feat(wallpaper): support configurable background color (#2671)

* feat(wallpaper): support configurable background color

* chore(translations): update settings search index

* revert(wallpaper): keep Pad naming instead of Center

.gitignore

@@ -117,3 +117,9 @@ quickshell/dms-plugins
 __pycache__
 
 .vscode/
+
+# Void (xbps) build artifacts
+*.xbps
+distro/void/temp/
+distro/void/hostdir/
+distro/void/masterdir*/

.pre-commit-config.yaml

@@ -20,6 +20,14 @@ repos:
         language: system
         files: ^core/.*\.(go|mod|sum)$
         pass_filenames: false
+  - repo: local
+    hooks:
+      - id: settings-search-index
+        name: settings search index is up to date
+        entry: bash -c 'python3 quickshell/translations/extract_settings_index.py >/dev/null || exit 1; if ! git diff --exit-code -- quickshell/translations/settings_search_index.json; then echo "settings_search_index.json is out of date; run quickshell/translations/extract_settings_index.py and stage the result" >&2; exit 1; fi'
+        language: system
+        files: ^quickshell/(Modules/Settings/.*\.qml|Modals/Settings/SettingsSidebar\.qml|translations/extract_settings_index\.py)$
+        pass_filenames: false
   - repo: local
     hooks:
       - id: no-console-in-qml

core/cmd/dms/commands_greeter.go

@@ -299,7 +299,7 @@ func installGreeter(nonInteractive bool) error {
 
 	fmt.Println("\n=== Installation Complete ===")
 	fmt.Println("\nTo start the greeter now, run:")
-	fmt.Println("  sudo systemctl start greetd")
+	fmt.Println(startGreeterHint())
 	fmt.Println("\nOr reboot to see the greeter at next boot.")
 
 	return nil
@@ -326,7 +326,13 @@ func uninstallGreeter(nonInteractive bool) error {
 	}
 
 	fmt.Println("\nDisabling greetd...")
-	if err := privesc.Run(context.Background(), "", "systemctl", "disable", "greetd"); err != nil {
+	if isRunit() {
+		if err := disableRunitService("greetd"); err != nil {
+			fmt.Printf("  ⚠ Could not disable greetd: %v\n", err)
+		} else {
+			fmt.Println("  ✓ greetd disabled")
+		}
+	} else if err := privesc.Run(context.Background(), "", "systemctl", "disable", "greetd"); err != nil {
 		fmt.Printf("  ⚠ Could not disable greetd: %v\n", err)
 	} else {
 		fmt.Println("  ✓ greetd disabled")
@@ -449,6 +455,14 @@ func suggestDisplayManagerRestore(nonInteractive bool) {
 
 	enableDM := func(dm string) {
 		fmt.Printf("  Enabling %s...\n", dm)
+		if isRunit() {
+			if err := enableRunitService(dm); err != nil {
+				fmt.Printf("  ⚠ Failed to enable %s: %v\n", dm, err)
+			} else {
+				fmt.Printf("  ✓ %s enabled (linked into %s).\n", dm, runitServiceDir)
+			}
+			return
+		}
 		if err := privesc.Run(context.Background(), "", "systemctl", "enable", "--force", dm); err != nil {
 			fmt.Printf("  ⚠ Failed to enable %s: %v\n", dm, err)
 		} else {
@@ -495,6 +509,9 @@ func suggestDisplayManagerRestore(nonInteractive bool) {
 }
 
 func isSystemdUnitInstalled(unit string) bool {
+	if isRunit() {
+		return runitServiceInstalled(unit)
+	}
 	cmd := exec.Command("systemctl", "list-unit-files", unit+".service", "--no-legend", "--no-pager")
 	out, err := cmd.Output()
 	return err == nil && strings.Contains(string(out), unit)
@@ -943,6 +960,18 @@ func resolveLocalDMSPath() (string, error) {
 }
 
 func disableDisplayManager(dmName string) (bool, error) {
+	if isRunit() {
+		if !runitServiceEnabled(dmName) {
+			return false, nil
+		}
+		fmt.Printf("\nDisabling %s (runit)...\n", dmName)
+		if err := disableRunitService(dmName); err != nil {
+			return false, fmt.Errorf("failed to disable %s: %w", dmName, err)
+		}
+		fmt.Printf("  ✓ %s disabled (removed from %s)\n", dmName, runitServiceDir)
+		return true, nil
+	}
+
 	state, err := getSystemdServiceState(dmName)
 	if err != nil {
 		return false, fmt.Errorf("failed to check %s state: %w", dmName, err)
@@ -996,6 +1025,21 @@ func disableDisplayManager(dmName string) (bool, error) {
 }
 
 func ensureGreetdEnabled() error {
+	if isRunit() {
+		fmt.Println("\nEnabling greetd service (runit)...")
+		if !runitServiceInstalled("greetd") {
+			return fmt.Errorf("greetd service not found in %s. Please install greetd first", runitSvDir)
+		}
+		// Seat + runtime-dir setup that logind handles automatically on systemd.
+		ensureRunitSeat("_greeter")
+		ensureGreetdPamRundir()
+		if err := enableRunitService("greetd"); err != nil {
+			return fmt.Errorf("failed to enable greetd: %w", err)
+		}
+		fmt.Printf("  ✓ greetd enabled (%s)\n", runitServiceDir)
+		return nil
+	}
+
 	fmt.Println("\nChecking greetd service status...")
 
 	state, err := getSystemdServiceState("greetd")
@@ -1043,6 +1087,12 @@ func ensureGreetdEnabled() error {
 }
 
 func ensureGraphicalTarget() error {
+	if isRunit() {
+		// runit has no targets; a supervised greetd service is the graphical
+		// login, so there is nothing to set here.
+		return nil
+	}
+
 	getDefaultCmd := exec.Command("systemctl", "get-default")
 	currentTarget, err := getDefaultCmd.Output()
 	if err != nil {
@@ -1176,7 +1226,7 @@ func enableGreeter(nonInteractive bool) error {
 		fmt.Println("\n=== Enable Complete ===")
 		fmt.Println("\nGreeter configuration verified and system state corrected.")
 		fmt.Println("To start the greeter now, run:")
-		fmt.Println("  sudo systemctl start greetd")
+		fmt.Println(startGreeterHint())
 		fmt.Println("\nOr reboot to see the greeter at boot time.")
 
 		return nil
@@ -1257,7 +1307,7 @@ func enableGreeter(nonInteractive bool) error {
 
 	fmt.Println("\n=== Enable Complete ===")
 	fmt.Println("\nTo start the greeter now, run:")
-	fmt.Println("  sudo systemctl start greetd")
+	fmt.Println(startGreeterHint())
 	fmt.Println("\nOr reboot to see the greeter at boot time.")
 
 	return nil

core/cmd/dms/init_service.go

@@ -0,0 +1,114 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/privesc"
+)
+
+// runit (Void Linux) service helpers. Services live in /etc/sv and are "enabled"
+// by symlinking them into the /var/service supervision dir, so the greeter
+// commands branch on isRunit() instead of shelling systemctl.
+
+const (
+	runitSvDir      = "/etc/sv"
+	runitServiceDir = "/var/service"
+)
+
+// isRunit reports whether this system is supervised by runit (Void Linux).
+func isRunit() bool {
+	if fi, err := os.Stat("/run/runit"); err == nil && fi.IsDir() {
+		return true
+	}
+	if _, err := os.Stat("/run/systemd/system"); err == nil {
+		return false
+	}
+	if fi, err := os.Stat(runitServiceDir); err == nil && fi.IsDir() {
+		return true
+	}
+	return false
+}
+
+func runitServiceInstalled(name string) bool {
+	fi, err := os.Stat(runitSvDir + "/" + name)
+	return err == nil && fi.IsDir()
+}
+
+func runitServiceEnabled(name string) bool {
+	_, err := os.Lstat(runitServiceDir + "/" + name)
+	return err == nil
+}
+
+// enableRunitService links a service into /var/service (idempotent).
+func enableRunitService(name string) error {
+	if !runitServiceInstalled(name) {
+		return fmt.Errorf("runit service %q not found in %s", name, runitSvDir)
+	}
+	if runitServiceEnabled(name) {
+		return nil
+	}
+	return privesc.Run(context.Background(), "", "ln", "-sf",
+		runitSvDir+"/"+name, runitServiceDir+"/"+name)
+}
+
+// disableRunitService removes a service's supervision symlink.
+func disableRunitService(name string) error {
+	if !runitServiceEnabled(name) {
+		return nil
+	}
+	return privesc.Run(context.Background(), "", "rm", "-f",
+		runitServiceDir+"/"+name)
+}
+
+// ensureRunitSeat sets up the seat access a Wayland greeter needs on runit (the
+// equivalent of logind on systemd): enables seatd and adds the greeter user to
+// the seat/video/input groups. Failures are reported but non-fatal.
+func ensureRunitSeat(greeterUser string) {
+	if runitServiceInstalled("seatd") {
+		if err := enableRunitService("seatd"); err != nil {
+			fmt.Printf("  ⚠ could not enable seatd: %v\n", err)
+		} else {
+			fmt.Println("  ✓ seatd enabled")
+		}
+	} else {
+		fmt.Println("  ⚠ seatd not installed — the greeter compositor needs it for GPU/seat access")
+	}
+	if err := privesc.Run(context.Background(), "", "usermod", "-aG", "_seatd,video,input", greeterUser); err != nil {
+		fmt.Printf("  ⚠ could not add %s to seat groups: %v\n", greeterUser, err)
+	} else {
+		fmt.Printf("  ✓ %s added to seat groups (_seatd, video, input)\n", greeterUser)
+	}
+}
+
+// ensureGreetdPamRundir adds pam_rundir to the greetd PAM stack so the post-login
+// session gets an XDG_RUNTIME_DIR on systems without logind (Void with seatd).
+// Appended outside DMS's managed auth block so it survives `dms greeter sync`.
+func ensureGreetdPamRundir() {
+	const pamPath = "/etc/pam.d/greetd"
+	data, err := os.ReadFile(pamPath)
+	if err != nil {
+		fmt.Printf("  ⚠ could not read %s: %v\n", pamPath, err)
+		return
+	}
+	if strings.Contains(string(data), "pam_rundir") {
+		return
+	}
+	line := "session    optional    pam_rundir.so"
+	if err := privesc.Run(context.Background(), "", "sh", "-c",
+		fmt.Sprintf("printf '%%s\\n' %q >> %s", line, pamPath)); err != nil {
+		fmt.Printf("  ⚠ could not add pam_rundir to %s: %v\n", pamPath, err)
+		return
+	}
+	fmt.Println("  ✓ pam_rundir added to greetd PAM (provides XDG_RUNTIME_DIR for the session)")
+}
+
+// startGreeterHint returns the init-appropriate "start greetd now" command.
+func startGreeterHint() string {
+	if isRunit() {
+		return "  sudo sv up greetd"
+	}
+	return "  sudo systemctl start greetd"
+}

core/internal/keybinds/providers/niri_parser.go

@@ -51,7 +51,7 @@ type NiriParser struct {
 }
 
 func parseKDL(data []byte) (*document.Document, error) {
-	return kdl.Parse(strings.NewReader(normalizeKDLBraces(string(data))))
+	return kdl.Parse(strings.NewReader(normalizeKDLBraces(quoteLeadingUnderscoreIdents(string(data)))))
 }
 
 func normalizeKDLBraces(input string) string {
@@ -94,6 +94,93 @@ func normalizeKDLBraces(input string) string {
 	return sb.String()
 }
 
+// quoteLeadingUnderscoreIdents wraps bare KDL identifiers that begin with '_'
+// in double quotes. kdl-go rejects '_' as the first character of a bare
+// identifier (e.g. the common `_JAVA_AWT_WM_NONREPARENTING "1"` environment
+// node), even though niri's own parser and the KDL spec accept it — so without
+// this the whole config fails to parse and no keybinds load. Quoting lets
+// kdl-go parse it; this is safe because the niri parser only dispatches on
+// fixed node/section names (binds, recent-windows, include, ...) that never
+// start with '_', so re-quoting such a name cannot change what DMS reads.
+// Underscores elsewhere in an identifier (XDG_CURRENT_DESKTOP) are left
+// untouched, and underscores inside strings or comments are skipped. Only a
+// leading '_' is handled; other start characters kdl-go over-rejects (e.g. '.'
+// or '?') do not occur in niri configs.
+func quoteLeadingUnderscoreIdents(input string) string {
+	var sb strings.Builder
+	sb.Grow(len(input))
+
+	var prev byte
+	n := len(input)
+	for i := 0; i < n; {
+		c := input[i]
+
+		switch {
+		case c == '"':
+			end := findStringEnd(input, i)
+			sb.WriteString(input[i:end])
+			prev = '"'
+			i = end
+		case c == '/' && i+1 < n && input[i+1] == '/':
+			end := findLineCommentEnd(input, i)
+			sb.WriteString(input[i:end])
+			prev = '\n'
+			i = end
+		case c == '/' && i+1 < n && input[i+1] == '*':
+			end := findBlockCommentEnd(input, i)
+			sb.WriteString(input[i:end])
+			prev = ' '
+			i = end
+		case c == '/' && i+1 < n && input[i+1] == '-':
+			// KDL slashdash: /- comments out the next node/value. Keep the
+			// marker but treat what follows as a fresh token start, so a
+			// slashdashed leading-underscore node (e.g. `/-_FOO "1"`) still
+			// gets quoted instead of crashing kdl-go.
+			sb.WriteByte('/')
+			sb.WriteByte('-')
+			prev = ' '
+			i += 2
+		case c == '_' && isIdentBoundary(prev):
+			end := scanBareIdent(input, i)
+			sb.WriteByte('"')
+			sb.WriteString(input[i:end])
+			sb.WriteByte('"')
+			prev = '"'
+			i = end
+		default:
+			sb.WriteByte(c)
+			prev = c
+			i++
+		}
+	}
+
+	return sb.String()
+}
+
+// isIdentBoundary reports whether the previously emitted byte ends a token, so
+// that a following '_' starts a fresh bare identifier rather than sitting in
+// the middle of one.
+func isIdentBoundary(prev byte) bool {
+	switch prev {
+	case 0, ' ', '\t', '\n', '\r', '{', '}', ';', '=', '(', ')', ',':
+		return true
+	}
+	return false
+}
+
+// scanBareIdent returns the index just past the bare identifier starting at
+// start, stopping at whitespace or any KDL delimiter.
+func scanBareIdent(s string, start int) int {
+	n := len(s)
+	for i := start; i < n; i++ {
+		switch s[i] {
+		case ' ', '\t', '\n', '\r', '"', '{', '}', '(', ')', ';', '=', ',', '/', '\\', '<', '>', '[', ']':
+			return i
+		}
+	}
+	return n
+}
+
 func findStringEnd(s string, start int) int {
 	n := len(s)
 	for i := start + 1; i < n; {

core/internal/keybinds/providers/niri_parser_test.go

@@ -71,6 +71,101 @@ func TestNormalizeKDLBraces(t *testing.T) {
 	}
 }
 
+func TestQuoteLeadingUnderscoreIdents(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		out  string
+	}{
+		{"leading underscore node", `_JAVA_AWT_WM_NONREPARENTING "1"`, `"_JAVA_AWT_WM_NONREPARENTING" "1"`},
+		{"mid underscore untouched", `XDG_CURRENT_DESKTOP "niri"`, `XDG_CURRENT_DESKTOP "niri"`},
+		{"indented node", "environment {\n  _FOO \"1\"\n}", "environment {\n  \"_FOO\" \"1\"\n}"},
+		{"underscore in string", `spawn "_not_a_node"`, `spawn "_not_a_node"`},
+		{"underscore in line comment", "// _comment\n_FOO \"1\"", "// _comment\n\"_FOO\" \"1\""},
+		{"underscore in block comment", "/* _x */ _FOO \"1\"", "/* _x */ \"_FOO\" \"1\""},
+		{"block comment abuts node", `/* x */_FOO "1"`, `/* x */"_FOO" "1"`},
+		{"slashdash before node", `/-_FOO "1"`, `/-"_FOO" "1"`},
+		{"node after closing paren", "node (u8)_v", `node (u8)"_v"`},
+		{"node before brace without space", "_FOO{ }", `"_FOO"{ }`},
+		{"lone underscore", `_ "x"`, `"_" "x"`},
+		{"property value", "node key=_val", `node key="_val"`},
+		{"no underscores", "node child", "node child"},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := quoteLeadingUnderscoreIdents(tc.in)
+			if got != tc.out {
+				t.Errorf("quoteLeadingUnderscoreIdents(%q) = %q, want %q", tc.in, got, tc.out)
+			}
+		})
+	}
+}
+
+func TestNiriParseLeadingUnderscoreEnvironment(t *testing.T) {
+	tmpDir := t.TempDir()
+	configFile := filepath.Join(tmpDir, "config.kdl")
+
+	// A leading-underscore environment node (a common Java/tiling-WM fix) must
+	// not abort parsing of the rest of the config — keybinds still have to load.
+	content := `environment {
+    XDG_CURRENT_DESKTOP "niri"
+    _JAVA_AWT_WM_NONREPARENTING "1"
+}
+binds {
+    Mod+Q { close-window; }
+    Mod+KP_Home { focus-workspace 1; }
+}
+`
+	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+		t.Fatalf("Failed to write test config: %v", err)
+	}
+
+	result, err := ParseNiriKeys(tmpDir)
+	if err != nil {
+		t.Fatalf("ParseNiriKeys failed on config with leading-underscore env node: %v", err)
+	}
+
+	if len(result.Section.Keybinds) != 2 {
+		t.Errorf("Expected 2 keybinds, got %d", len(result.Section.Keybinds))
+	}
+
+	foundClose := false
+	for _, kb := range result.Section.Keybinds {
+		if kb.Action == "close-window" {
+			foundClose = true
+		}
+	}
+	if !foundClose {
+		t.Error("close-window keybind not found — leading-underscore env node broke parsing")
+	}
+}
+
+func TestNiriParseSlashdashLeadingUnderscore(t *testing.T) {
+	tmpDir := t.TempDir()
+	configFile := filepath.Join(tmpDir, "config.kdl")
+
+	// A slashdashed leading-underscore node must not abort parsing either.
+	content := `environment {
+    /-_JAVA_AWT_WM_NONREPARENTING "1"
+}
+binds {
+    Mod+Q { close-window; }
+}
+`
+	if err := os.WriteFile(configFile, []byte(content), 0o644); err != nil {
+		t.Fatalf("Failed to write test config: %v", err)
+	}
+
+	result, err := ParseNiriKeys(tmpDir)
+	if err != nil {
+		t.Fatalf("ParseNiriKeys failed on config with slashdashed leading-underscore node: %v", err)
+	}
+
+	if len(result.Section.Keybinds) != 1 {
+		t.Errorf("Expected 1 keybind, got %d", len(result.Section.Keybinds))
+	}
+}
+
 func TestNiriParseKeyCombo(t *testing.T) {
 	tests := []struct {
 		combo        string

core/internal/server/network/API.md

@@ -125,6 +125,8 @@ State updates are sent whenever network configuration changes:
 - `wifiConnected`: Whether associated with an access point
 - `wifiSSID`: Currently connected network name
 - `wifiIP`: Assigned IP address (empty until DHCP completes)
+- `savedWifiNetworks` (API v26+): Saved WiFi profiles exposed at SSID granularity. If a backend has multiple profiles for the same SSID, DMS merges them into one SSID-level entry. Clients talking to older servers should derive saved visible networks from `wifiNetworks` entries where `saved` is true.
+- `savedWifiNetworks[].outOfRange` (API v26+): Whether the saved profile is not currently visible in scan results. Fallback entries derived from `wifiNetworks` should be treated as visible (`outOfRange: false`).
 - `lastError`: Error message from last failed connection attempt
 
 ### network.credentials Service Events

core/internal/server/network/backend.go

@@ -67,6 +67,7 @@ type BackendState struct {
 	WiFiBSSID              string
 	WiFiSignal             uint8
 	WiFiNetworks           []WiFiNetwork
+	SavedWiFiNetworks      []WiFiNetwork
 	WiFiDevices            []WiFiDevice
 	WiredConnections       []WiredConnection
 	VPNProfiles            []VPNProfile

core/internal/server/network/backend_hybrid_test.go

@@ -27,6 +27,19 @@ func TestHybridIwdNetworkdBackend_GetCurrentState_MergesState(t *testing.T) {
 	wifi.state.WiFiBSSID = "00:11:22:33:44:55"
 	wifi.state.WiFiSignal = 75
 	wifi.state.WiFiDevice = "wlan0"
+	wifi.state.SavedWiFiNetworks = []WiFiNetwork{
+		{
+			SSID:        "TestNetwork",
+			Saved:       true,
+			Autoconnect: true,
+			Connected:   true,
+		},
+		{
+			SSID:       "AwayNetwork",
+			Saved:      true,
+			OutOfRange: true,
+		},
+	}
 
 	l3.state.WiFiIP = "192.168.1.100"
 	l3.state.EthernetConnected = false
@@ -42,6 +55,9 @@ func TestHybridIwdNetworkdBackend_GetCurrentState_MergesState(t *testing.T) {
 	assert.True(t, state.WiFiConnected)
 	assert.False(t, state.EthernetConnected)
 	assert.Equal(t, StatusWiFi, state.NetworkStatus)
+	assert.Len(t, state.SavedWiFiNetworks, 2)
+	assert.Equal(t, "TestNetwork", state.SavedWiFiNetworks[0].SSID)
+	assert.True(t, state.SavedWiFiNetworks[1].OutOfRange)
 }
 
 func TestHybridIwdNetworkdBackend_GetCurrentState_EthernetPriority(t *testing.T) {

core/internal/server/network/backend_iwd.go

@@ -80,6 +80,10 @@ func (b *IWDBackend) Initialize() error {
 		return fmt.Errorf("failed to discover iwd devices: %w", err)
 	}
 
+	if err := b.updateSavedWiFiNetworks(); err != nil {
+		log.Warnf("Failed to get initial saved WiFi networks: %v", err)
+	}
+
 	if err := b.updateState(); err != nil {
 		conn.Close()
 		return fmt.Errorf("failed to get initial state: %w", err)
@@ -145,6 +149,7 @@ func (b *IWDBackend) GetCurrentState() (*BackendState, error) {
 
 	state := *b.state
 	state.WiFiNetworks = append([]WiFiNetwork(nil), b.state.WiFiNetworks...)
+	state.SavedWiFiNetworks = append([]WiFiNetwork(nil), b.state.SavedWiFiNetworks...)
 	state.WiredConnections = append([]WiredConnection(nil), b.state.WiredConnections...)
 	state.WiFiDevices = b.getWiFiDevicesLocked()
 

core/internal/server/network/backend_iwd_signals.go

@@ -45,12 +45,42 @@ func (b *IWDBackend) StartMonitoring(onStateChange func()) error {
 		}
 	}
 
+	if err := b.conn.AddMatchSignal(
+		dbus.WithMatchInterface(dbusPropertiesInterface),
+		dbus.WithMatchMember("PropertiesChanged"),
+		dbus.WithMatchArg(0, iwdKnownNetworkInterface),
+	); err != nil {
+		return fmt.Errorf("failed to add known network signal match: %w", err)
+	}
+
+	if err := b.conn.AddMatchSignal(
+		dbus.WithMatchInterface(dbusObjectManager),
+		dbus.WithMatchMember("InterfacesAdded"),
+	); err != nil {
+		return fmt.Errorf("failed to add iwd interfaces-added signal match: %w", err)
+	}
+
+	if err := b.conn.AddMatchSignal(
+		dbus.WithMatchInterface(dbusObjectManager),
+		dbus.WithMatchMember("InterfacesRemoved"),
+	); err != nil {
+		return fmt.Errorf("failed to add iwd interfaces-removed signal match: %w", err)
+	}
+
 	b.sigWG.Add(1)
 	go b.signalHandler(sigChan)
 
 	return nil
 }
 
+func (b *IWDBackend) refreshWiFiNetworkState() bool {
+	_, err := b.updateWiFiNetworks()
+	if err == nil {
+		return true
+	}
+	return b.updateSavedWiFiNetworks() == nil
+}
+
 func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 	defer b.sigWG.Done()
 
@@ -66,11 +96,36 @@ func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 				return
 			}
 
-			if sig.Name != dbusPropertiesInterface+".PropertiesChanged" {
+			if sig.Name == dbusObjectManager+".InterfacesAdded" {
+				if len(sig.Body) >= 2 {
+					if interfaces, ok := sig.Body[1].(map[string]map[string]dbus.Variant); ok {
+						if _, ok := interfaces[iwdKnownNetworkInterface]; ok {
+							if b.refreshWiFiNetworkState() && b.onStateChange != nil {
+								b.onStateChange()
+							}
+						}
+					}
+				}
 				continue
 			}
 
-			if len(sig.Body) < 2 {
+			if sig.Name == dbusObjectManager+".InterfacesRemoved" {
+				if len(sig.Body) >= 2 {
+					if interfaces, ok := sig.Body[1].([]string); ok {
+						for _, iface := range interfaces {
+							if iface == iwdKnownNetworkInterface {
+								if b.refreshWiFiNetworkState() && b.onStateChange != nil {
+									b.onStateChange()
+								}
+								break
+							}
+						}
+					}
+				}
+				continue
+			}
+
+			if sig.Name != dbusPropertiesInterface+".PropertiesChanged" || len(sig.Body) < 2 {
 				continue
 			}
 
@@ -87,6 +142,9 @@ func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 			stateChanged := false
 
 			switch iface {
+			case iwdKnownNetworkInterface:
+				stateChanged = b.refreshWiFiNetworkState()
+
 			case iwdDeviceInterface:
 				if sig.Path == b.devicePath {
 					if poweredVar, ok := changed["Powered"]; ok {
@@ -105,13 +163,7 @@ func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 				if sig.Path == b.stationPath {
 					if scanningVar, ok := changed["Scanning"]; ok {
 						if scanning, ok := scanningVar.Value().(bool); ok && !scanning {
-							networks, err := b.updateWiFiNetworks()
+							stateChanged = b.refreshWiFiNetworkState() || stateChanged
-							if err == nil {
-								b.stateMutex.Lock()
-								b.state.WiFiNetworks = networks
-								b.stateMutex.Unlock()
-								stateChanged = true
-							}
 
 							b.stateMutex.RLock()
 							wifiConnected := b.state.WiFiConnected
@@ -236,6 +288,7 @@ func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 									}
 								}
 
+								b.refreshWiFiNetworkState()
 								stateChanged = true
 
 								if att != nil && isTarget {
@@ -282,6 +335,7 @@ func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 									b.state.NetworkStatus = StatusDisconnected
 								}
 								b.stateMutex.Unlock()
+								b.refreshWiFiNetworkState()
 								stateChanged = true
 							}
 						}
@@ -342,6 +396,7 @@ func (b *IWDBackend) signalHandler(sigChan chan *dbus.Signal) {
 								stateChanged = true
 							}
 							b.stateMutex.Unlock()
+							b.refreshWiFiNetworkState()
 						}
 					}
 				}

core/internal/server/network/backend_iwd_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/godbus/dbus/v5"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -168,6 +169,92 @@ func TestIWDBackend_MapIwdDBusError(t *testing.T) {
 	}
 }
 
+func TestIWDSavedWiFiProfilesFromManagedObjects(t *testing.T) {
+	objects := map[dbus.ObjectPath]map[string]map[string]dbus.Variant{
+		"/net/connman/iwd/known_network/1": {
+			iwdKnownNetworkInterface: {
+				"Name":        dbus.MakeVariant("Home"),
+				"AutoConnect": dbus.MakeVariant(false),
+				"Hidden":      dbus.MakeVariant(true),
+				"Type":        dbus.MakeVariant("psk"),
+			},
+		},
+		"/net/connman/iwd/known_network/2": {
+			iwdKnownNetworkInterface: {
+				"Name": dbus.MakeVariant("Office"),
+				"Type": dbus.MakeVariant("8021x"),
+			},
+		},
+		"/net/connman/iwd/known_network/3": {
+			iwdKnownNetworkInterface: {
+				"Name": dbus.MakeVariant("Cafe"),
+				"Type": dbus.MakeVariant("open"),
+			},
+		},
+		"/net/connman/iwd/network/1": {
+			iwdNetworkInterface: {
+				"Name": dbus.MakeVariant("VisibleOnly"),
+			},
+		},
+	}
+
+	profiles := iwdSavedWiFiProfilesFromManagedObjects(objects)
+
+	assert.Len(t, profiles, 3)
+	assert.False(t, profiles["Home"].Autoconnect)
+	assert.True(t, profiles["Home"].Hidden)
+	assert.True(t, profiles["Home"].Secured)
+	assert.False(t, profiles["Home"].Enterprise)
+
+	assert.True(t, profiles["Office"].Autoconnect)
+	assert.True(t, profiles["Office"].Secured)
+	assert.True(t, profiles["Office"].Enterprise)
+
+	assert.True(t, profiles["Cafe"].Autoconnect)
+	assert.False(t, profiles["Cafe"].Secured)
+	assert.False(t, profiles["Cafe"].Enterprise)
+}
+
+func TestIWDWiFiNetworksFromVisibleIncludesConnectedHiddenFallback(t *testing.T) {
+	profiles := map[string]savedWiFiProfile{
+		"Home": {
+			Autoconnect: true,
+			Secured:     true,
+			Hidden:      true,
+			Mode:        "infrastructure",
+		},
+	}
+	visible := []WiFiNetwork{
+		{
+			SSID:    "Cafe",
+			Signal:  42,
+			Secured: false,
+		},
+	}
+
+	networks := iwdWiFiNetworksFromVisible(visible, profiles, "Home", true, 68)
+	savedNetworks := savedWiFiNetworksFromProfiles(profiles, map[string]WiFiNetwork{
+		networks[0].SSID: networks[0],
+		networks[1].SSID: networks[1],
+	}, "Home", true)
+
+	assert.Len(t, networks, 2)
+	assert.Equal(t, "Cafe", networks[0].SSID)
+	assert.False(t, networks[0].Connected)
+
+	assert.Equal(t, "Home", networks[1].SSID)
+	assert.True(t, networks[1].Connected)
+	assert.True(t, networks[1].Hidden)
+	assert.True(t, networks[1].Saved)
+	assert.True(t, networks[1].Autoconnect)
+	assert.Equal(t, uint8(68), networks[1].Signal)
+
+	assert.Len(t, savedNetworks, 1)
+	assert.Equal(t, "Home", savedNetworks[0].SSID)
+	assert.True(t, savedNetworks[0].Connected)
+	assert.False(t, savedNetworks[0].OutOfRange)
+}
+
 func TestConnectAttempt_Finalization(t *testing.T) {
 	backend, _ := NewIWDBackend()
 	backend.state = &BackendState{}

core/internal/server/network/backend_iwd_wifi.go

@@ -164,22 +164,18 @@ func (b *IWDBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 		return nil, fmt.Errorf("failed to get networks: %w", err)
 	}
 
-	knownNetworks, err := b.getKnownNetworks()
+	savedProfiles, err := b.getIWDSavedWiFiProfiles()
 	if err != nil {
-		knownNetworks = make(map[string]bool)
+		savedProfiles = make(map[string]savedWiFiProfile)
-	}
-
-	autoconnectMap, err := b.getAutoconnectSettings()
-	if err != nil {
-		autoconnectMap = make(map[string]bool)
 	}
 
 	b.stateMutex.RLock()
 	currentSSID := b.state.WiFiSSID
 	wifiConnected := b.state.WiFiConnected
+	wifiSignal := b.state.WiFiSignal
 	b.stateMutex.RUnlock()
 
-	networks := make([]WiFiNetwork, 0, len(orderedNetworks))
+	visibleNetworks := make([]WiFiNetwork, 0, len(orderedNetworks))
 	for _, netData := range orderedNetworks {
 		if len(netData) < 2 {
 			continue
@@ -225,23 +221,26 @@ func (b *IWDBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 
 		secured := netType != "open"
 
-		network := WiFiNetwork{
+		visibleNetworks = append(visibleNetworks, WiFiNetwork{
-			SSID:        name,
+			SSID:       name,
-			Signal:      signal,
+			Signal:     signal,
-			Secured:     secured,
+			Secured:    secured,
-			Connected:   wifiConnected && name == currentSSID,
+			Enterprise: netType == "8021x",
-			Saved:       knownNetworks[name],
+		})
-			Autoconnect: autoconnectMap[name],
-			Enterprise:  netType == "8021x",
-		}
-
-		networks = append(networks, network)
 	}
 
+	networks := iwdWiFiNetworksFromVisible(visibleNetworks, savedProfiles, currentSSID, wifiConnected, wifiSignal)
+	visibleNetworkMap := make(map[string]WiFiNetwork, len(networks))
+	for _, network := range networks {
+		visibleNetworkMap[network.SSID] = network
+	}
+	savedNetworks := savedWiFiNetworksFromProfiles(savedProfiles, visibleNetworkMap, currentSSID, wifiConnected)
+
 	sortWiFiNetworks(networks)
 
 	b.stateMutex.Lock()
 	b.state.WiFiNetworks = networks
+	b.state.SavedWiFiNetworks = savedNetworks
 	b.stateMutex.Unlock()
 
 	now := time.Now()
@@ -254,30 +253,129 @@ func (b *IWDBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 	return networks, nil
 }
 
-func (b *IWDBackend) getKnownNetworks() (map[string]bool, error) {
+func (b *IWDBackend) updateSavedWiFiNetworks() error {
-	obj := b.conn.Object(iwdBusName, iwdObjectPath)
+	savedProfiles, err := b.getIWDSavedWiFiProfiles()
-
-	var objects map[dbus.ObjectPath]map[string]map[string]dbus.Variant
-	err := obj.Call(dbusObjectManager+".GetManagedObjects", 0).Store(&objects)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	known := make(map[string]bool)
+	b.stateMutex.RLock()
-	for _, interfaces := range objects {
+	currentSSID := b.state.WiFiSSID
-		if knownProps, ok := interfaces[iwdKnownNetworkInterface]; ok {
+	wifiConnected := b.state.WiFiConnected
-			if nameVar, ok := knownProps["Name"]; ok {
+	wifiNetworks := append([]WiFiNetwork(nil), b.state.WiFiNetworks...)
-				if name, ok := nameVar.Value().(string); ok {
+	b.stateMutex.RUnlock()
-					known[name] = true
-				}
-			}
-		}
-	}
 
-	return known, nil
+	wifiNetworks, savedNetworks := refreshSavedWiFiState(wifiNetworks, savedProfiles, currentSSID, wifiConnected)
+
+	b.stateMutex.Lock()
+	b.state.WiFiNetworks = wifiNetworks
+	b.state.SavedWiFiNetworks = savedNetworks
+	b.stateMutex.Unlock()
+
+	return nil
 }
 
-func (b *IWDBackend) getAutoconnectSettings() (map[string]bool, error) {
+func iwdWiFiNetworksFromVisible(visibleNetworks []WiFiNetwork, savedProfiles map[string]savedWiFiProfile, currentSSID string, wifiConnected bool, wifiSignal uint8) []WiFiNetwork {
+	networks := make([]WiFiNetwork, 0, len(visibleNetworks)+1)
+	seenSSIDs := make(map[string]struct{}, len(visibleNetworks)+1)
+
+	for _, network := range visibleNetworks {
+		profile, saved := savedProfiles[network.SSID]
+		network.Connected = wifiConnected && network.SSID == currentSSID
+		network.Saved = saved
+		network.Autoconnect = profile.Autoconnect
+		network.Hidden = network.Hidden || profile.Hidden
+		network.Secured = network.Secured || profile.Secured
+		network.Enterprise = network.Enterprise || profile.Enterprise
+		if network.Mode == "" {
+			network.Mode = profile.Mode
+		}
+		networks = append(networks, network)
+		seenSSIDs[network.SSID] = struct{}{}
+	}
+
+	if wifiConnected && currentSSID != "" {
+		if _, exists := seenSSIDs[currentSSID]; !exists {
+			profile, saved := savedProfiles[currentSSID]
+			secured := profile.Secured
+			if !saved {
+				secured = true
+			}
+			mode := profile.Mode
+			if mode == "" {
+				mode = "infrastructure"
+			}
+
+			networks = append(networks, WiFiNetwork{
+				SSID:        currentSSID,
+				Signal:      wifiSignal,
+				Secured:     secured,
+				Enterprise:  profile.Enterprise,
+				Connected:   true,
+				Saved:       saved,
+				Autoconnect: profile.Autoconnect,
+				Hidden:      true,
+				Mode:        mode,
+			})
+		}
+	}
+
+	return networks
+}
+
+func iwdSavedWiFiProfilesFromManagedObjects(objects map[dbus.ObjectPath]map[string]map[string]dbus.Variant) map[string]savedWiFiProfile {
+	profiles := make(map[string]savedWiFiProfile)
+
+	for _, interfaces := range objects {
+		knownProps, ok := interfaces[iwdKnownNetworkInterface]
+		if !ok {
+			continue
+		}
+
+		nameVar, ok := knownProps["Name"]
+		if !ok {
+			continue
+		}
+		name, ok := nameVar.Value().(string)
+		if !ok || name == "" {
+			continue
+		}
+
+		profile := savedWiFiProfile{
+			Autoconnect: true,
+			Mode:        "infrastructure",
+		}
+		if acVar, ok := knownProps["AutoConnect"]; ok {
+			if autoconnect, ok := acVar.Value().(bool); ok {
+				profile.Autoconnect = autoconnect
+			}
+		}
+		if hiddenVar, ok := knownProps["Hidden"]; ok {
+			if hidden, ok := hiddenVar.Value().(bool); ok {
+				profile.Hidden = hidden
+			}
+		}
+		if typeVar, ok := knownProps["Type"]; ok {
+			if networkType, ok := typeVar.Value().(string); ok {
+				profile.Secured = networkType != "" && networkType != "open"
+				profile.Enterprise = networkType == "8021x"
+			}
+		}
+
+		if existing, ok := profiles[name]; ok {
+			profile.Autoconnect = profile.Autoconnect || existing.Autoconnect
+			profile.Hidden = profile.Hidden || existing.Hidden
+			profile.Secured = profile.Secured || existing.Secured
+			profile.Enterprise = profile.Enterprise || existing.Enterprise
+		}
+
+		profiles[name] = profile
+	}
+
+	return profiles
+}
+
+func (b *IWDBackend) getIWDSavedWiFiProfiles() (map[string]savedWiFiProfile, error) {
 	obj := b.conn.Object(iwdBusName, iwdObjectPath)
 
 	var objects map[dbus.ObjectPath]map[string]map[string]dbus.Variant
@@ -286,24 +384,7 @@ func (b *IWDBackend) getAutoconnectSettings() (map[string]bool, error) {
 		return nil, err
 	}
 
-	autoconnectMap := make(map[string]bool)
+	return iwdSavedWiFiProfilesFromManagedObjects(objects), nil
-	for _, interfaces := range objects {
-		if knownProps, ok := interfaces[iwdKnownNetworkInterface]; ok {
-			if nameVar, ok := knownProps["Name"]; ok {
-				if name, ok := nameVar.Value().(string); ok {
-					autoconnect := true
-					if acVar, ok := knownProps["AutoConnect"]; ok {
-						if ac, ok := acVar.Value().(bool); ok {
-							autoconnect = ac
-						}
-					}
-					autoconnectMap[name] = autoconnect
-				}
-			}
-		}
-	}
-
-	return autoconnectMap, nil
 }
 
 func (b *IWDBackend) GetWiFiNetworkDetails(ssid string) (*NetworkInfoResponse, error) {
@@ -614,6 +695,8 @@ func (b *IWDBackend) ForgetWiFiNetwork(ssid string) error {
 						b.stateMutex.Unlock()
 					}
 
+					_, _ = b.updateWiFiNetworks()
+
 					if b.onStateChange != nil {
 						b.onStateChange()
 					}

core/internal/server/network/backend_networkmanager.go

@@ -222,6 +222,10 @@ func (b *NetworkManagerBackend) Initialize() error {
 		log.Warnf("Failed to update WiFi state: %v", err)
 	}
 
+	if err := b.updateSavedWiFiNetworks(); err != nil {
+		log.Warnf("Failed to get initial saved WiFi networks: %v", err)
+	}
+
 	if wifiEnabled {
 		if _, err := b.updateWiFiNetworks(); err != nil {
 			log.Warnf("Failed to get initial networks: %v", err)
@@ -261,6 +265,7 @@ func (b *NetworkManagerBackend) GetCurrentState() (*BackendState, error) {
 
 	state := *b.state
 	state.WiFiNetworks = append([]WiFiNetwork(nil), b.state.WiFiNetworks...)
+	state.SavedWiFiNetworks = append([]WiFiNetwork(nil), b.state.SavedWiFiNetworks...)
 	state.WiFiDevices = append([]WiFiDevice(nil), b.state.WiFiDevices...)
 	state.WiredConnections = append([]WiredConnection(nil), b.state.WiredConnections...)
 	state.EthernetDevices = append([]EthernetDevice(nil), b.state.EthernetDevices...)

core/internal/server/network/backend_networkmanager_signals.go

@@ -5,6 +5,12 @@ import (
 	"github.com/godbus/dbus/v5"
 )
 
+const (
+	dbusNMSettingsPath                = "/org/freedesktop/NetworkManager/Settings"
+	dbusNMSettingsInterface           = "org.freedesktop.NetworkManager.Settings"
+	dbusNMSettingsConnectionInterface = "org.freedesktop.NetworkManager.Settings.Connection"
+)
+
 func (b *NetworkManagerBackend) startSignalPump() error {
 	conn, err := dbus.ConnectSystemBus()
 	if err != nil {
@@ -27,8 +33,8 @@ func (b *NetworkManagerBackend) startSignalPump() error {
 	}
 
 	if err := conn.AddMatchSignal(
-		dbus.WithMatchObjectPath(dbus.ObjectPath("/org/freedesktop/NetworkManager/Settings")),
+		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
-		dbus.WithMatchInterface("org.freedesktop.NetworkManager.Settings"),
+		dbus.WithMatchInterface(dbusNMSettingsInterface),
 		dbus.WithMatchMember("NewConnection"),
 	); err != nil {
 		conn.RemoveMatchSignal(
@@ -42,8 +48,8 @@ func (b *NetworkManagerBackend) startSignalPump() error {
 	}
 
 	if err := conn.AddMatchSignal(
-		dbus.WithMatchObjectPath(dbus.ObjectPath("/org/freedesktop/NetworkManager/Settings")),
+		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
-		dbus.WithMatchInterface("org.freedesktop.NetworkManager.Settings"),
+		dbus.WithMatchInterface(dbusNMSettingsInterface),
 		dbus.WithMatchMember("ConnectionRemoved"),
 	); err != nil {
 		conn.RemoveMatchSignal(
@@ -52,8 +58,8 @@ func (b *NetworkManagerBackend) startSignalPump() error {
 			dbus.WithMatchMember("PropertiesChanged"),
 		)
 		conn.RemoveMatchSignal(
-			dbus.WithMatchObjectPath(dbus.ObjectPath("/org/freedesktop/NetworkManager/Settings")),
+			dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
-			dbus.WithMatchInterface("org.freedesktop.NetworkManager.Settings"),
+			dbus.WithMatchInterface(dbusNMSettingsInterface),
 			dbus.WithMatchMember("NewConnection"),
 		)
 		conn.RemoveSignal(signals)
@@ -61,6 +67,31 @@ func (b *NetworkManagerBackend) startSignalPump() error {
 		return err
 	}
 
+	if err := conn.AddMatchSignal(
+		dbus.WithMatchPathNamespace(dbus.ObjectPath(dbusNMSettingsPath)),
+		dbus.WithMatchInterface(dbusNMSettingsConnectionInterface),
+		dbus.WithMatchMember("Updated"),
+	); err != nil {
+		conn.RemoveMatchSignal(
+			dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMPath)),
+			dbus.WithMatchInterface(dbusPropsInterface),
+			dbus.WithMatchMember("PropertiesChanged"),
+		)
+		conn.RemoveMatchSignal(
+			dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
+			dbus.WithMatchInterface(dbusNMSettingsInterface),
+			dbus.WithMatchMember("NewConnection"),
+		)
+		conn.RemoveMatchSignal(
+			dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
+			dbus.WithMatchInterface(dbusNMSettingsInterface),
+			dbus.WithMatchMember("ConnectionRemoved"),
+		)
+		conn.RemoveSignal(signals)
+		conn.Close()
+		return err
+	}
+
 	if err := conn.AddMatchSignal(
 		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMPath)),
 		dbus.WithMatchInterface(dbusNMInterface),
@@ -137,6 +168,32 @@ func (b *NetworkManagerBackend) stopSignalPump() {
 		dbus.WithMatchMember("PropertiesChanged"),
 	)
 
+	b.dbusConn.RemoveMatchSignal(
+		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
+		dbus.WithMatchInterface(dbusNMSettingsInterface),
+		dbus.WithMatchMember("NewConnection"),
+	)
+	b.dbusConn.RemoveMatchSignal(
+		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMSettingsPath)),
+		dbus.WithMatchInterface(dbusNMSettingsInterface),
+		dbus.WithMatchMember("ConnectionRemoved"),
+	)
+	b.dbusConn.RemoveMatchSignal(
+		dbus.WithMatchPathNamespace(dbus.ObjectPath(dbusNMSettingsPath)),
+		dbus.WithMatchInterface(dbusNMSettingsConnectionInterface),
+		dbus.WithMatchMember("Updated"),
+	)
+	b.dbusConn.RemoveMatchSignal(
+		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMPath)),
+		dbus.WithMatchInterface(dbusNMInterface),
+		dbus.WithMatchMember("DeviceAdded"),
+	)
+	b.dbusConn.RemoveMatchSignal(
+		dbus.WithMatchObjectPath(dbus.ObjectPath(dbusNMPath)),
+		dbus.WithMatchInterface(dbusNMInterface),
+		dbus.WithMatchMember("DeviceRemoved"),
+	)
+
 	for _, info := range b.wifiDevices {
 		b.dbusConn.RemoveMatchSignal(
 			dbus.WithMatchObjectPath(dbus.ObjectPath(info.device.GetPath())),
@@ -164,9 +221,13 @@ func (b *NetworkManagerBackend) stopSignalPump() {
 }
 
 func (b *NetworkManagerBackend) handleDBusSignal(sig *dbus.Signal) {
-	if sig.Name == "org.freedesktop.NetworkManager.Settings.NewConnection" ||
+	if sig.Name == dbusNMSettingsInterface+".NewConnection" ||
-		sig.Name == "org.freedesktop.NetworkManager.Settings.ConnectionRemoved" {
+		sig.Name == dbusNMSettingsInterface+".ConnectionRemoved" ||
+		sig.Name == dbusNMSettingsConnectionInterface+".Updated" {
 		b.ListVPNProfiles()
+		if err := b.updateSavedWiFiNetworks(); err != nil {
+			b.updateWiFiNetworks()
+		}
 		if b.onStateChange != nil {
 			b.onStateChange()
 		}

core/internal/server/network/backend_networkmanager_wifi.go

@@ -225,24 +225,14 @@ func (b *NetworkManagerBackend) GetWiFiQRCodeContent(ssid string) (string, error
 		return "", fmt.Errorf("failed to identify security type of network `%s`", ssid)
 	}
 
-	var securityType string
 	switch keyMgmt {
 	case "none":
-		authAlg, _ := secSettings["auth-alg"].(string)
+		return "", fmt.Errorf("QR code generation only supports WPA-PSK connections, `%s` is open or WEP", ssid)
-		switch authAlg {
-		case "open":
-			securityType = "nopass"
-		default:
-			securityType = "WEP"
-		}
 	case "ieee8021x":
-		securityType = "WEP"
+		return "", fmt.Errorf("QR code generation only supports WPA-PSK connections, `%s` is enterprise", ssid)
+	case "wpa-psk", "sae", "wpa-psk-sae":
 	default:
-		securityType = "WPA"
+		return "", fmt.Errorf("QR code generation only supports WPA-PSK connections, `%s` uses %s", ssid, keyMgmt)
-	}
-
-	if securityType != "WPA" {
-		return "", fmt.Errorf("QR code generation only supports WPA connections, `%s` uses %s", ssid, securityType)
 	}
 
 	var psk string
@@ -276,7 +266,7 @@ func (b *NetworkManagerBackend) GetWiFiQRCodeContent(ssid string) (string, error
 		return "", fmt.Errorf("failed to retrieve password for `%s`", ssid)
 	}
 
-	return FormatWiFiQRString(securityType, ssid, psk), nil
+	return FormatWiFiQRString("WPA", ssid, psk), nil
 }
 
 func (b *NetworkManagerBackend) ConnectWiFi(req ConnectionRequest) error {
@@ -405,6 +395,74 @@ func (b *NetworkManagerBackend) ForgetWiFiNetwork(ssid string) error {
 	return nil
 }
 
+func getSavedWiFiProfiles(connections []gonetworkmanager.Connection) map[string]savedWiFiProfile {
+	profiles := make(map[string]savedWiFiProfile)
+
+	for _, conn := range connections {
+		connSettings, err := conn.GetSettings()
+		if err != nil {
+			continue
+		}
+
+		connMeta, ok := connSettings["connection"]
+		if !ok {
+			continue
+		}
+
+		connType, ok := connMeta["type"].(string)
+		if !ok || connType != "802-11-wireless" {
+			continue
+		}
+
+		wifiSettings, ok := connSettings["802-11-wireless"]
+		if !ok {
+			continue
+		}
+
+		ssidBytes, ok := wifiSettings["ssid"].([]byte)
+		if !ok || len(ssidBytes) == 0 {
+			continue
+		}
+
+		ssid := string(ssidBytes)
+		profile := savedWiFiProfile{
+			Autoconnect: true,
+			Mode:        "infrastructure",
+		}
+
+		if ac, ok := connMeta["autoconnect"].(bool); ok {
+			profile.Autoconnect = ac
+		}
+		if hidden, ok := wifiSettings["hidden"].(bool); ok {
+			profile.Hidden = hidden
+		}
+		if mode, ok := wifiSettings["mode"].(string); ok && mode != "" {
+			profile.Mode = mode
+		}
+		if _, ok := connSettings["802-11-wireless-security"]; ok {
+			profile.Secured = true
+		}
+		if _, ok := connSettings["802-1x"]; ok {
+			profile.Enterprise = true
+			profile.Secured = true
+		}
+
+		if existing, ok := profiles[ssid]; ok {
+			profile.Autoconnect = profile.Autoconnect || existing.Autoconnect
+			profile.Hidden = profile.Hidden || existing.Hidden
+			profile.Secured = profile.Secured || existing.Secured
+			profile.Enterprise = profile.Enterprise || existing.Enterprise
+			if profile.Mode == "" {
+				profile.Mode = existing.Mode
+			}
+		}
+
+		profiles[ssid] = profile
+	}
+
+	return profiles
+}
+
 func (b *NetworkManagerBackend) IsConnectingTo(ssid string) bool {
 	b.stateMutex.RLock()
 	defer b.stateMutex.RUnlock()
@@ -442,47 +500,7 @@ func (b *NetworkManagerBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 		return nil, fmt.Errorf("failed to get connections: %w", err)
 	}
 
-	savedSSIDs := make(map[string]bool)
+	savedProfiles := getSavedWiFiProfiles(connections)
-	autoconnectMap := make(map[string]bool)
-	hiddenSSIDs := make(map[string]bool)
-	for _, conn := range connections {
-		connSettings, err := conn.GetSettings()
-		if err != nil {
-			continue
-		}
-
-		connMeta, ok := connSettings["connection"]
-		if !ok {
-			continue
-		}
-
-		connType, ok := connMeta["type"].(string)
-		if !ok || connType != "802-11-wireless" {
-			continue
-		}
-
-		wifiSettings, ok := connSettings["802-11-wireless"]
-		if !ok {
-			continue
-		}
-
-		ssidBytes, ok := wifiSettings["ssid"].([]byte)
-		if !ok {
-			continue
-		}
-
-		ssid := string(ssidBytes)
-		savedSSIDs[ssid] = true
-		autoconnect := true
-		if ac, ok := connMeta["autoconnect"].(bool); ok {
-			autoconnect = ac
-		}
-		autoconnectMap[ssid] = autoconnect
-
-		if hidden, ok := wifiSettings["hidden"].(bool); ok && hidden {
-			hiddenSSIDs[ssid] = true
-		}
-	}
 
 	b.stateMutex.RLock()
 	currentSSID := b.state.WiFiSSID
@@ -491,8 +509,8 @@ func (b *NetworkManagerBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 	wifiBSSID := b.state.WiFiBSSID
 	b.stateMutex.RUnlock()
 
-	seenSSIDs := make(map[string]*WiFiNetwork)
+	seenSSIDs := make(map[string]int)
-	networks := []WiFiNetwork{}
+	networks := make([]WiFiNetwork, 0, len(apPaths)+1)
 
 	for _, ap := range apPaths {
 		ssid, err := ap.GetPropertySSID()
@@ -500,7 +518,8 @@ func (b *NetworkManagerBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 			continue
 		}
 
-		if existing, exists := seenSSIDs[ssid]; exists {
+		if existingIndex, exists := seenSSIDs[ssid]; exists {
+			existing := &networks[existingIndex]
 			strength, _ := ap.GetPropertyStrength()
 			if strength > existing.Signal {
 				existing.Signal = strength
@@ -550,6 +569,7 @@ func (b *NetworkManagerBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 			}
 		}
 
+		profile, saved := savedProfiles[ssid]
 		network := WiFiNetwork{
 			SSID:        ssid,
 			BSSID:       bssid,
@@ -557,45 +577,86 @@ func (b *NetworkManagerBackend) updateWiFiNetworks() ([]WiFiNetwork, error) {
 			Secured:     secured,
 			Enterprise:  enterprise,
 			Connected:   isConnected,
-			Saved:       savedSSIDs[ssid],
+			Saved:       saved,
-			Autoconnect: autoconnectMap[ssid],
+			Autoconnect: profile.Autoconnect,
-			Hidden:      hiddenSSIDs[ssid],
+			Hidden:      profile.Hidden,
 			Frequency:   freq,
 			Mode:        modeStr,
 			Rate:        rate,
 			Channel:     channel,
 		}
 
-		seenSSIDs[ssid] = &network
 		networks = append(networks, network)
+		seenSSIDs[ssid] = len(networks) - 1
 	}
 
 	if wifiConnected && currentSSID != "" {
 		if _, exists := seenSSIDs[currentSSID]; !exists {
+			profile, saved := savedProfiles[currentSSID]
 			hiddenNetwork := WiFiNetwork{
 				SSID:        currentSSID,
 				BSSID:       wifiBSSID,
 				Signal:      wifiSignal,
 				Secured:     true,
 				Connected:   true,
-				Saved:       savedSSIDs[currentSSID],
+				Saved:       saved,
-				Autoconnect: autoconnectMap[currentSSID],
+				Autoconnect: profile.Autoconnect,
 				Hidden:      true,
 				Mode:        "infrastructure",
 			}
 			networks = append(networks, hiddenNetwork)
+			seenSSIDs[currentSSID] = len(networks) - 1
 		}
 	}
 
+	visibleNetworks := wiFiNetworksBySSID(networks, true)
+	savedNetworks := savedWiFiNetworksFromProfiles(savedProfiles, visibleNetworks, currentSSID, wifiConnected)
+
 	sortWiFiNetworks(networks)
 
 	b.stateMutex.Lock()
 	b.state.WiFiNetworks = networks
+	b.state.SavedWiFiNetworks = savedNetworks
 	b.stateMutex.Unlock()
 
 	return networks, nil
 }
 
+func (b *NetworkManagerBackend) updateSavedWiFiNetworks() error {
+	s := b.settings
+	if s == nil {
+		var err error
+		s, err = gonetworkmanager.NewSettings()
+		if err != nil {
+			return fmt.Errorf("failed to get settings: %w", err)
+		}
+		b.settings = s
+	}
+
+	settingsMgr := s.(gonetworkmanager.Settings)
+	connections, err := settingsMgr.ListConnections()
+	if err != nil {
+		return fmt.Errorf("failed to get connections: %w", err)
+	}
+
+	savedProfiles := getSavedWiFiProfiles(connections)
+
+	b.stateMutex.RLock()
+	currentSSID := b.state.WiFiSSID
+	wifiConnected := b.state.WiFiConnected
+	wifiNetworks := append([]WiFiNetwork(nil), b.state.WiFiNetworks...)
+	b.stateMutex.RUnlock()
+
+	wifiNetworks, savedNetworks := refreshSavedWiFiState(wifiNetworks, savedProfiles, currentSSID, wifiConnected)
+
+	b.stateMutex.Lock()
+	b.state.WiFiNetworks = wifiNetworks
+	b.state.SavedWiFiNetworks = savedNetworks
+	b.stateMutex.Unlock()
+
+	return nil
+}
+
 func (b *NetworkManagerBackend) findConnection(ssid string) (gonetworkmanager.Connection, error) {
 	s := b.settings
 	if s == nil {
@@ -975,49 +1036,14 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 		return
 	}
 
-	savedSSIDs := make(map[string]bool)
+	savedProfiles := getSavedWiFiProfiles(connections)
-	autoconnectMap := make(map[string]bool)
-	hiddenSSIDs := make(map[string]bool)
-	for _, conn := range connections {
-		connSettings, err := conn.GetSettings()
-		if err != nil {
-			continue
-		}
-
-		connMeta, ok := connSettings["connection"]
-		if !ok {
-			continue
-		}
-
-		connType, ok := connMeta["type"].(string)
-		if !ok || connType != "802-11-wireless" {
-			continue
-		}
-
-		wifiSettings, ok := connSettings["802-11-wireless"]
-		if !ok {
-			continue
-		}
-
-		ssidBytes, ok := wifiSettings["ssid"].([]byte)
-		if !ok {
-			continue
-		}
-
-		ssid := string(ssidBytes)
-		savedSSIDs[ssid] = true
-		autoconnect := true
-		if ac, ok := connMeta["autoconnect"].(bool); ok {
-			autoconnect = ac
-		}
-		autoconnectMap[ssid] = autoconnect
-
-		if hidden, ok := wifiSettings["hidden"].(bool); ok && hidden {
-			hiddenSSIDs[ssid] = true
-		}
-	}
 
 	var devices []WiFiDevice
+	visibleNetworks := make(map[string]WiFiNetwork)
+	b.stateMutex.RLock()
+	currentSSID := b.state.WiFiSSID
+	wifiConnected := b.state.WiFiConnected
+	b.stateMutex.RUnlock()
 
 	for name, devInfo := range b.wifiDevices {
 		state, _ := devInfo.device.GetPropertyState()
@@ -1050,14 +1076,16 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 		apPaths, err := devInfo.wireless.GetAccessPoints()
 		var networks []WiFiNetwork
 		if err == nil {
-			seenSSIDs := make(map[string]*WiFiNetwork)
+			seenSSIDs := make(map[string]int)
+			networks = make([]WiFiNetwork, 0, len(apPaths)+1)
 			for _, ap := range apPaths {
 				apSSID, err := ap.GetPropertySSID()
 				if err != nil || apSSID == "" {
 					continue
 				}
 
-				if existing, exists := seenSSIDs[apSSID]; exists {
+				if existingIndex, exists := seenSSIDs[apSSID]; exists {
+					existing := &networks[existingIndex]
 					strength, _ := ap.GetPropertyStrength()
 					if strength > existing.Signal {
 						existing.Signal = strength
@@ -1107,6 +1135,7 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 					}
 				}
 
+				profile, saved := savedProfiles[apSSID]
 				network := WiFiNetwork{
 					SSID:        apSSID,
 					BSSID:       apBSSID,
@@ -1114,9 +1143,9 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 					Secured:     secured,
 					Enterprise:  enterprise,
 					Connected:   isConnected,
-					Saved:       savedSSIDs[apSSID],
+					Saved:       saved,
-					Autoconnect: autoconnectMap[apSSID],
+					Autoconnect: profile.Autoconnect,
-					Hidden:      hiddenSSIDs[apSSID],
+					Hidden:      profile.Hidden,
 					Frequency:   freq,
 					Mode:        modeStr,
 					Rate:        rate,
@@ -1124,25 +1153,31 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 					Device:      name,
 				}
 
-				seenSSIDs[apSSID] = &network
 				networks = append(networks, network)
+				seenSSIDs[apSSID] = len(networks) - 1
+				if existing, ok := visibleNetworks[apSSID]; !ok || network.Signal > existing.Signal {
+					visibleNetworks[apSSID] = network
+				}
 			}
 
 			if connected && ssid != "" {
 				if _, exists := seenSSIDs[ssid]; !exists {
+					profile, saved := savedProfiles[ssid]
 					hiddenNetwork := WiFiNetwork{
 						SSID:        ssid,
 						BSSID:       bssid,
 						Signal:      signal,
 						Secured:     true,
 						Connected:   true,
-						Saved:       savedSSIDs[ssid],
+						Saved:       saved,
-						Autoconnect: autoconnectMap[ssid],
+						Autoconnect: profile.Autoconnect,
 						Hidden:      true,
 						Mode:        "infrastructure",
 						Device:      name,
 					}
 					networks = append(networks, hiddenNetwork)
+					seenSSIDs[ssid] = len(networks) - 1
+					visibleNetworks[ssid] = hiddenNetwork
 				}
 			}
 
@@ -1168,6 +1203,7 @@ func (b *NetworkManagerBackend) updateAllWiFiDevices() {
 
 	b.stateMutex.Lock()
 	b.state.WiFiDevices = devices
+	b.state.SavedWiFiNetworks = savedWiFiNetworksFromProfiles(savedProfiles, visibleNetworks, currentSSID, wifiConnected)
 	b.stateMutex.Unlock()
 }
 

core/internal/server/network/backend_networkmanager_wifi_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	mock_gonetworkmanager "github.com/AvengeMedia/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2"
+	"github.com/Wifx/gonetworkmanager/v2"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -176,6 +177,54 @@ func TestNetworkManagerBackend_UpdateWiFiNetworks_NoDevice(t *testing.T) {
 	assert.Contains(t, err.Error(), "no WiFi device available")
 }
 
+func TestNetworkManagerBackend_UpdateSavedWiFiNetworksPreservesVisibleSavedNetworks(t *testing.T) {
+	mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
+	mockSettings := mock_gonetworkmanager.NewMockSettings(t)
+	mockConn := mock_gonetworkmanager.NewMockConnection(t)
+
+	backend, err := NewNetworkManagerBackend(mockNM)
+	assert.NoError(t, err)
+	backend.settings = mockSettings
+
+	backend.stateMutex.Lock()
+	backend.state.WiFiNetworks = []WiFiNetwork{
+		{
+			SSID:   "Home",
+			Signal: 76,
+		},
+	}
+	backend.stateMutex.Unlock()
+
+	settings := gonetworkmanager.ConnectionSettings{
+		"connection": {
+			"type":        "802-11-wireless",
+			"autoconnect": true,
+		},
+		"802-11-wireless": {
+			"ssid": []byte("Home"),
+		},
+		"802-11-wireless-security": {},
+	}
+	mockSettings.EXPECT().ListConnections().Return([]gonetworkmanager.Connection{mockConn}, nil)
+	mockConn.EXPECT().GetSettings().Return(settings, nil)
+
+	err = backend.updateSavedWiFiNetworks()
+	assert.NoError(t, err)
+
+	backend.stateMutex.RLock()
+	savedNetworks := append([]WiFiNetwork(nil), backend.state.SavedWiFiNetworks...)
+	wifiNetworks := append([]WiFiNetwork(nil), backend.state.WiFiNetworks...)
+	backend.stateMutex.RUnlock()
+
+	assert.Len(t, wifiNetworks, 1)
+	assert.True(t, wifiNetworks[0].Saved)
+	assert.Len(t, savedNetworks, 1)
+	assert.Equal(t, "Home", savedNetworks[0].SSID)
+	assert.True(t, savedNetworks[0].Saved)
+	assert.False(t, savedNetworks[0].OutOfRange)
+	assert.Equal(t, uint8(76), savedNetworks[0].Signal)
+}
+
 func TestNetworkManagerBackend_FindConnection_NoSettings(t *testing.T) {
 	mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
 

core/internal/server/network/manager.go

@@ -64,9 +64,10 @@ func NewManager() (*Manager, error) {
 	m := &Manager{
 		backend: backend,
 		state: &NetworkState{
-			NetworkStatus: StatusDisconnected,
+			NetworkStatus:     StatusDisconnected,
-			Preference:    PreferenceAuto,
+			Preference:        PreferenceAuto,
-			WiFiNetworks:  []WiFiNetwork{},
+			WiFiNetworks:      []WiFiNetwork{},
+			SavedWiFiNetworks: []WiFiNetwork{},
 		},
 		stateMutex: sync.RWMutex{},
 
@@ -120,6 +121,7 @@ func (m *Manager) syncStateFromBackend() error {
 	m.state.WiFiBSSID = backendState.WiFiBSSID
 	m.state.WiFiSignal = backendState.WiFiSignal
 	m.state.WiFiNetworks = backendState.WiFiNetworks
+	m.state.SavedWiFiNetworks = backendState.SavedWiFiNetworks
 	m.state.WiFiDevices = backendState.WiFiDevices
 	m.state.WiredConnections = backendState.WiredConnections
 	m.state.VPNProfiles = backendState.VPNProfiles
@@ -156,6 +158,7 @@ func (m *Manager) snapshotState() NetworkState {
 	defer m.stateMutex.RUnlock()
 	s := *m.state
 	s.WiFiNetworks = append([]WiFiNetwork(nil), m.state.WiFiNetworks...)
+	s.SavedWiFiNetworks = append([]WiFiNetwork(nil), m.state.SavedWiFiNetworks...)
 	s.WiFiDevices = append([]WiFiDevice(nil), m.state.WiFiDevices...)
 	s.WiredConnections = append([]WiredConnection(nil), m.state.WiredConnections...)
 	s.EthernetDevices = append([]EthernetDevice(nil), m.state.EthernetDevices...)
@@ -211,6 +214,9 @@ func stateChangedMeaningfully(old, new *NetworkState) bool {
 	if len(old.WiFiNetworks) != len(new.WiFiNetworks) {
 		return true
 	}
+	if len(old.SavedWiFiNetworks) != len(new.SavedWiFiNetworks) {
+		return true
+	}
 	if len(old.WiFiDevices) != len(new.WiFiDevices) {
 		return true
 	}
@@ -238,6 +244,23 @@ func stateChangedMeaningfully(old, new *NetworkState) bool {
 		}
 	}
 
+	for i := range old.SavedWiFiNetworks {
+		oldNet := &old.SavedWiFiNetworks[i]
+		newNet := &new.SavedWiFiNetworks[i]
+		if oldNet.SSID != newNet.SSID {
+			return true
+		}
+		if oldNet.Connected != newNet.Connected {
+			return true
+		}
+		if oldNet.Autoconnect != newNet.Autoconnect {
+			return true
+		}
+		if oldNet.OutOfRange != newNet.OutOfRange {
+			return true
+		}
+	}
+
 	for i := range old.WiredConnections {
 		oldNet := &old.WiredConnections[i]
 		newNet := &new.WiredConnections[i]

core/internal/server/network/types.go

@@ -34,6 +34,7 @@ type WiFiNetwork struct {
 	Saved       bool   `json:"saved"`
 	Autoconnect bool   `json:"autoconnect"`
 	Hidden      bool   `json:"hidden"`
+	OutOfRange  bool   `json:"outOfRange"`
 	Frequency   uint32 `json:"frequency"`
 	Mode        string `json:"mode"`
 	Rate        uint32 `json:"rate"`
@@ -111,6 +112,7 @@ type NetworkState struct {
 	WiFiBSSID              string               `json:"wifiBSSID"`
 	WiFiSignal             uint8                `json:"wifiSignal"`
 	WiFiNetworks           []WiFiNetwork        `json:"wifiNetworks"`
+	SavedWiFiNetworks      []WiFiNetwork        `json:"savedWifiNetworks"`
 	WiFiDevices            []WiFiDevice         `json:"wifiDevices"`
 	WiredConnections       []WiredConnection    `json:"wiredConnections"`
 	VPNProfiles            []VPNProfile         `json:"vpnProfiles"`

core/internal/server/network/wifi_saved.go

@@ -0,0 +1,103 @@
+package network
+
+import "sort"
+
+type savedWiFiProfile struct {
+	Autoconnect bool
+	Hidden      bool
+	Secured     bool
+	Enterprise  bool
+	Mode        string
+}
+
+// Saved WiFi state is keyed by SSID because the UI/API accepts SSID actions.
+// Multiple backend profiles for the same SSID are intentionally collapsed here.
+func mergeSavedProfilesIntoWiFiNetworks(networks []WiFiNetwork, profiles map[string]savedWiFiProfile, currentSSID string, wifiConnected bool) []WiFiNetwork {
+	merged := make([]WiFiNetwork, len(networks))
+	for i, network := range networks {
+		profile, saved := profiles[network.SSID]
+		network.Connected = wifiConnected && network.SSID == currentSSID
+		network.Saved = saved
+		if saved {
+			network.Autoconnect = profile.Autoconnect
+			network.Hidden = network.Hidden || profile.Hidden
+			network.Secured = network.Secured || profile.Secured
+			network.Enterprise = network.Enterprise || profile.Enterprise
+			if network.Mode == "" {
+				network.Mode = profile.Mode
+			}
+		} else {
+			network.Autoconnect = false
+		}
+		merged[i] = network
+	}
+	return merged
+}
+
+func wiFiNetworksBySSID(networks []WiFiNetwork, visibleOnly bool) map[string]WiFiNetwork {
+	visible := make(map[string]WiFiNetwork, len(networks))
+	for _, network := range networks {
+		if visibleOnly && network.OutOfRange {
+			continue
+		}
+		visible[network.SSID] = network
+	}
+	return visible
+}
+
+func refreshSavedWiFiState(networks []WiFiNetwork, profiles map[string]savedWiFiProfile, currentSSID string, wifiConnected bool) ([]WiFiNetwork, []WiFiNetwork) {
+	mergedNetworks := mergeSavedProfilesIntoWiFiNetworks(networks, profiles, currentSSID, wifiConnected)
+	visibleNetworks := wiFiNetworksBySSID(mergedNetworks, true)
+	savedNetworks := savedWiFiNetworksFromProfiles(profiles, visibleNetworks, currentSSID, wifiConnected)
+	return mergedNetworks, savedNetworks
+}
+
+func savedWiFiNetworksFromProfiles(profiles map[string]savedWiFiProfile, visible map[string]WiFiNetwork, currentSSID string, wifiConnected bool) []WiFiNetwork {
+	networks := make([]WiFiNetwork, 0, len(profiles))
+	for ssid, profile := range profiles {
+		if network, ok := visible[ssid]; ok {
+			network.Saved = true
+			network.Autoconnect = profile.Autoconnect
+			network.Hidden = network.Hidden || profile.Hidden
+			network.Secured = network.Secured || profile.Secured
+			network.Enterprise = network.Enterprise || profile.Enterprise
+			network.OutOfRange = false
+			if network.Mode == "" {
+				network.Mode = profile.Mode
+			}
+			networks = append(networks, network)
+			continue
+		}
+
+		isConnected := wifiConnected && ssid == currentSSID
+		networks = append(networks, WiFiNetwork{
+			SSID:        ssid,
+			Secured:     profile.Secured,
+			Enterprise:  profile.Enterprise,
+			Connected:   isConnected,
+			Saved:       true,
+			Autoconnect: profile.Autoconnect,
+			Hidden:      profile.Hidden,
+			OutOfRange:  !isConnected,
+			Mode:        profile.Mode,
+		})
+	}
+
+	sort.Slice(networks, func(i, j int) bool {
+		if networks[i].Connected && !networks[j].Connected {
+			return true
+		}
+		if !networks[i].Connected && networks[j].Connected {
+			return false
+		}
+		if networks[i].OutOfRange != networks[j].OutOfRange {
+			return !networks[i].OutOfRange
+		}
+		if networks[i].Signal != networks[j].Signal {
+			return networks[i].Signal > networks[j].Signal
+		}
+		return networks[i].SSID < networks[j].SSID
+	})
+
+	return networks
+}

core/internal/server/network/wifi_saved_test.go

@@ -0,0 +1,170 @@
+package network
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMergeSavedProfilesIntoWiFiNetworks(t *testing.T) {
+	networks := []WiFiNetwork{
+		{
+			SSID:        "Home",
+			Signal:      80,
+			Secured:     false,
+			Autoconnect: false,
+		},
+		{
+			SSID:        "Cafe",
+			Signal:      50,
+			Secured:     false,
+			Autoconnect: true,
+		},
+	}
+	profiles := map[string]savedWiFiProfile{
+		"Home": {
+			Autoconnect: true,
+			Hidden:      true,
+			Secured:     true,
+			Mode:        "infrastructure",
+		},
+	}
+
+	merged := mergeSavedProfilesIntoWiFiNetworks(networks, profiles, "Home", true)
+
+	assert.Len(t, merged, 2)
+	assert.Equal(t, "Home", merged[0].SSID)
+	assert.True(t, merged[0].Connected)
+	assert.True(t, merged[0].Saved)
+	assert.True(t, merged[0].Autoconnect)
+	assert.True(t, merged[0].Hidden)
+	assert.True(t, merged[0].Secured)
+	assert.Equal(t, "infrastructure", merged[0].Mode)
+
+	assert.Equal(t, "Cafe", merged[1].SSID)
+	assert.False(t, merged[1].Saved)
+	assert.False(t, merged[1].Autoconnect)
+}
+
+func TestSavedWiFiNetworksFromProfilesOutOfRangeWithoutVisibleNetworks(t *testing.T) {
+	profiles := map[string]savedWiFiProfile{
+		"Home": {
+			Autoconnect: true,
+			Secured:     true,
+			Mode:        "infrastructure",
+		},
+	}
+
+	networks := savedWiFiNetworksFromProfiles(profiles, nil, "", false)
+
+	assert.Len(t, networks, 1)
+	assert.Equal(t, "Home", networks[0].SSID)
+	assert.True(t, networks[0].Saved)
+	assert.True(t, networks[0].OutOfRange)
+	assert.Equal(t, uint8(0), networks[0].Signal)
+}
+
+func TestSavedWiFiNetworksFromProfilesKeepsConnectedCurrentNetworkInRange(t *testing.T) {
+	profiles := map[string]savedWiFiProfile{
+		"Home": {
+			Autoconnect: true,
+			Secured:     true,
+		},
+	}
+
+	networks := savedWiFiNetworksFromProfiles(profiles, nil, "Home", true)
+
+	assert.Len(t, networks, 1)
+	assert.Equal(t, "Home", networks[0].SSID)
+	assert.True(t, networks[0].Connected)
+	assert.False(t, networks[0].OutOfRange)
+}
+
+func TestSavedWiFiNetworksFromProfilesIncludesOutOfRange(t *testing.T) {
+	profiles := map[string]savedWiFiProfile{
+		"Home": {
+			Autoconnect: true,
+			Hidden:      true,
+			Secured:     true,
+			Mode:        "infrastructure",
+		},
+		"Office": {
+			Autoconnect: false,
+			Secured:     true,
+			Enterprise:  true,
+			Mode:        "infrastructure",
+		},
+	}
+	visible := map[string]WiFiNetwork{
+		"Home": {
+			SSID:      "Home",
+			Signal:    72,
+			Secured:   true,
+			Connected: true,
+		},
+	}
+
+	networks := savedWiFiNetworksFromProfiles(profiles, visible, "Home", true)
+
+	assert.Len(t, networks, 2)
+	assert.Equal(t, "Home", networks[0].SSID)
+	assert.True(t, networks[0].Saved)
+	assert.True(t, networks[0].Connected)
+	assert.False(t, networks[0].OutOfRange)
+	assert.True(t, networks[0].Hidden)
+	assert.Equal(t, uint8(72), networks[0].Signal)
+
+	assert.Equal(t, "Office", networks[1].SSID)
+	assert.True(t, networks[1].Saved)
+	assert.False(t, networks[1].Autoconnect)
+	assert.True(t, networks[1].Enterprise)
+	assert.True(t, networks[1].OutOfRange)
+}
+
+func TestWiFiNetworksBySSIDVisibleOnlySkipsOutOfRange(t *testing.T) {
+	visible := wiFiNetworksBySSID([]WiFiNetwork{
+		{SSID: "Home", Signal: 70},
+		{SSID: "Office", Signal: 0, OutOfRange: true},
+	}, true)
+
+	assert.Contains(t, visible, "Home")
+	assert.NotContains(t, visible, "Office")
+}
+
+func TestRefreshSavedWiFiStatePreservesVisibleSavedNetworks(t *testing.T) {
+	networks := []WiFiNetwork{
+		{
+			SSID:   "Home",
+			Signal: 82,
+		},
+	}
+	profiles := map[string]savedWiFiProfile{
+		"Home": {
+			Autoconnect: true,
+			Secured:     true,
+			Mode:        "infrastructure",
+		},
+		"Office": {
+			Autoconnect: false,
+			Secured:     true,
+			Mode:        "infrastructure",
+		},
+	}
+
+	mergedNetworks, savedNetworks := refreshSavedWiFiState(networks, profiles, "", false)
+
+	assert.Len(t, mergedNetworks, 1)
+	assert.Equal(t, "Home", mergedNetworks[0].SSID)
+	assert.True(t, mergedNetworks[0].Saved)
+	assert.True(t, mergedNetworks[0].Autoconnect)
+
+	assert.Len(t, savedNetworks, 2)
+	assert.Equal(t, "Home", savedNetworks[0].SSID)
+	assert.True(t, savedNetworks[0].Saved)
+	assert.False(t, savedNetworks[0].OutOfRange)
+	assert.Equal(t, uint8(82), savedNetworks[0].Signal)
+
+	assert.Equal(t, "Office", savedNetworks[1].SSID)
+	assert.True(t, savedNetworks[1].Saved)
+	assert.True(t, savedNetworks[1].OutOfRange)
+}

core/internal/server/server.go

@@ -38,7 +38,7 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/pkg/syncmap"
 )
 
-const APIVersion = 25
+const APIVersion = 26
 
 var CLIVersion = "dev"
 

core/internal/server/tailscale/client.go

@@ -66,16 +66,17 @@ func convertPeerStatus(ps *ipnstate.PeerStatus, users map[tailcfg.UserID]tailcfg
 	}
 
 	peer := Peer{
-		ID:       string(ps.ID),
+		ID:             string(ps.ID),
-		Hostname: hostname,
+		Hostname:       hostname,
-		DNSName:  dnsName,
+		DNSName:        dnsName,
-		OS:       ps.OS,
+		OS:             ps.OS,
-		Online:   ps.Online,
+		Online:         ps.Online,
-		Active:   ps.Active,
+		Active:         ps.Active,
-		ExitNode: ps.ExitNode,
+		ExitNode:       ps.ExitNode,
-		Relay:    ps.Relay,
+		ExitNodeOption: ps.ExitNodeOption,
-		RxBytes:  ps.RxBytes,
+		Relay:          ps.Relay,
-		TxBytes:  ps.TxBytes,
+		RxBytes:        ps.RxBytes,
+		TxBytes:        ps.TxBytes,
 	}
 
 	for _, ip := range ps.TailscaleIPs {

core/internal/server/tailscale/handlers.go

@@ -14,6 +14,14 @@ func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 		handleGetStatus(conn, req, manager)
 	case "tailscale.refresh":
 		handleRefresh(conn, req, manager)
+	case "tailscale.connect":
+		handleConnect(conn, req, manager)
+	case "tailscale.disconnect":
+		handleDisconnect(conn, req, manager)
+	case "tailscale.setExitNode":
+		handleSetExitNode(conn, req, manager)
+	case "tailscale.setAllowLanAccess":
+		handleSetAllowLanAccess(conn, req, manager)
 	default:
 		models.RespondError(conn, req.ID, fmt.Sprintf("unknown method: %s", req.Method))
 	}
@@ -28,3 +36,37 @@ func handleRefresh(conn net.Conn, req models.Request, manager *Manager) {
 	manager.RefreshState()
 	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "refreshed"})
 }
+
+func handleConnect(conn net.Conn, req models.Request, manager *Manager) {
+	if err := manager.Connect(); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "connected"})
+}
+
+func handleDisconnect(conn net.Conn, req models.Request, manager *Manager) {
+	if err := manager.Disconnect(); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "disconnected"})
+}
+
+func handleSetExitNode(conn net.Conn, req models.Request, manager *Manager) {
+	id := models.GetOr(req, "id", "")
+	if err := manager.SetExitNode(id); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "exit node updated"})
+}
+
+func handleSetAllowLanAccess(conn net.Conn, req models.Request, manager *Manager) {
+	enabled := models.GetOr(req, "enabled", false)
+	if err := manager.SetAllowLANAccess(enabled); err != nil {
+		models.RespondError(conn, req.ID, err.Error())
+		return
+	}
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "lan access updated"})
+}

core/internal/server/tailscale/handlers_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"fmt"
 	"net"
 	"testing"
 	"time"
@@ -78,6 +79,63 @@ func TestHandleRefresh(t *testing.T) {
 	assert.True(t, resp.Result.Success)
 }
 
+func TestHandleActions(t *testing.T) {
+	cases := []struct {
+		name   string
+		method string
+		params map[string]any
+	}{
+		{"connect", "tailscale.connect", nil},
+		{"disconnect", "tailscale.disconnect", nil},
+		{"setExitNode", "tailscale.setExitNode", map[string]any{"id": "nABC123"}},
+		{"clearExitNode", "tailscale.setExitNode", map[string]any{"id": ""}},
+		{"setAllowLanAccess", "tailscale.setAllowLanAccess", map[string]any{"enabled": true}},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			m := handlerTestManager()
+			defer m.Close()
+
+			buf := &bytes.Buffer{}
+			conn := &mockConn{Buffer: buf}
+
+			req := models.Request{ID: 1, Method: tc.method, Params: tc.params}
+			HandleRequest(conn, req, m)
+
+			var resp models.Response[models.SuccessResult]
+			require.NoError(t, json.NewDecoder(buf).Decode(&resp))
+			assert.Equal(t, 1, resp.ID)
+			assert.Empty(t, resp.Error)
+			require.NotNil(t, resp.Result)
+			assert.True(t, resp.Result.Success)
+		})
+	}
+}
+
+func TestHandleAction_BackendError(t *testing.T) {
+	client := &mockClient{
+		watchFn:  blockingWatch,
+		statusFn: func(ctx context.Context) (*ipnstate.Status, error) { return runningStatus(), nil },
+		editPrefsFn: func(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error) {
+			return nil, fmt.Errorf("backend rejected edit")
+		},
+	}
+	m := newManager(client)
+	defer m.Close()
+
+	buf := &bytes.Buffer{}
+	conn := &mockConn{Buffer: buf}
+
+	req := models.Request{ID: 1, Method: "tailscale.connect"}
+	HandleRequest(conn, req, m)
+
+	var resp models.Response[models.SuccessResult]
+	require.NoError(t, json.NewDecoder(buf).Decode(&resp))
+	assert.Nil(t, resp.Result)
+	assert.Contains(t, resp.Error, "backend rejected edit")
+}
+
 func TestHandleRequest_UnknownMethod(t *testing.T) {
 	m := handlerTestManager()
 	defer m.Close()

core/internal/server/tailscale/manager.go

@@ -11,6 +11,7 @@ import (
 	"tailscale.com/client/local"
 	"tailscale.com/ipn"
 	"tailscale.com/ipn/ipnstate"
+	"tailscale.com/tailcfg"
 )
 
 const (
@@ -22,6 +23,8 @@ const (
 type tailscaleClient interface {
 	WatchIPNBus(ctx context.Context, mask ipn.NotifyWatchOpt) (ipnBusWatcher, error)
 	Status(ctx context.Context) (*ipnstate.Status, error)
+	GetPrefs(ctx context.Context) (*ipn.Prefs, error)
+	EditPrefs(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error)
 }
 
 // ipnBusWatcher abstracts the IPN bus watcher for testing.
@@ -43,6 +46,14 @@ func (w *localClientWrapper) Status(ctx context.Context) (*ipnstate.Status, erro
 	return w.client.Status(ctx)
 }
 
+func (w *localClientWrapper) GetPrefs(ctx context.Context) (*ipn.Prefs, error) {
+	return w.client.GetPrefs(ctx)
+}
+
+func (w *localClientWrapper) EditPrefs(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error) {
+	return w.client.EditPrefs(ctx, mp)
+}
+
 // Manager manages Tailscale state via IPN bus events and subscriber notifications.
 type Manager struct {
 	state                *TailscaleState
@@ -169,16 +180,36 @@ func (m *Manager) fetchAndBroadcast(ctx context.Context) {
 	statusCtx, cancel := context.WithTimeout(ctx, statusTimeout)
 	defer cancel()
 
-	status, err := m.client.Status(statusCtx)
+	state, err := m.fetchState(statusCtx)
 	if err != nil {
 		log.Warnf("[Tailscale] Failed to fetch status: %v", err)
 		return
 	}
 
-	state := convertStatus(status)
 	m.updateState(state)
 }
 
+// fetchState fetches the current status and merges in pref-derived fields
+// (e.g. exit-node LAN access) that are not present in the IPN status itself.
+func (m *Manager) fetchState(ctx context.Context) (*TailscaleState, error) {
+	status, err := m.client.Status(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	state := convertStatus(status)
+
+	// Prefs carry the exit-node LAN-access toggle, which the status does not
+	// expose. Treat a prefs failure as non-fatal so status still updates.
+	if prefs, err := m.client.GetPrefs(ctx); err != nil {
+		log.Warnf("[Tailscale] Failed to fetch prefs: %v", err)
+	} else if prefs != nil {
+		state.ExitNodeAllowLANAccess = prefs.ExitNodeAllowLANAccess
+	}
+
+	return state, nil
+}
+
 func (m *Manager) updateState(state *TailscaleState) {
 	m.stateMutex.Lock()
 	m.state = state
@@ -266,12 +297,62 @@ func (m *Manager) RefreshState() {
 	ctx, cancel := context.WithTimeout(m.ctx, statusTimeout)
 	defer cancel()
 
-	status, err := m.client.Status(ctx)
+	state, err := m.fetchState(ctx)
 	if err != nil {
 		log.Warnf("[Tailscale] Failed to refresh state: %v", err)
 		return
 	}
 
-	state := convertStatus(status)
 	m.updateState(state)
 }
+
+// Connect brings the Tailscale backend up (WantRunning = true).
+func (m *Manager) Connect() error {
+	return m.editPrefs(&ipn.MaskedPrefs{
+		Prefs:          ipn.Prefs{WantRunning: true},
+		WantRunningSet: true,
+	})
+}
+
+// Disconnect brings the Tailscale backend down (WantRunning = false).
+func (m *Manager) Disconnect() error {
+	return m.editPrefs(&ipn.MaskedPrefs{
+		Prefs:          ipn.Prefs{WantRunning: false},
+		WantRunningSet: true,
+	})
+}
+
+// SetExitNode selects the exit node identified by its stable node ID. An empty
+// id clears the current exit node. Mirrors `tailscale set --exit-node=<id>`,
+// which also clears any legacy IP-based exit node so a stale ExitNodeIP cannot
+// silently take precedence over the now-empty ID.
+func (m *Manager) SetExitNode(id string) error {
+	return m.editPrefs(&ipn.MaskedPrefs{
+		Prefs:         ipn.Prefs{ExitNodeID: tailcfg.StableNodeID(id)},
+		ExitNodeIDSet: true,
+		ExitNodeIPSet: true,
+	})
+}
+
+// SetAllowLANAccess toggles whether locally accessible subnets remain
+// reachable while an exit node is in use.
+func (m *Manager) SetAllowLANAccess(enabled bool) error {
+	return m.editPrefs(&ipn.MaskedPrefs{
+		Prefs:                     ipn.Prefs{ExitNodeAllowLANAccess: enabled},
+		ExitNodeAllowLANAccessSet: true,
+	})
+}
+
+// editPrefs applies a masked prefs edit and refreshes state so subscribers see
+// the result immediately, in addition to the IPN bus notification it triggers.
+func (m *Manager) editPrefs(mp *ipn.MaskedPrefs) error {
+	ctx, cancel := context.WithTimeout(m.ctx, statusTimeout)
+	defer cancel()
+
+	if _, err := m.client.EditPrefs(ctx, mp); err != nil {
+		return err
+	}
+
+	m.RefreshState()
+	return nil
+}

core/internal/server/tailscale/manager_test.go

@@ -12,8 +12,16 @@ import (
 	"github.com/stretchr/testify/require"
 	"tailscale.com/ipn"
 	"tailscale.com/ipn/ipnstate"
+	"tailscale.com/tailcfg"
 )
 
+// blockingWatch is a watchFn that blocks until the context is cancelled, used
+// by tests that exercise direct manager calls rather than the watch loop.
+func blockingWatch(ctx context.Context, mask ipn.NotifyWatchOpt) (ipnBusWatcher, error) {
+	<-ctx.Done()
+	return nil, ctx.Err()
+}
+
 // mockWatcher yields canned Notify events, then returns err or blocks until Close/context cancel.
 type mockWatcher struct {
 	events []ipn.Notify
@@ -68,8 +76,10 @@ func (w *mockWatcher) Close() error {
 
 // mockClient implements tailscaleClient for testing.
 type mockClient struct {
-	watchFn  func(ctx context.Context, mask ipn.NotifyWatchOpt) (ipnBusWatcher, error)
+	watchFn     func(ctx context.Context, mask ipn.NotifyWatchOpt) (ipnBusWatcher, error)
-	statusFn func(ctx context.Context) (*ipnstate.Status, error)
+	statusFn    func(ctx context.Context) (*ipnstate.Status, error)
+	getPrefsFn  func(ctx context.Context) (*ipn.Prefs, error)
+	editPrefsFn func(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error)
 }
 
 func (c *mockClient) WatchIPNBus(ctx context.Context, mask ipn.NotifyWatchOpt) (ipnBusWatcher, error) {
@@ -80,6 +90,20 @@ func (c *mockClient) Status(ctx context.Context) (*ipnstate.Status, error) {
 	return c.statusFn(ctx)
 }
 
+func (c *mockClient) GetPrefs(ctx context.Context) (*ipn.Prefs, error) {
+	if c.getPrefsFn != nil {
+		return c.getPrefsFn(ctx)
+	}
+	return &ipn.Prefs{}, nil
+}
+
+func (c *mockClient) EditPrefs(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error) {
+	if c.editPrefsFn != nil {
+		return c.editPrefsFn(ctx, mp)
+	}
+	return &ipn.Prefs{}, nil
+}
+
 func runningStatus() *ipnstate.Status {
 	return &ipnstate.Status{
 		Version:        "1.94.2",
@@ -296,3 +320,78 @@ func TestManager_RefreshState(t *testing.T) {
 	assert.True(t, state.Connected)
 	assert.Equal(t, "cachyos", state.Self.Hostname)
 }
+
+func TestManager_RefreshState_MergesPrefs(t *testing.T) {
+	client := &mockClient{
+		watchFn:  blockingWatch,
+		statusFn: func(ctx context.Context) (*ipnstate.Status, error) { return runningStatus(), nil },
+		getPrefsFn: func(ctx context.Context) (*ipn.Prefs, error) {
+			return &ipn.Prefs{ExitNodeAllowLANAccess: true}, nil
+		},
+	}
+
+	m := newManager(client)
+	defer m.Close()
+
+	m.RefreshState()
+
+	assert.True(t, m.GetState().ExitNodeAllowLANAccess)
+}
+
+func TestManager_Actions_EditPrefs(t *testing.T) {
+	var captured *ipn.MaskedPrefs
+	client := &mockClient{
+		watchFn:  blockingWatch,
+		statusFn: func(ctx context.Context) (*ipnstate.Status, error) { return runningStatus(), nil },
+		editPrefsFn: func(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error) {
+			captured = mp
+			return &ipn.Prefs{}, nil
+		},
+	}
+
+	m := newManager(client)
+	defer m.Close()
+
+	require.NoError(t, m.Connect())
+	require.NotNil(t, captured)
+	assert.True(t, captured.WantRunningSet)
+	assert.True(t, captured.WantRunning)
+
+	require.NoError(t, m.Disconnect())
+	assert.True(t, captured.WantRunningSet)
+	assert.False(t, captured.WantRunning)
+
+	require.NoError(t, m.SetExitNode("nABC123"))
+	assert.True(t, captured.ExitNodeIDSet)
+	assert.Equal(t, tailcfg.StableNodeID("nABC123"), captured.ExitNodeID)
+	// ExitNodeIPSet must also be set so a stale legacy ExitNodeIP cannot
+	// override the ID-based selection (mirrors `tailscale set --exit-node`).
+	assert.True(t, captured.ExitNodeIPSet)
+
+	require.NoError(t, m.SetExitNode(""))
+	assert.True(t, captured.ExitNodeIDSet)
+	assert.Equal(t, tailcfg.StableNodeID(""), captured.ExitNodeID)
+	// Clearing must zero both the ID and any legacy IP-based exit node.
+	assert.True(t, captured.ExitNodeIPSet)
+
+	require.NoError(t, m.SetAllowLANAccess(true))
+	assert.True(t, captured.ExitNodeAllowLANAccessSet)
+	assert.True(t, captured.ExitNodeAllowLANAccess)
+}
+
+func TestManager_Actions_PropagateError(t *testing.T) {
+	client := &mockClient{
+		watchFn:  blockingWatch,
+		statusFn: func(ctx context.Context) (*ipnstate.Status, error) { return runningStatus(), nil },
+		editPrefsFn: func(ctx context.Context, mp *ipn.MaskedPrefs) (*ipn.Prefs, error) {
+			return nil, fmt.Errorf("backend rejected edit")
+		},
+	}
+
+	m := newManager(client)
+	defer m.Close()
+
+	assert.Error(t, m.Connect())
+	assert.Error(t, m.SetExitNode("nABC123"))
+	assert.Error(t, m.SetAllowLANAccess(true))
+}

core/internal/server/tailscale/types.go

@@ -2,30 +2,32 @@ package tailscale
 
 // TailscaleState represents the current state of the Tailscale daemon.
 type TailscaleState struct {
-	Connected      bool   `json:"connected"`
+	Connected              bool   `json:"connected"`
-	Version        string `json:"version"`
+	Version                string `json:"version"`
-	BackendState   string `json:"backendState"`
+	BackendState           string `json:"backendState"`
-	MagicDNSSuffix string `json:"magicDnsSuffix"`
+	MagicDNSSuffix         string `json:"magicDnsSuffix"`
-	TailnetName    string `json:"tailnetName"`
+	TailnetName            string `json:"tailnetName"`
-	Self           Peer   `json:"self"`
+	ExitNodeAllowLANAccess bool   `json:"exitNodeAllowLanAccess"`
-	Peers          []Peer `json:"peers"`
+	Self                   Peer   `json:"self"`
+	Peers                  []Peer `json:"peers"`
 }
 
 // Peer represents a single node in the Tailscale network.
 type Peer struct {
-	ID            string   `json:"id"`
+	ID             string   `json:"id"`
-	Hostname      string   `json:"hostname"`
+	Hostname       string   `json:"hostname"`
-	DNSName       string   `json:"dnsName"`
+	DNSName        string   `json:"dnsName"`
-	TailscaleIP   string   `json:"tailscaleIp"`
+	TailscaleIP    string   `json:"tailscaleIp"`
-	TailscaleIPv6 string   `json:"tailscaleIpv6,omitempty"`
+	TailscaleIPv6  string   `json:"tailscaleIpv6,omitempty"`
-	OS            string   `json:"os"`
+	OS             string   `json:"os"`
-	Online        bool     `json:"online"`
+	Online         bool     `json:"online"`
-	LastSeen      string   `json:"lastSeen,omitempty"`
+	LastSeen       string   `json:"lastSeen,omitempty"`
-	ExitNode      bool     `json:"exitNode"`
+	ExitNode       bool     `json:"exitNode"`
-	Tags          []string `json:"tags,omitempty"`
+	ExitNodeOption bool     `json:"exitNodeOption"`
-	Owner         string   `json:"owner"`
+	Tags           []string `json:"tags,omitempty"`
-	Relay         string   `json:"relay,omitempty"`
+	Owner          string   `json:"owner"`
-	Active        bool     `json:"active"`
+	Relay          string   `json:"relay,omitempty"`
-	RxBytes       int64    `json:"rxBytes"`
+	Active         bool     `json:"active"`
-	TxBytes       int64    `json:"txBytes"`
+	RxBytes        int64    `json:"rxBytes"`
+	TxBytes        int64    `json:"txBytes"`
 }

distro/scripts/ppa-build.sh

@@ -3,10 +3,10 @@
 # Usage: ./create-source.sh <package-dir> [ubuntu-series]
 #
 # Example:
-#   ./create-source.sh ../dms questing    # Ubuntu 25.10 (default series in ppa-upload)
+#   ./create-source.sh ../dms resolute     # Ubuntu 26.04 LTS (default series in ppa-upload)
-#   ./create-source.sh ../dms resolute     # Ubuntu 26.04 LTS
+#   ./create-source.sh ../dms stonking     # Ubuntu 26.10
-#   ./create-source.sh ../dms-git questing
 #   ./create-source.sh ../dms-git resolute
+#   ./create-source.sh ../dms-git stonking
 
 set -e
 
@@ -27,13 +27,13 @@ if [ $# -lt 1 ]; then
     echo "Arguments:"
     echo "  package-dir     : Path to package directory (e.g., ../dms)"
     echo "  ubuntu-series   : Ubuntu series (optional, default: noble)"
-    echo "                    Options: noble, jammy, oracular, mantic, questing, resolute"
+    echo "                    Options: noble, jammy, oracular, mantic, resolute, stonking"
     echo
     echo "Examples:"
-    echo "  $0 ../dms questing"
     echo "  $0 ../dms resolute"
-    echo "  $0 ../dms-git questing"
+    echo "  $0 ../dms stonking"
     echo "  $0 ../dms-git resolute"
+    echo "  $0 ../dms-git stonking"
     exit 1
 fi
 
@@ -135,7 +135,7 @@ check_ppa_version_exists() {
     local CHECK_MODE="${4:-commit}"
     local DISTRO_SERIES="${5:-}"
 
-    # Query Launchpad API (optionally scoped to one Ubuntu series so the same version can ship to questing and resolute)
+    # Query Launchpad API (optionally scoped to one Ubuntu series so the same version can ship to resolute and stonking)
     local API_URL="https://api.launchpad.net/1.0/~avengemedia/+archive/ubuntu/$PPA_NAME?ws.op=getPublishedSources&source_name=$SOURCE_NAME&status=Published"
     if [[ -n "$DISTRO_SERIES" ]]; then
         API_URL+="&distro_series=https://api.launchpad.net/1.0/ubuntu/${DISTRO_SERIES}"

distro/scripts/ppa-status.sh

@@ -10,8 +10,8 @@
 
 PPA_OWNER="avengemedia"
 LAUNCHPAD_API="https://api.launchpad.net/1.0"
-# Supported Ubuntu series for PPA builds (25.10 questing + 26.04 LTS resolute)
+# Supported Ubuntu series for PPA builds (26.04 LTS resolute + 26.10 stonking)
-DISTRO_SERIES_LIST=(questing resolute)
+DISTRO_SERIES_LIST=(resolute stonking)
 
 # Define packages (sync with ppa-upload.sh)
 ALL_PACKAGES=(dms dms-git dms-greeter)

distro/scripts/ppa-sync-plan.sh

@@ -5,7 +5,7 @@ set -euo pipefail
 
 PPA_OWNER="avengemedia"
 LAUNCHPAD_API="https://api.launchpad.net/1.0"
-SERIES_LIST=(questing resolute)
+SERIES_LIST=(resolute stonking)
 PACKAGE_FILTER="dms-git"
 REBUILD_RELEASE=""
 JSON=false
@@ -72,12 +72,12 @@ embedded_commit() {
 target_ppa() {
     local series="$1"
     if [[ -n "$REBUILD_RELEASE" ]]; then
-        if [[ "$series" == "resolute" ]]; then
+        if [[ "$series" == "stonking" ]]; then
             echo $((REBUILD_RELEASE + 1))
         else
             echo "$REBUILD_RELEASE"
         fi
-    elif [[ "$series" == "resolute" ]]; then
+    elif [[ "$series" == "stonking" ]]; then
         echo "2"
     else
         echo "1"

distro/scripts/ppa-upload.sh

@@ -3,13 +3,13 @@
 # Usage: ./ppa-upload.sh [package-name] [ppa-name] [ubuntu-series] [rebuild-number] [--keep-builds] [--rebuild=N]
 #
 # Examples:
-#   ./ppa-upload.sh dms                    # Upload to questing + resolute (default)
+#   ./ppa-upload.sh dms                    # Upload to resolute + stonking (default)
-#   ./ppa-upload.sh dms 2                 # Native: questing ppa2, resolute ppa3 (auto +1 on second series)
+#   ./ppa-upload.sh dms 2                 # Native: resolute ppa2, stonking ppa3 (auto +1 on second series)
 #   ./ppa-upload.sh dms --rebuild=2       # Rebuild with ppa2 (flag syntax)
 #   ./ppa-upload.sh dms-git               # Single package (both series)
 #   ./ppa-upload.sh all                   # All packages (each to both series)
 #   ./ppa-upload.sh dms resolute          # 26.04 LTS only (same as "dms dms resolute")
-#   ./ppa-upload.sh dms questing          # 25.10 only
+#   ./ppa-upload.sh dms stonking          # 26.10 only
 #   ./ppa-upload.sh dms dms resolute      # Explicit PPA name + one series (optional form)
 #   ./ppa-upload.sh dms dms resolute 2    # One series + rebuild number
 #   ./ppa-upload.sh distro/ubuntu/dms dms # Path-style (backward compatible)
@@ -70,8 +70,8 @@ if [[ ${#POSITIONAL_ARGS[@]} -gt 0 ]]; then
     fi
 fi
 
-# Shorthand: "dms resolute" / "dms questing" (package + series; PPA inferred — no need for "dms dms resolute")
+# Shorthand: "dms resolute" / "dms stonking" (package + series; PPA inferred — no need for "dms dms resolute")
-if [[ ${#POSITIONAL_ARGS[@]} -eq 2 ]] && [[ "${POSITIONAL_ARGS[1]}" == "questing" || "${POSITIONAL_ARGS[1]}" == "resolute" ]]; then
+if [[ ${#POSITIONAL_ARGS[@]} -eq 2 ]] && [[ "${POSITIONAL_ARGS[1]}" == "resolute" || "${POSITIONAL_ARGS[1]}" == "stonking" ]]; then
     PACKAGE_INPUT="${POSITIONAL_ARGS[0]}"
     PPA_NAME_INPUT=""
     UBUNTU_SERIES_RAW="${POSITIONAL_ARGS[1]}"
@@ -79,11 +79,11 @@ fi
 
 SERIES_LIST=()
 if [[ -z "$UBUNTU_SERIES_RAW" ]]; then
-    SERIES_LIST=(questing resolute)
+    SERIES_LIST=(resolute stonking)
-elif [[ "$UBUNTU_SERIES_RAW" == "questing" || "$UBUNTU_SERIES_RAW" == "resolute" ]]; then
+elif [[ "$UBUNTU_SERIES_RAW" == "resolute" || "$UBUNTU_SERIES_RAW" == "stonking" ]]; then
     SERIES_LIST=("$UBUNTU_SERIES_RAW")
 else
-    error "Invalid Ubuntu series: $UBUNTU_SERIES_RAW (use questing, resolute, or omit for both)"
+    error "Invalid Ubuntu series: $UBUNTU_SERIES_RAW (use resolute, stonking, or omit for both)"
     exit 1
 fi
 

distro/ubuntu/dms-greeter/debian/rules

@@ -40,10 +40,17 @@ override_dh_auto_install:
 	install -Dm644 DankMaterialShell-$(BASE_VERSION)/LICENSE \
 		debian/dms-greeter/usr/share/doc/dms-greeter/LICENSE
 
-	install -Dpm0644 DankMaterialShell-$(BASE_VERSION)/quickshell/systemd/tmpfiles-dms-greeter.conf \
+	# Install systemd tmpfiles/sysusers fragments only when present in the fetched source.
-		debian/dms-greeter/usr/lib/tmpfiles.d/dms-greeter.conf
+	# sysusers-dms-greeter.conf landed upstream after v1.4.6; guarding both lets older
-	install -Dm644 DankMaterialShell-$(BASE_VERSION)/quickshell/systemd/sysusers-dms-greeter.conf \
+	# release tarballs build, while future tags that ship the files install them automatically.
-		debian/dms-greeter/usr/lib/sysusers.d/dms-greeter.conf
+	if [ -f DankMaterialShell-$(BASE_VERSION)/quickshell/systemd/tmpfiles-dms-greeter.conf ]; then \
+		install -Dpm0644 DankMaterialShell-$(BASE_VERSION)/quickshell/systemd/tmpfiles-dms-greeter.conf \
+			debian/dms-greeter/usr/lib/tmpfiles.d/dms-greeter.conf; \
+	fi
+	if [ -f DankMaterialShell-$(BASE_VERSION)/quickshell/systemd/sysusers-dms-greeter.conf ]; then \
+		install -Dm644 DankMaterialShell-$(BASE_VERSION)/quickshell/systemd/sysusers-dms-greeter.conf \
+			debian/dms-greeter/usr/lib/sysusers.d/dms-greeter.conf; \
+	fi
 
 	# Create cache directory structure (will be created by postinst)
 	mkdir -p debian/dms-greeter/var/cache/dms-greeter

distro/void/README.md

@@ -0,0 +1,90 @@
+# Void Linux packaging
+
+XBPS templates for DankMaterialShell on [Void Linux](https://voidlinux.org).
+
+| Package | Source repo | Template |
+| --- | --- | --- |
+| `dms` | DankMaterialShell | [`srcpkgs/dms/template`](srcpkgs/dms/template) |
+| `dms-greeter` (optional) | DankMaterialShell | [`srcpkgs/dms-greeter/template`](srcpkgs/dms-greeter/template) |
+| `dgop` | AvengeMedia/dgop | maintained in the **danklinux** repo (`distro/void/srcpkgs/dgop`) |
+| `danksearch` | AvengeMedia/danksearch | maintained in the **danklinux** repo (`distro/void/srcpkgs/danksearch`) |
+
+All build from source.
+
+## Distribution
+
+These packages target the official
+[`void-linux/void-packages`](https://github.com/void-linux/void-packages)
+repository, so they install with a plain `xbps-install dms` and no extra setup.
+Most dependencies (`quickshell`, `matugen`, `cava`, `niri`, `greetd`, …) are
+already in Void; `dgop` and `danksearch` are packaged alongside in the
+[danklinux repo](https://github.com/AvengeMedia/danklinux/tree/master/distro/void).
+
+The templates here are the source of truth: copy each into a void-packages
+checkout at `srcpkgs/<pkg>/template` to build or submit it. Only tagged releases
+are packaged (no `-git`/nightly variant).
+
+## Dependencies
+
+Installing `dms` automatically pulls in `quickshell`, `accountsservice`, `dgop`,
+and `matugen` (which drives the Material You theming). The rest are optional —
+install whichever features you want:
+
+| Package | Enables |
+| --- | --- |
+| `danksearch` | launcher / filesystem search |
+| `cava` | audio visualiser widget |
+| `qt6-multimedia` | system sound feedback |
+| `qt6ct` | Qt app theming |
+| `wtype` | virtual keyboard input |
+| `power-profiles-daemon` | power profile control |
+| `cups-pk-helper` | printer management |
+| `NetworkManager` | network control |
+| `i2c-tools` | external-monitor brightness (DDC) |
+| `niri` / `hyprland` / `sway` | a Wayland compositor (niri is the team's choice) |
+
+## Building & testing
+
+Inside a `void-packages` checkout (symlink or copy these `srcpkgs/<pkg>` dirs in):
+
+```sh
+# build the dependency packages first (dms requires dgop)
+./xbps-src pkg dgop
+./xbps-src pkg danksearch
+./xbps-src pkg dms
+./xbps-src pkg dms-greeter      # optional
+
+# lint (xlint ships in the xtools package)
+xlint srcpkgs/dms/template
+
+# install the built packages
+sudo xbps-install --repository=hostdir/binpkgs dms dgop
+```
+
+`dms` requires Go ≥ 1.26 in the build environment (per `core/go.mod`).
+
+## Running the shell
+
+DMS is a user-level Wayland shell with **no system service** — start it from your
+compositor's autostart, e.g. niri:
+
+```kdl
+spawn-at-startup "dms" "run"
+```
+
+or Hyprland: `exec-once = dms run`.
+
+## Greeter (optional)
+
+Install `dms-greeter`, then let the CLI do the setup:
+
+```sh
+dms greeter enable      # configures greetd + the Void seat/PAM bits below
+dms greeter sync        # optional: share theming with the shell
+```
+
+`dms greeter enable` handles what logind does automatically on systemd: it points
+greetd at the greeter, enables `seatd`, adds `_greeter` to the `_seatd`/`video`/
+`input` groups, and adds `pam_rundir` to `/etc/pam.d/greetd` (so the post-login
+session gets an `XDG_RUNTIME_DIR`). A Wayland compositor and a working DRM device
+(`/dev/dri/card*`) are required and not pulled in automatically.

distro/void/srcpkgs/dms-greeter/INSTALL.msg

@@ -0,0 +1,15 @@
+dms-greeter installed.
+
+Configure and enable it with:
+
+    dms greeter enable
+
+This points greetd at the greeter and sets up everything Void needs that logind
+would handle on systemd: enables seatd, adds the greeter user to the seat/video/
+input groups, and adds pam_rundir to the greetd PAM stack. Optionally sync your
+shell theme into the greeter with:
+
+    dms greeter sync
+
+Requirements not pulled in automatically: a Wayland compositor (niri, hyprland,
+sway, …) and a working DRM device (/dev/dri/card*; in a VM, enable virtio-gpu).

distro/void/srcpkgs/dms-greeter/template

@@ -0,0 +1,35 @@
+# Template file for 'dms-greeter'
+#
+# greetd greeter for DankMaterialShell
+# Builds from the same DMS release tarball as 'dms'; keep version/checksum in sync.
+# Setup is done by `dms greeter enable`, not by this package — see distro/void/README.md.
+pkgname=dms-greeter
+version=1.4.6
+revision=1
+short_desc="DankMaterialShell greeter for greetd"
+maintainer="AvengeMedia <AvengeMedia.US@gmail.com>"
+license="MIT"
+homepage="https://danklinux.com"
+distfiles="https://github.com/AvengeMedia/DankMaterialShell/archive/refs/tags/v${version}.tar.gz"
+checksum=f54601e522c883fa9cce02bec070e4321e47389a1cf453e7ad0bb7379ad91b61
+
+depends="greetd quickshell acl-progs seatd pam_rundir"
+
+# Cache dir the greeter uses as $HOME (owned by greetd's _greeter user).
+make_dirs="/var/cache/dms-greeter 0750 _greeter _greeter"
+
+do_install() {
+	# Launcher wrapper -> /usr/bin/dms-greeter
+	vbin quickshell/Modules/Greetd/assets/dms-greeter
+
+	# Same QML tree as the shell; greeter mode is selected at runtime via DMS_RUN_GREETER.
+	vmkdir usr/share/quickshell/dms-greeter
+	vcopy "quickshell/*" usr/share/quickshell/dms-greeter
+
+	# Sample compositor configs for reference
+	vinstall quickshell/Modules/Greetd/assets/dms-niri.kdl 644 usr/share/dms-greeter
+	vinstall quickshell/Modules/Greetd/assets/dms-hypr.conf 644 usr/share/dms-greeter
+
+	vdoc quickshell/Modules/Greetd/README.md
+	vlicense LICENSE
+}

distro/void/srcpkgs/dms/template

@@ -0,0 +1,48 @@
+# Template file for 'dms'
+#
+# DankMaterialShell stable release
+#
+# NOTE: the binary is built with the `distro_binary` build tag, which is the
+# packaged variant upstream ships (it drops the in-app self-update command).
+pkgname=dms
+version=1.4.6
+revision=1
+build_style=go
+build_wrksrc="core"
+go_import_path="github.com/AvengeMedia/DankMaterialShell/core"
+go_package="${go_import_path}/cmd/dms"
+go_build_tags="distro_binary"
+go_ldflags="-X main.Version=${version}"
+short_desc="DankMaterialShell — Material 3 desktop shell for Wayland"
+maintainer="AvengeMedia <AvengeMedia.US@gmail.com>"
+license="MIT"
+homepage="https://danklinux.com"
+changelog="https://github.com/AvengeMedia/DankMaterialShell/releases"
+distfiles="https://github.com/AvengeMedia/DankMaterialShell/archive/refs/tags/v${version}.tar.gz"
+checksum=f54601e522c883fa9cce02bec070e4321e47389a1cf453e7ad0bb7379ad91b61
+
+# Optional feature deps (XBPS has no "recommends") are listed in distro/void/README.md.
+depends="quickshell accountsservice dgop matugen"
+
+post_install() {
+	# QML shell tree (build_style=go already installed the dms binary)
+	vmkdir usr/share/quickshell/dms
+	vcopy "${wrksrc}/quickshell/*" usr/share/quickshell/dms
+	echo "${version}" > "${DESTDIR}/usr/share/quickshell/dms/VERSION"
+
+	# Desktop entry + icon
+	vinstall "${wrksrc}/assets/dms-open.desktop" 644 usr/share/applications
+	vinstall "${wrksrc}/assets/danklogo.svg" 644 usr/share/icons/hicolor/scalable/apps
+
+	# Shell completions (generated by the built binary; skip when cross-building)
+	vmkdir usr/share/bash-completion/completions
+	vmkdir usr/share/zsh/site-functions
+	vmkdir usr/share/fish/vendor_completions.d
+	if [ -z "$CROSS_BUILD" ]; then
+		"${DESTDIR}/usr/bin/dms" completion bash > "${DESTDIR}/usr/share/bash-completion/completions/dms"
+		"${DESTDIR}/usr/bin/dms" completion zsh  > "${DESTDIR}/usr/share/zsh/site-functions/_dms"
+		"${DESTDIR}/usr/bin/dms" completion fish > "${DESTDIR}/usr/share/fish/vendor_completions.d/dms.fish"
+	fi
+
+	vlicense "${wrksrc}/LICENSE"
+}

quickshell/Common/KeyUtils.js

@@ -126,7 +126,40 @@ const KEY_MAP = {
     161: "exclamdown"
 };
 
-function xkbKeyFromQtKey(qk) {
+// Numpad (keypad) keys. Qt reuses the same Qt::Key_* values for the numpad and
+// the main rows/nav cluster; only Qt.KeypadModifier distinguishes them. niri and
+// the other compositors bind against the xkb KP_* keysym names, so we must emit
+// those instead of the collapsed twin. With NumLock off the numpad sends the
+// navigation keysyms (KP_Home, KP_End, ...); with NumLock on it sends KP_0..KP_9
+// (handled by the digit range in xkbKeyFromQtKey). Operators/Enter are the same
+// in both states.
+const KP_MAP = {
+    16777232: "KP_Home",
+    16777235: "KP_Up",
+    16777238: "KP_Prior",
+    16777234: "KP_Left",
+    16777227: "KP_Begin",
+    16777236: "KP_Right",
+    16777233: "KP_End",
+    16777237: "KP_Down",
+    16777239: "KP_Next",
+    16777222: "KP_Insert",
+    16777223: "KP_Delete",
+    16777221: "KP_Enter",
+    43: "KP_Add",
+    45: "KP_Subtract",
+    42: "KP_Multiply",
+    47: "KP_Divide",
+    46: "KP_Decimal"
+};
+
+function xkbKeyFromQtKey(qk, isKeypad) {
+    if (isKeypad) {
+        if (qk >= 48 && qk <= 57)
+            return "KP_" + (qk - 48);
+        if (KP_MAP[qk])
+            return KP_MAP[qk];
+    }
     if (qk >= 65 && qk <= 90)
         return String.fromCharCode(qk);
     if (qk >= 97 && qk <= 122)

quickshell/Common/Paths.qml

@@ -74,6 +74,15 @@ Singleton {
         return appId;
     }
 
+    function themedIconPath(name: string): string {
+        if (!name)
+            return "";
+        const themed = (typeof IconThemeService !== "undefined") ? IconThemeService.resolve(name) : "";
+        if (themed)
+            return themed;
+        return Quickshell.iconPath(name, true);
+    }
+
     function resolveIconPath(iconName: string): string {
         if (!iconName)
             return "";
@@ -83,23 +92,24 @@ Singleton {
                 return toFileUrl(expandTilde(moddedId));
             if (moddedId.startsWith("file://"))
                 return moddedId;
-            return Quickshell.iconPath(moddedId, true);
+            return themedIconPath(moddedId);
         }
-        return Quickshell.iconPath(iconName, true) || DesktopService.resolveIconPath(iconName);
+        return themedIconPath(iconName) || DesktopService.resolveIconPath(iconName);
     }
 
     function resolveIconUrl(iconName: string): string {
         if (!iconName)
             return "";
         const moddedId = moddedAppId(iconName);
-        if (moddedId !== iconName) {
+        const target = (moddedId !== iconName) ? moddedId : iconName;
-            if (moddedId.startsWith("~") || moddedId.startsWith("/"))
+        if (target.startsWith("~") || target.startsWith("/"))
-                return toFileUrl(expandTilde(moddedId));
+            return toFileUrl(expandTilde(target));
-            if (moddedId.startsWith("file://"))
+        if (target.startsWith("file://"))
-                return moddedId;
+            return target;
-            return "image://icon/" + moddedId;
+        const themed = (typeof IconThemeService !== "undefined") ? IconThemeService.resolve(target) : "";
-        }
+        if (themed)
-        return "image://icon/" + iconName;
+            return themed;
+        return "image://icon/" + target;
     }
 
     function getAppIcon(appId: string, desktopEntry: var): string {
@@ -113,10 +123,10 @@ Singleton {
             return resolveIconPath(appId);
 
         if (desktopEntry && desktopEntry.icon) {
-            return Quickshell.iconPath(desktopEntry.icon, true);
+            return themedIconPath(desktopEntry.icon);
         }
 
-        const icon = Quickshell.iconPath(appId, true);
+        const icon = themedIconPath(appId);
         if (icon && icon !== "")
             return icon;
 

quickshell/Common/SettingsData.qml

@@ -107,7 +107,10 @@ Singleton {
         saveSettings();
     }
 
+    property bool clipboardClickToPaste: false
     property bool clipboardEnterToPaste: false
+    property bool clipboardRememberTypeFilter: false
+    property string clipboardTypeFilter: "all"
     property var clipboardVisibleEntryActions: ["pin", "edit", "delete"]
 
     property var launcherPluginVisibility: ({})
@@ -164,6 +167,8 @@ Singleton {
     property real popupTransparency: 1.0
     property real dockTransparency: 1
     property string widgetBackgroundColor: "sch"
+    property string widgetBackgroundCustomColor: "#6750A4"
+    property real widgetBackgroundCustomStrength: 0.50
     property string widgetColorMode: "default"
     property string controlCenterTileColorMode: "primary"
     property string buttonColorMode: "primary"
@@ -237,6 +242,24 @@ Singleton {
     property string wallpaperFillMode: "Fill"
     property bool blurredWallpaperLayer: false
     property bool blurWallpaperOnOverview: false
+    property string wallpaperBackgroundColorMode: "black"
+    property string wallpaperBackgroundCustomColor: "#000000"
+    readonly property color effectiveWallpaperBackgroundColor: {
+        switch (wallpaperBackgroundColorMode) {
+        case "black":
+            return "#000000";
+        case "white":
+            return "#ffffff";
+        case "primary":
+            return Theme.primary;
+        case "surface":
+            return Theme.surfaceContainer;
+        case "custom":
+            return wallpaperBackgroundCustomColor;
+        default:
+            return "#000000";
+        }
+    }
 
     property bool frameEnabled: false
     onFrameEnabledChanged: saveSettings()
@@ -385,11 +408,16 @@ Singleton {
     property bool dwlShowAllTags: false
     property bool workspaceActiveAppHighlightEnabled: false
     property string workspaceColorMode: "default"
+    property string workspaceFocusedCustomColor: "#6750A4"
     property string workspaceOccupiedColorMode: "none"
+    property string workspaceOccupiedCustomColor: "#625B71"
     property string workspaceUnfocusedColorMode: "default"
+    property string workspaceUnfocusedCustomColor: "#49454E"
     property string workspaceUrgentColorMode: "default"
+    property string workspaceUrgentCustomColor: "#B3261E"
     property bool workspaceFocusedBorderEnabled: false
     property string workspaceFocusedBorderColor: "primary"
+    property string workspaceFocusedBorderCustomColor: "#6750A4"
     property int workspaceFocusedBorderThickness: 2
     property var workspaceNameIcons: ({})
     property bool waveProgressEnabled: true
@@ -455,6 +483,7 @@ Singleton {
     onAppDrawerSectionViewModesChanged: saveSettings()
     property bool niriOverviewOverlayEnabled: true
     property string dankLauncherV2Size: "compact"
+    property bool dankLauncherV2ShowSourceBadges: true
     property bool dankLauncherV2BorderEnabled: false
     property int dankLauncherV2BorderThickness: 2
     property string dankLauncherV2BorderColor: "primary"
@@ -465,6 +494,8 @@ Singleton {
     property bool launcherUseOverlayLayer: false
     property string launcherStyle: "full"
     property bool spotlightBarShowModeChips: false
+    property bool keybindsFloatingWindow: false
+    onKeybindsFloatingWindowChanged: saveSettings()
 
     property string _legacyWeatherLocation: "New York, NY"
     property string _legacyWeatherCoordinates: "40.7128,-74.0060"
@@ -476,7 +507,11 @@ Singleton {
 
     property string networkPreference: "auto"
 
-    property string iconTheme: "System Default"
+    property string iconThemeDark: "System Default"
+    property string iconThemeLight: "System Default"
+    property bool iconThemePerMode: false
+    property string lastAppliedIconTheme: ""
+    readonly property string iconTheme: resolveIconTheme()
     property var availableIconThemes: ["System Default"]
     property string systemDefaultIconTheme: ""
     property bool qt5ctAvailable: false
@@ -572,6 +607,7 @@ Singleton {
     property bool soundVolumeChanged: true
     property bool soundPluggedIn: true
     property bool soundLogin: false
+    property bool muteSoundsWhenMediaPlaying: true
 
     property int acMonitorTimeout: 0
     property int acLockTimeout: 0
@@ -586,6 +622,13 @@ Singleton {
     property string batteryProfileName: ""
     property int batteryPostLockMonitorTimeout: 0
     property int batteryChargeLimit: 100
+    property bool batteryNotifyChargeLimit: false
+    property int batteryCriticalThreshold: 10
+    property bool batteryNotifyCritical: true
+    property int batteryLowThreshold: 20
+    property bool batteryNotifyLow: false
+    property int batteryNotificationType: 0
+    property bool batteryAutoPowerSaver: false
     property bool lockBeforeSuspend: false
     property bool loginctlLockIntegration: true
     property bool fadeToLockEnabled: true
@@ -1260,14 +1303,67 @@ Singleton {
             MangoService.generateLayoutConfig();
     }
 
+    function resolveIconTheme() {
+        if (iconThemePerMode && typeof SessionData !== "undefined" && SessionData.isLightMode)
+            return iconThemeLight;
+        return iconThemeDark;
+    }
+
     function applyStoredIconTheme() {
         updateGtkIconTheme();
         updateQtIconTheme();
         updateCosmicIconTheme();
     }
 
+    function setIconThemeUnmanaged() {
+        iconThemePerMode = false;
+        iconThemeDark = "System Default";
+        iconThemeLight = "System Default";
+        lastAppliedIconTheme = "";
+        saveSettings();
+    }
+
+    function checkIconThemeDrift() {
+        if (isGreeterMode)
+            return;
+        if (resolveIconTheme() === "System Default")
+            return;
+        if (!lastAppliedIconTheme)
+            return;
+        const script = `if command -v gsettings >/dev/null 2>&1; then
+        gsettings get org.gnome.desktop.interface icon-theme 2>/dev/null | sed "s/'//g"
+        elif command -v dconf >/dev/null 2>&1; then
+        dconf read /org/gnome/desktop/interface/icon-theme 2>/dev/null | sed "s/'//g"
+        fi`;
+
+        Proc.runCommand("iconThemeDriftCheck", ["sh", "-c", script], (output, exitCode) => {
+            const platform = (output || "").trim();
+            if (!platform)
+                return;
+            if (platform === root.lastAppliedIconTheme || platform === root.iconThemeDark || platform === root.iconThemeLight)
+                return;
+            root.setIconThemeUnmanaged();
+            ToastService.showWarning(I18n.tr("Icon theme changed outside DMS; switched to System Default", "shown when an external tool overrides the icon theme DMS applied"));
+        });
+    }
+
+    Connections {
+        target: typeof SessionData !== "undefined" ? SessionData : null
+        function onIsLightModeChanged() {
+            if (!SessionData.isSwitchingMode)
+                return;
+            if (!root.iconThemePerMode)
+                return;
+            if (root.iconThemeLight === root.iconThemeDark)
+                return;
+            root.applyStoredIconTheme();
+            root.saveSettings();
+        }
+    }
+
     function updateCosmicIconTheme() {
-        let cosmicThemeName = (iconTheme === "System Default") ? systemDefaultIconTheme : iconTheme;
+        const resolved = resolveIconTheme();
+        let cosmicThemeName = (resolved === "System Default") ? systemDefaultIconTheme : resolved;
         if (!cosmicThemeName || cosmicThemeName === "System Default") {
             const detectScript = `if command -v gsettings >/dev/null 2>&1; then
             gsettings get org.gnome.desktop.interface icon-theme 2>/dev/null | sed "s/'//g"
@@ -1303,9 +1399,11 @@ Singleton {
     }
 
     function updateGtkIconTheme() {
-        const gtkThemeName = (iconTheme === "System Default") ? systemDefaultIconTheme : iconTheme;
+        const resolved = resolveIconTheme();
+        const gtkThemeName = (resolved === "System Default") ? systemDefaultIconTheme : resolved;
         if (gtkThemeName === "System Default" || gtkThemeName === "")
             return;
+        lastAppliedIconTheme = gtkThemeName;
         if (typeof DMSService !== "undefined" && DMSService.apiVersion >= 3 && typeof PortalService !== "undefined") {
             PortalService.setSystemIconTheme(gtkThemeName);
         }
@@ -1330,13 +1428,20 @@ Singleton {
         fi
         done
 
+        if command -v gsettings >/dev/null 2>&1; then
+        gsettings set org.gnome.desktop.interface icon-theme '${gtkThemeName}' 2>/dev/null || true
+        elif command -v dconf >/dev/null 2>&1; then
+        dconf write /org/gnome/desktop/interface/icon-theme "'${gtkThemeName}'" 2>/dev/null || true
+        fi
+
         pkill -HUP -f 'gtk' 2>/dev/null || true`;
 
         Quickshell.execDetached(["sh", "-lc", configScript]);
     }
 
     function updateQtIconTheme() {
-        const qtThemeName = (iconTheme === "System Default") ? "" : iconTheme;
+        const resolved = resolveIconTheme();
+        const qtThemeName = (resolved === "System Default") ? "" : resolved;
         if (!qtThemeName)
             return;
         const home = _homeUrl.replace("file://", "").replace(/'/g, "'\\''");
@@ -1423,6 +1528,9 @@ Singleton {
             if (obj?.directionalAnimationMode === 3 && frameMode !== "connected")
                 frameMode = "connected";
 
+            if (obj?.iconTheme !== undefined && obj?.iconThemeDark === undefined)
+                iconThemeDark = obj.iconTheme;
+
             if (obj?.weatherLocation !== undefined)
                 _legacyWeatherLocation = obj.weatherLocation;
             if (obj?.weatherCoordinates !== undefined)
@@ -1438,6 +1546,7 @@ Singleton {
             applyStoredTheme();
             updateCompositorCursor();
             Processes.detectQtTools();
+            Qt.callLater(checkIconThemeDrift);
 
             _checkSettingsWritable();
         } catch (e) {
@@ -2445,10 +2554,24 @@ Singleton {
     }
 
     function setIconTheme(themeName) {
-        iconTheme = themeName;
+        const light = iconThemePerMode && typeof SessionData !== "undefined" && SessionData.isLightMode;
-        updateGtkIconTheme();
+        setIconThemeForMode(themeName, light);
-        updateQtIconTheme();
+    }
-        updateCosmicIconTheme();
+
+    function setIconThemeForMode(themeName, light) {
+        if (light)
+            iconThemeLight = themeName;
+        else
+            iconThemeDark = themeName;
+        applyStoredIconTheme();
+        saveSettings();
+        if (typeof Theme !== "undefined" && Theme.currentTheme === Theme.dynamic)
+            Theme.generateSystemThemesFromCurrentTheme();
+    }
+
+    function setIconThemePerMode(enabled) {
+        iconThemePerMode = enabled;
+        applyStoredIconTheme();
         saveSettings();
         if (typeof Theme !== "undefined" && Theme.currentTheme === Theme.dynamic)
             Theme.generateSystemThemesFromCurrentTheme();

quickshell/Common/Theme.qml

@@ -450,7 +450,9 @@ Singleton {
                 "primaryText": getMatugenColor("on_primary", "#ffffff"),
                 "primaryContainer": getMatugenColor("primary_container", "#1976d2"),
                 "secondary": getMatugenColor("secondary", "#8ab4f8"),
+                "secondaryContainer": getMatugenColor("secondary_container", getMatugenColor("surface_container_high", "#292b2f")),
                 "tertiary": getMatugenColor("tertiary", "#efb8c8"),
+                "tertiaryContainer": getMatugenColor("tertiary_container", getMatugenColor("surface_container_high", "#292b2f")),
                 "surface": getMatugenColor("surface", "#1a1c1e"),
                 "surfaceText": getMatugenColor("on_background", "#e3e8ef"),
                 "surfaceVariant": getMatugenColor("surface_variant", "#44464f"),
@@ -521,7 +523,6 @@ Singleton {
 
     property color primary: currentThemeData.primary
     property color primaryText: currentThemeData.primaryText
-    property color primaryContainer: currentThemeData.primaryContainer
     property color secondary: currentThemeData.secondary
     property color tertiary: currentThemeData.tertiary || currentThemeData.secondary
     property color surface: currentThemeData.surface
@@ -536,6 +537,9 @@ Singleton {
     property color surfaceContainer: currentThemeData.surfaceContainer
     property color surfaceContainerHigh: currentThemeData.surfaceContainerHigh
     property color surfaceContainerHighest: currentThemeData.surfaceContainerHighest || surfaceContainerHigh
+    property color primaryContainer: currentThemeData.primaryContainer || blend(surfaceContainerHigh, primary, 0.45)
+    property color secondaryContainer: currentThemeData.secondaryContainer || blend(surfaceContainerHigh, secondary, 0.35)
+    property color tertiaryContainer: currentThemeData.tertiaryContainer || blend(surfaceContainerHigh, tertiary, 0.35)
 
     property color onSurface: surfaceText
     property color onSurfaceVariant: surfaceVariantText
@@ -577,6 +581,45 @@ Singleton {
     readonly property int layerOutlineWidth: BlurService.enabled && layerOutlineOpacity > 0 ? 1 : 0
     property color surfaceTextHover: Qt.rgba(surfaceText.r, surfaceText.g, surfaceText.b, 0.08)
     property color surfaceTextAlpha: Qt.rgba(surfaceText.r, surfaceText.g, surfaceText.b, 0.3)
+
+    function roleColor(mode) {
+        switch (mode) {
+        case "primary":
+        case "pri":
+            return primary;
+        case "primaryContainer":
+            return primaryContainer;
+        case "secondary":
+        case "sec":
+            return secondary;
+        case "secondaryContainer":
+            return secondaryContainer;
+        case "tertiary":
+        case "ter":
+            return tertiary;
+        case "tertiaryContainer":
+            return tertiaryContainer;
+        case "surfaceText":
+            return surfaceText;
+        case "surfaceVariant":
+            return surfaceVariant;
+        case "s":
+            return surface;
+        case "sc":
+            return surfaceContainer;
+        case "sch":
+            return surfaceContainerHigh;
+        case "schh":
+            return surfaceContainerHighest;
+        case "sth":
+            return surfaceTextHover;
+        case "error":
+        case "err":
+            return error;
+        default:
+            return "transparent";
+        }
+    }
     property color surfaceTextLight: Qt.rgba(surfaceText.r, surfaceText.g, surfaceText.b, 0.06)
     property color surfaceTextMedium: Qt.rgba(surfaceText.r, surfaceText.g, surfaceText.b, 0.7)
 
@@ -1430,9 +1473,22 @@ Singleton {
 
     property bool widgetBackgroundHasAlpha: {
         const colorMode = typeof SettingsData !== "undefined" ? SettingsData.widgetBackgroundColor : "sch";
-        return colorMode === "sth";
+        return colorMode === "sth" || colorMode === "custom";
     }
 
+    function safeColor(value, fallback) {
+        try {
+            if (value === undefined || value === null || value === "")
+                return fallback;
+            return Qt.color(value);
+        } catch (e) {
+            return fallback;
+        }
+    }
+
+    readonly property color widgetBackgroundCustomBaseColor: safeColor(typeof SettingsData !== "undefined" ? SettingsData.widgetBackgroundCustomColor : "#6750A4", primaryContainer)
+    readonly property real widgetBackgroundCustomStrength: Math.max(0, Math.min(1, typeof SettingsData !== "undefined" ? (SettingsData.widgetBackgroundCustomStrength ?? 0.4) : 0.4))
+
     property var widgetBaseBackgroundColor: {
         const colorMode = typeof SettingsData !== "undefined" ? SettingsData.widgetBackgroundColor : "sch";
         switch (colorMode) {
@@ -1442,6 +1498,14 @@ Singleton {
             return surfaceContainer;
         case "sch":
             return surfaceContainerHigh;
+        case "primaryContainer":
+            return primaryContainer;
+        case "secondaryContainer":
+            return secondaryContainer;
+        case "tertiaryContainer":
+            return tertiaryContainer;
+        case "custom":
+            return blend(surfaceContainerHigh, widgetBackgroundCustomBaseColor, widgetBackgroundCustomStrength);
         case "sth":
         default:
             return surfaceTextHover;

quickshell/Common/settings/SettingsSpec.js

@@ -19,6 +19,8 @@ var SPEC = {
     dockTransparency: { def: 1.0, coerce: percentToUnit },
 
     widgetBackgroundColor: { def: "sch" },
+    widgetBackgroundCustomColor: { def: "#6750A4" },
+    widgetBackgroundCustomStrength: { def: 0.50, coerce: percentToUnit },
     widgetColorMode: { def: "default" },
     controlCenterTileColorMode: { def: "primary" },
     buttonColorMode: { def: "primary" },
@@ -72,6 +74,8 @@ var SPEC = {
     wallpaperFillMode: { def: "Fill" },
     blurredWallpaperLayer: { def: false },
     blurWallpaperOnOverview: { def: false },
+    wallpaperBackgroundColorMode: { def: "black" },
+    wallpaperBackgroundCustomColor: { def: "#000000" },
 
     showLauncherButton: { def: true },
     showWorkspaceSwitcher: { def: true },
@@ -144,11 +148,16 @@ var SPEC = {
     dwlShowAllTags: { def: false },
     workspaceActiveAppHighlightEnabled: { def: false },
     workspaceColorMode: { def: "default" },
+    workspaceFocusedCustomColor: { def: "#6750A4" },
     workspaceOccupiedColorMode: { def: "none" },
+    workspaceOccupiedCustomColor: { def: "#625B71" },
     workspaceUnfocusedColorMode: { def: "default" },
+    workspaceUnfocusedCustomColor: { def: "#49454E" },
     workspaceUrgentColorMode: { def: "default" },
+    workspaceUrgentCustomColor: { def: "#B3261E" },
     workspaceFocusedBorderEnabled: { def: false },
     workspaceFocusedBorderColor: { def: "primary" },
+    workspaceFocusedBorderCustomColor: { def: "#6750A4" },
     workspaceFocusedBorderThickness: { def: 2 },
     workspaceNameIcons: { def: {} },
     waveProgressEnabled: { def: true },
@@ -220,6 +229,7 @@ var SPEC = {
     appDrawerSectionViewModes: { def: {} },
     niriOverviewOverlayEnabled: { def: true },
     dankLauncherV2Size: { def: "compact" },
+    dankLauncherV2ShowSourceBadges: { def: true },
     dankLauncherV2BorderEnabled: { def: false },
     dankLauncherV2BorderThickness: { def: 2 },
     dankLauncherV2BorderColor: { def: "primary" },
@@ -230,13 +240,17 @@ var SPEC = {
     launcherUseOverlayLayer: { def: false },
     launcherStyle: { def: "full" },
     spotlightBarShowModeChips: { def: false },
+    keybindsFloatingWindow: { def: false },
 
     useAutoLocation: { def: false },
     weatherEnabled: { def: true },
 
     networkPreference: { def: "auto" },
 
-    iconTheme: { def: "System Default", onChange: "applyStoredIconTheme" },
+    iconThemeDark: { def: "System Default", onChange: "applyStoredIconTheme" },
+    iconThemeLight: { def: "System Default", onChange: "applyStoredIconTheme" },
+    iconThemePerMode: { def: false, onChange: "applyStoredIconTheme" },
+    lastAppliedIconTheme: { def: "" },
     availableIconThemes: { def: ["System Default"], persist: false },
     systemDefaultIconTheme: { def: "", persist: false },
     qt5ctAvailable: { def: false, persist: false },
@@ -282,6 +296,7 @@ var SPEC = {
     soundNewNotification: { def: true },
     soundVolumeChanged: { def: true },
     soundPluggedIn: { def: true },
+    muteSoundsWhenMediaPlaying: { def: true },
 
     acMonitorTimeout: { def: 0 },
     acLockTimeout: { def: 0 },
@@ -296,6 +311,13 @@ var SPEC = {
     batteryProfileName: { def: "" },
     batteryPostLockMonitorTimeout: { def: 0 },
     batteryChargeLimit: { def: 100 },
+    batteryNotifyChargeLimit: { def: false },
+    batteryCriticalThreshold: { def: 10 },
+    batteryNotifyCritical: { def: true },
+    batteryLowThreshold: { def: 20 },
+    batteryNotifyLow: { def: false },
+    batteryNotificationType: { def: 0 },
+    batteryAutoPowerSaver: { def: false },
     lockBeforeSuspend: { def: false },
     loginctlLockIntegration: { def: true },
     fadeToLockEnabled: { def: true },
@@ -581,7 +603,10 @@ var SPEC = {
     desktopWidgetGroups: { def: [] },
 
     builtInPluginSettings: { def: {} },
+    clipboardClickToPaste: { def: false },
     clipboardEnterToPaste: { def: false },
+    clipboardRememberTypeFilter: { def: false },
+    clipboardTypeFilter: { def: "all" },
     clipboardVisibleEntryActions: { def: ["pin", "edit", "delete"] },
 
     launcherPluginVisibility: { def: {} },

quickshell/DMSShell.qml

@@ -116,6 +116,12 @@ Item {
                         fadeWindowLoader.item.cancelFade();
                     }
                 }
+
+                function onDismissFadeToLock() {
+                    if (fadeWindowLoader.item) {
+                        fadeWindowLoader.item.dismiss();
+                    }
+                }
             }
         }
     }
@@ -317,6 +323,9 @@ Item {
 
     property bool hadRealScreen: true
     property var previousRealScreenNames: []
+    // Guards for the screen-reconnect recovery path (see scheduleScreenReconnectRecovery).
+    property bool _screenRecoveryCooldown: false
+    property bool _screenRecoveryPending: false
 
     function _getRealScreenNames() {
         const names = [];
@@ -359,15 +368,60 @@ Item {
             const partialReconnect = root.previousRealScreenNames.length > 0
                 && currentNames.some(name => !root.previousRealScreenNames.includes(name));
             if (fullReconnect || partialReconnect) {
-                log.info("Screen reconnect detected, triggering surface recovery",
+                log.info("Screen reconnect detected, scheduling surface recovery",
                          "full:", fullReconnect, "partial:", partialReconnect);
-                root.triggerSurfaceRecovery("screen-reconnect");
+                root.scheduleScreenReconnectRecovery();
             }
             root.hadRealScreen = hasReal;
             root.previousRealScreenNames = currentNames;
         }
     }
 
+    // A DPMS off/on cycle removes an output from the screen list and re-adds it,
+    // which is indistinguishable here from a hotplug. Recovering immediately on
+    // every such event lets a flapping monitor (or a recovery that itself perturbs
+    // the output) drive an endless recovery storm that power-cycles the display
+    // (#2642). Debounce a burst of changes into a single pass, then hold a cooldown
+    // so repeated flaps trigger at most one recovery per window. Recovery still runs
+    // once per resume, so a partial DPMS resume keeps redrawing its surfaces (#2579).
+    function scheduleScreenReconnectRecovery() {
+        if (root._screenRecoveryCooldown) {
+            root._screenRecoveryPending = true;
+            return;
+        }
+        screenReconnectDebounce.restart();
+    }
+
+    Timer {
+        id: screenReconnectDebounce
+        // Wide enough to collapse the output-remove + output-re-add pair that one
+        // DPMS off/on cycle emits as two near-simultaneous events into one recovery.
+        interval: 450
+        repeat: false
+        onTriggered: {
+            root._screenRecoveryCooldown = true;
+            root._screenRecoveryPending = false;
+            screenReconnectCooldown.restart();
+            root.triggerSurfaceRecovery("screen-reconnect");
+        }
+    }
+
+    Timer {
+        id: screenReconnectCooldown
+        // Must exceed the full two-pass surfaceResumeRecoveryTimer sequence
+        // (800 + 2000 ms) so the cooldown still covers an in-flight recovery;
+        // raise this if those passes are lengthened.
+        interval: 4000
+        repeat: false
+        onTriggered: {
+            root._screenRecoveryCooldown = false;
+            if (root._screenRecoveryPending) {
+                root._screenRecoveryPending = false;
+                screenReconnectDebounce.restart();
+            }
+        }
+    }
+
     Timer {
         id: surfaceResumeRecoveryTimer
         interval: 800
@@ -653,7 +707,7 @@ Item {
             if (!wifiPasswordModalLoader.item)
                 return;
 
-            if (wifiPasswordModalLoader.item.visible && timeSinceLastPrompt < 1000) {
+            if (wifiPasswordModalLoader.item.shouldBeVisible && timeSinceLastPrompt < 1000) {
                 NetworkService.cancelCredentials(lastCredentialsToken);
                 lastCredentialsToken = token;
                 lastCredentialsTime = now;
@@ -997,6 +1051,14 @@ Item {
             osdResumeRecreateTimer.interval = 400;
             osdResumeRecreateTimer.restart();
 
+            // This path runs its own recovery directly, so drop any queued or
+            // in-flight screen-reconnect recovery to avoid a redundant pass once
+            // its cooldown expires.
+            screenReconnectDebounce.stop();
+            screenReconnectCooldown.stop();
+            root._screenRecoveryCooldown = false;
+            root._screenRecoveryPending = false;
+
             root.triggerSurfaceRecovery("sessionResumed");
         }
     }

quickshell/Modals/Clipboard/ClipboardContent.qml

@@ -2,6 +2,7 @@ import QtQuick
 import Quickshell
 import qs.Common
 import qs.Widgets
+import qs.Services
 
 Item {
     id: clipboardContent
@@ -11,8 +12,70 @@ Item {
     property alias searchField: searchField
     property alias clipboardListView: clipboardListView
 
+    readonly property var filterOptions: [I18n.tr("All"), I18n.tr("Text"), I18n.tr("Long Text"), I18n.tr("Image")]
+    readonly property var filterValues: ["all", "text", "long_text", "image"]
+
+    function closeFilterMenu() {
+        filterMenuLoader.active = false;
+        filterMenuLoader.active = true;
+    }
+
+    function showContextMenu(entry, sceneX, sceneY) {
+        const localPos = mapFromItem(null, sceneX, sceneY);
+        contextMenu.show(localPos.x, localPos.y, entry);
+    }
+
+    function contextEntryAtScreen(screenX, screenY) {
+        const host = modal.surfaceHost ?? null;
+        const hostX = host?.alignedX;
+        const hostY = host?.renderedAlignedY ?? host?.alignedY;
+
+        if (!isNaN(hostX) && !isNaN(hostY))
+            return contextEntryAtLocal(screenX - hostX, screenY - hostY);
+
+        const screenRef = host?.effectiveScreen ?? host?.screen ?? modal.Window?.window?.screen ?? null;
+        const globalOrigin = mapToGlobal(0, 0);
+        const screenOriginX = screenRef?.x || 0;
+        const screenOriginY = screenRef?.y || 0;
+        return contextEntryAtLocal(screenOriginX + screenX - globalOrigin.x, screenOriginY + screenY - globalOrigin.y);
+    }
+
+    function contextEntryAtLocal(localX, localY) {
+        const listView = modal.activeTab === "saved" ? savedListView : clipboardListView;
+        const entries = modal.activeTab === "saved" ? modal.pinnedEntries : modal.unpinnedEntries;
+
+        if (!listView.visible || !entries)
+            return null;
+
+        const listPos = mapToItem(listView, localX, localY);
+        if (listPos.x < 0 || listPos.x > listView.width || listPos.y < 0 || listPos.y > listView.height)
+            return null;
+
+        const index = listView.indexAt(listPos.x + listView.contentX, listPos.y + listView.contentY);
+        if (index < 0 || index >= entries.length)
+            return null;
+
+        return {
+            entry: entries[index],
+            x: localX,
+            y: localY
+        };
+    }
+
+    function closeContextMenu() {
+        contextMenu.hide();
+    }
+
+    readonly property bool contextMenuActive: contextMenu.openState
+
     anchors.fill: parent
 
+    ClipboardContextMenu {
+        id: contextMenu
+        modal: clipboardContent.modal
+        parentHandler: clipboardContent
+    }
+
     Column {
         id: headerColumn
         anchors.top: parent.top
@@ -36,27 +99,87 @@ Item {
             onCloseClicked: modal.hide()
         }
 
-        DankTextField {
+        Item {
-            id: searchField
+            id: searchRow
             width: parent.width
-            placeholderText: ""
+            implicitHeight: searchField.height
-            leftIconName: "search"
+
-            showClearButton: true
+            DankTextField {
-            focus: true
+                id: searchField
-            ignoreTabKeys: true
+
-            keyForwardTargets: [modal.modalFocusScope]
+                width: parent.width
-            onTextChanged: {
+                rightAccessoryWidth: filterButton.width + Theme.spacingS
-                modal.searchText = text;
+                placeholderText: ""
-                modal.updateFilteredModel();
+                leftIconName: "search"
+                showClearButton: true
+                focus: true
+                ignoreTabKeys: true
+                keyForwardTargets: [modal.modalFocusScope]
+
+                onTextChanged: {
+                    modal.searchText = text;
+                    modal.updateFilteredModel();
+                    ClipboardService.selectedIndex = 0;
+                    ClipboardService.keyboardNavigationActive = true;
+                    Qt.callLater(function () {
+                        clipboardListView.positionViewAtBeginning();
+                        savedListView.positionViewAtBeginning();
+                    });
+                }
+
+                Keys.onEscapePressed: function (event) {
+                    modal.hide();
+                    event.accepted = true;
+                }
+
+                Component.onCompleted: {
+                    Qt.callLater(function () {
+                        forceActiveFocus();
+                    });
+                }
             }
-            Keys.onEscapePressed: function (event) {
+
-                modal.hide();
+            DankActionButton {
-                event.accepted = true;
+                id: filterButton
+
+                anchors.right: parent.right
+                anchors.rightMargin: Theme.spacingS
+                anchors.verticalCenter: parent.verticalCenter
+                iconName: "filter_list"
+                iconColor: modal.activeFilter !== "all" ? Theme.primary : Theme.surfaceText
+                backgroundColor: modal.activeFilter !== "all" ? Theme.primarySelected : "transparent"
+                tooltipText: I18n.tr("Filter by type", "Clipboard history type filter button tooltip")
+                onClicked: filterMenuLoader.item?.openDropdownMenu()
             }
-            Component.onCompleted: {
+
-                Qt.callLater(function () {
+            Loader {
-                    forceActiveFocus();
+                id: filterMenuLoader
-                });
+
+                active: true
+                sourceComponent: filterMenuComponent
+            }
+
+            Component {
+                id: filterMenuComponent
+
+                DankDropdown {
+                    showTrigger: false
+                    popupAnchorItem: filterButton
+                    popupWidth: 180
+                    alignPopupRight: true
+                    options: clipboardContent.filterOptions
+                    currentValue: {
+                        const idx = clipboardContent.filterValues.indexOf(clipboardContent.modal.activeFilter);
+                        return idx >= 0 ? clipboardContent.filterOptions[idx] : clipboardContent.filterOptions[0];
+                    }
+
+                    onValueChanged: value => {
+                        const idx = clipboardContent.filterOptions.indexOf(value);
+                        if (idx >= 0) {
+                            clipboardContent.modal.activeFilter = clipboardContent.filterValues[idx];
+                        }
+                    }
+                }
             }
         }
     }
@@ -140,10 +263,12 @@ Item {
                 modal: clipboardContent.modal
                 listView: clipboardListView
                 onCopyRequested: clipboardContent.modal.copyEntry(modelData)
+                onPasteRequested: clipboardContent.modal.pasteEntry(modelData)
                 onDeleteRequested: clipboardContent.modal.deleteEntry(modelData)
                 onPinRequested: targetEntry => clipboardContent.modal.pinEntry(targetEntry)
                 onUnpinRequested: targetEntry => clipboardContent.modal.unpinEntry(targetEntry)
                 onEditRequested: clipboardContent.modal.editEntry(modelData)
+                onContextMenuRequested: (mouseX, mouseY) => clipboardContent.showContextMenu(modelData, mouseX, mouseY)
             }
         }
 
@@ -214,10 +339,12 @@ Item {
                 modal: clipboardContent.modal
                 listView: savedListView
                 onCopyRequested: clipboardContent.modal.copyEntry(modelData)
+                onPasteRequested: clipboardContent.modal.pasteEntry(modelData)
                 onDeleteRequested: clipboardContent.modal.deletePinnedEntry(modelData)
                 onPinRequested: targetEntry => clipboardContent.modal.pinEntry(targetEntry)
                 onUnpinRequested: targetEntry => clipboardContent.modal.unpinEntry(targetEntry)
                 onEditRequested: clipboardContent.modal.editEntry(modelData)
+                onContextMenuRequested: (mouseX, mouseY) => clipboardContent.showContextMenu(modelData, mouseX, mouseY)
             }
         }
 

quickshell/Modals/Clipboard/ClipboardContextMenu.qml

@@ -0,0 +1,400 @@
+pragma ComponentBehavior: Bound
+
+import QtQuick
+import Quickshell
+import Quickshell.Wayland
+import qs.Common
+import qs.Services
+import qs.Widgets
+
+Item {
+    id: root
+
+    visible: false
+    width: 0
+    height: 0
+
+    property var entry: null
+    property var modal: null
+    property var parentHandler: null
+    property real menuMargin: 8
+    property var targetScreen: null
+    property real anchorX: 0
+    property real anchorY: 0
+    property bool openState: false
+    property bool renderActive: false
+    readonly property bool blurActive: renderActive && openState && BlurService.enabled && Theme.connectedSurfaceBlurEnabled
+
+    readonly property bool hasPinnedDuplicate: !!entry && !entry.pinned && ClipboardService.getPinnedEntryByHash(entry.hash) !== null
+    readonly property bool canEditEntry: !!entry && !(entry.isImage ?? false)
+    readonly property string pinText: entry?.pinned || hasPinnedDuplicate ? I18n.tr("Unpin") : I18n.tr("Pin")
+    readonly property string pinIcon: entry?.pinned || hasPinnedDuplicate ? "keep_off" : "push_pin"
+
+    readonly property var menuItems: {
+        const items = [
+            {
+                type: "item",
+                icon: "content_copy",
+                text: I18n.tr("Copy"),
+                action: copyEntry
+            },
+            {
+                type: "item",
+                icon: pinIcon,
+                text: pinText,
+                action: togglePin
+            }
+        ];
+
+        if (canEditEntry) {
+            items.push({
+                type: "item",
+                icon: "edit",
+                text: I18n.tr("Edit"),
+                action: editEntry
+            });
+        }
+
+        items.push({
+            type: "item",
+            icon: "delete",
+            text: I18n.tr("Delete"),
+            action: deleteEntry
+        }, {
+            type: "separator"
+        }, {
+            type: "item",
+            icon: "content_paste",
+            text: I18n.tr("Paste"),
+            action: pasteEntry
+        });
+
+        return items;
+    }
+
+    readonly property real minMenuWidth: 160
+    readonly property real maxMenuWidth: Math.max(0, (targetScreen?.width ?? 500) - menuMargin * 2)
+    readonly property real maxMenuHeight: Math.max(0, (targetScreen?.height ?? 600) - menuMargin * 2)
+    readonly property string longestMenuText: {
+        let longest = "";
+        for (let i = 0; i < menuItems.length; i++) {
+            const text = menuItems[i].text || "";
+            if (text.length > longest.length)
+                longest = text;
+        }
+        return longest;
+    }
+    readonly property real naturalMenuWidth: Math.max(minMenuWidth, menuTextMetrics.width + Theme.iconSize + Theme.spacingS * 5)
+    readonly property real effectiveMenuWidth: Math.max(0, Math.min(maxMenuWidth, naturalMenuWidth))
+    readonly property real naturalMenuHeight: menuItemsHeight() + Theme.spacingS * 2
+    readonly property real effectiveMenuHeight: Math.min(maxMenuHeight, naturalMenuHeight)
+    readonly property bool menuScrolls: naturalMenuHeight > effectiveMenuHeight + 0.5
+
+    TextMetrics {
+        id: menuTextMetrics
+        text: root.longestMenuText
+        font.pixelSize: Theme.fontSizeSmall
+        font.weight: Font.Normal
+    }
+
+    function menuItemsHeight() {
+        let h = 0;
+        for (let i = 0; i < menuItems.length; i++) {
+            h += menuItems[i].type === "separator" ? 5 : 32;
+        }
+        if (menuItems.length > 1)
+            h += menuItems.length - 1;
+        return h;
+    }
+
+    function show(x, y, targetEntry) {
+        if (!targetEntry)
+            return;
+
+        entry = targetEntry;
+
+        const host = modal?.surfaceHost ?? null;
+        const modalWindow = modal?.Window?.window ?? null;
+        const screenRef = host?.effectiveScreen ?? host?.screen ?? modalWindow?.screen ?? parentHandler?.Window?.window?.screen ?? null;
+        const screenX = screenRef?.x || 0;
+        const screenY = screenRef?.y || 0;
+        const hostX = host?.alignedX;
+        const hostY = host?.renderedAlignedY ?? host?.alignedY;
+        const globalPos = (!isNaN(hostX) && !isNaN(hostY)) ? ({
+            x: screenX + hostX + x,
+            y: screenY + hostY + y
+        }) : (parentHandler ? parentHandler.mapToGlobal(x, y) : ({
+            x: screenX + x,
+            y: screenY + y
+        }));
+
+        targetScreen = screenRef;
+        anchorX = globalPos.x - screenX + 4;
+        anchorY = globalPos.y - screenY + 4;
+        renderActive = true;
+        openState = true;
+
+        Qt.callLater(() => menuFlickable.contentY = 0);
+    }
+
+    function hide() {
+        if (!renderActive)
+            return;
+        openState = false;
+    }
+
+    function showFromWindowPoint(x, y) {
+        if (!parentHandler || typeof parentHandler.contextEntryAtScreen !== "function") {
+            hide();
+            return;
+        }
+
+        const hit = parentHandler.contextEntryAtScreen(x, y);
+
+        if (!hit || !hit.entry) {
+            hide();
+            return;
+        }
+
+        show(hit.x, hit.y, hit.entry);
+    }
+
+    function copyEntry() {
+        if (!entry)
+            return;
+        modal?.copyEntry(entry);
+        hide();
+    }
+
+    function togglePin() {
+        if (!entry)
+            return;
+        if (entry.pinned) {
+            modal?.unpinEntry(entry);
+        } else {
+            const duplicate = ClipboardService.getPinnedEntryByHash(entry.hash);
+            if (duplicate)
+                modal?.unpinEntry(duplicate);
+            else
+                modal?.pinEntry(entry);
+        }
+        hide();
+    }
+
+    function editEntry() {
+        if (!entry || !canEditEntry)
+            return;
+        modal?.editEntry(entry);
+        hide();
+    }
+
+    function deleteEntry() {
+        if (!entry)
+            return;
+        if (entry.pinned)
+            modal?.deletePinnedEntry(entry);
+        else
+            modal?.deleteEntry(entry);
+        hide();
+    }
+
+    function pasteEntry() {
+        if (!entry)
+            return;
+        modal?.pasteEntry(entry);
+        hide();
+    }
+
+    PanelWindow {
+        id: menuWindow
+
+        screen: root.targetScreen
+        visible: root.renderActive
+        color: "transparent"
+
+        WlrLayershell.namespace: "dms:clipboard-context-menu"
+        WlrLayershell.layer: WlrLayershell.Overlay
+        WlrLayershell.exclusiveZone: -1
+        WlrLayershell.keyboardFocus: WlrKeyboardFocus.None
+
+        anchors {
+            top: true
+            left: true
+            right: true
+            bottom: true
+        }
+
+        WindowBlur {
+            targetWindow: menuWindow
+            blurX: root.blurActive ? menuContainer.x : 0
+            blurY: root.blurActive ? menuContainer.y : 0
+            blurWidth: root.blurActive ? menuContainer.width : 0
+            blurHeight: root.blurActive ? menuContainer.height : 0
+            blurRadius: Theme.cornerRadius
+        }
+
+        MouseArea {
+            anchors.fill: parent
+            z: -1
+            enabled: root.renderActive
+            acceptedButtons: Qt.LeftButton | Qt.RightButton
+            onClicked: mouse => {
+                if (mouse.button === Qt.RightButton) {
+                    root.showFromWindowPoint(mouse.x, mouse.y);
+                    return;
+                }
+                root.hide();
+            }
+        }
+
+        Item {
+            anchors.fill: parent
+
+            Rectangle {
+                id: menuContainer
+                x: Math.max(root.menuMargin, Math.min(menuWindow.width - width - root.menuMargin, root.anchorX))
+                y: Math.max(root.menuMargin, Math.min(menuWindow.height - height - root.menuMargin, root.anchorY))
+                width: root.effectiveMenuWidth
+                height: root.effectiveMenuHeight
+                color: Theme.withAlpha(Theme.surfaceContainer, Theme.popupTransparency)
+                radius: Theme.cornerRadius
+                border.color: BlurService.enabled ? BlurService.borderColor : Qt.rgba(Theme.outline.r, Theme.outline.g, Theme.outline.b, 0.08)
+                border.width: BlurService.enabled ? BlurService.borderWidth : 1
+                opacity: root.openState ? 1 : 0
+
+                Behavior on opacity {
+                    NumberAnimation {
+                        duration: Theme.shortDuration
+                        easing.type: Theme.emphasizedEasing
+                        onRunningChanged: {
+                            if (!running && !root.openState) {
+                                root.renderActive = false;
+                            }
+                        }
+                    }
+                }
+
+                Rectangle {
+                    anchors.fill: parent
+                    anchors.topMargin: 4
+                    anchors.leftMargin: 2
+                    anchors.rightMargin: -2
+                    anchors.bottomMargin: -4
+                    radius: parent.radius
+                    color: Qt.rgba(0, 0, 0, 0.15)
+                    z: -1
+                }
+
+                Flickable {
+                    id: menuFlickable
+                    anchors.fill: parent
+                    anchors.margins: Theme.spacingS
+                    clip: true
+                    contentWidth: width
+                    contentHeight: menuColumn.implicitHeight
+                    boundsBehavior: Flickable.StopAtBounds
+                    interactive: root.menuScrolls
+
+                    Column {
+                        id: menuColumn
+                        width: menuFlickable.width
+                        spacing: 1
+
+                        Repeater {
+                            model: root.menuItems
+
+                            Item {
+                                id: menuItemDelegate
+                                required property var modelData
+
+                                width: menuColumn.width
+                                height: modelData.type === "separator" ? 5 : 32
+
+                                Rectangle {
+                                    visible: menuItemDelegate.modelData.type === "separator"
+                                    width: parent.width - Theme.spacingS * 2
+                                    height: parent.height
+                                    anchors.horizontalCenter: parent.horizontalCenter
+                                    color: "transparent"
+
+                                    Rectangle {
+                                        anchors.centerIn: parent
+                                        width: parent.width
+                                        height: 1
+                                        color: Qt.rgba(Theme.outline.r, Theme.outline.g, Theme.outline.b, 0.2)
+                                    }
+                                }
+
+                                Rectangle {
+                                    visible: menuItemDelegate.modelData.type === "item"
+                                    width: parent.width
+                                    height: parent.height
+                                    radius: Theme.cornerRadius
+                                    color: itemMouseArea.containsMouse ? BlurService.hoverColor(Theme.widgetBaseHoverColor) : "transparent"
+
+                                    Row {
+                                        anchors.left: parent.left
+                                        anchors.leftMargin: Theme.spacingS
+                                        anchors.right: parent.right
+                                        anchors.rightMargin: Theme.spacingS
+                                        anchors.verticalCenter: parent.verticalCenter
+                                        spacing: Theme.spacingS
+
+                                        Item {
+                                            width: Theme.iconSize - 2
+                                            height: Theme.iconSize - 2
+                                            anchors.verticalCenter: parent.verticalCenter
+
+                                            DankIcon {
+                                                visible: (menuItemDelegate.modelData?.icon ?? "").length > 0
+                                                name: menuItemDelegate.modelData?.icon ?? ""
+                                                size: Theme.iconSize - 2
+                                                color: Theme.surfaceText
+                                                opacity: 0.7
+                                                anchors.verticalCenter: parent.verticalCenter
+                                            }
+                                        }
+
+                                        StyledText {
+                                            text: menuItemDelegate.modelData.text || ""
+                                            font.pixelSize: Theme.fontSizeSmall
+                                            color: Theme.surfaceText
+                                            font.weight: Font.Normal
+                                            anchors.verticalCenter: parent.verticalCenter
+                                            elide: Text.ElideRight
+                                            width: parent.width - (Theme.iconSize - 2) - Theme.spacingS
+                                        }
+                                    }
+
+                                    DankRipple {
+                                        id: menuItemRipple
+                                        rippleColor: Theme.surfaceText
+                                        cornerRadius: Theme.cornerRadius
+                                    }
+
+                                    MouseArea {
+                                        id: itemMouseArea
+                                        anchors.fill: parent
+                                        hoverEnabled: true
+                                        cursorShape: Qt.PointingHandCursor
+                                        acceptedButtons: Qt.LeftButton | Qt.RightButton
+                                        onPressed: mouse => menuItemRipple.trigger(mouse.x, mouse.y)
+                                        onClicked: mouse => {
+                                            if (mouse.button === Qt.RightButton) {
+                                                root.hide();
+                                                return;
+                                            }
+                                            const menuItem = menuItemDelegate.modelData;
+                                            if (menuItem.action)
+                                                menuItem.action();
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

quickshell/Modals/Clipboard/ClipboardEditor.qml

@@ -15,6 +15,12 @@ Item {
     property var entry: null
     property string editorText: ""
 
+    function releaseTextInputFocus() {
+        if (editField) {
+            editField.focus = false;
+        }
+    }
+
     function decodeEntryData(data) {
         if (!data) {
             return "";

quickshell/Modals/Clipboard/ClipboardEntry.qml

@@ -14,10 +14,12 @@ Rectangle {
     required property var listView
 
     signal copyRequested
+    signal pasteRequested
     signal deleteRequested
     signal pinRequested(var targetEntry)
     signal unpinRequested(var targetEntry)
     signal editRequested
+    signal contextMenuRequested(real mouseX, real mouseY)
 
     readonly property string entryType: modal ? modal.getEntryType(entry) : "text"
     readonly property string entryPreview: modal ? modal.getEntryPreview(entry) : ""
@@ -25,11 +27,13 @@ Rectangle {
     readonly property bool hasPinnedDuplicate: pinnedDuplicateEntry !== null
     readonly property bool effectivePinned: entry.pinned || hasPinnedDuplicate
     readonly property var visibleEntryActions: SettingsData.clipboardVisibleEntryActions || ["pin", "edit", "delete"]
+    readonly property bool showCopyAction: visibleEntryActions.includes("copy")
+    readonly property bool showPasteAction: visibleEntryActions.includes("paste")
     readonly property bool showPinAction: visibleEntryActions.includes("pin")
     readonly property bool showEditAction: visibleEntryActions.includes("edit")
     readonly property bool showDeleteAction: visibleEntryActions.includes("delete")
     readonly property bool showPinnedIndicator: hasPinnedDuplicate && !showPinAction
-    readonly property bool showAnyAction: showPinAction || showEditAction || showDeleteAction || showPinnedIndicator
+    readonly property bool showAnyAction: showCopyAction || showPasteAction || showPinAction || showEditAction || showDeleteAction || showPinnedIndicator
 
     radius: Theme.cornerRadius
     color: {
@@ -86,6 +90,22 @@ Rectangle {
             }
         }
 
+        DankActionButton {
+            iconName: "content_copy"
+            iconSize: Theme.iconSize - 6
+            iconColor: Theme.surfaceText
+            visible: root.showCopyAction
+            onClicked: copyRequested()
+        }
+
+        DankActionButton {
+            iconName: "content_paste"
+            iconSize: Theme.iconSize - 6
+            iconColor: Theme.surfaceText
+            visible: root.showPasteAction
+            onClicked: pasteRequested()
+        }
+
         DankActionButton {
             iconName: "push_pin"
             iconSize: Theme.iconSize - 6
@@ -199,10 +219,28 @@ Rectangle {
         anchors.bottom: parent.bottom
         hoverEnabled: true
         cursorShape: Qt.PointingHandCursor
+        acceptedButtons: Qt.LeftButton
         onPressed: mouse => {
-            const pos = mouseArea.mapToItem(root, mouse.x, mouse.y);
+            if (mouse.button === Qt.LeftButton) {
-            rippleLayer.trigger(pos.x, pos.y);
+                const pos = mouseArea.mapToItem(root, mouse.x, mouse.y);
+                rippleLayer.trigger(pos.x, pos.y);
+            }
+        }
+        onClicked: {
+            if (SettingsData.clipboardClickToPaste) {
+                pasteRequested()
+            } else {
+                copyRequested()
+            }
+        }
+    }
+
+    MouseArea {
+        anchors.fill: parent
+        acceptedButtons: Qt.RightButton
+        onClicked: mouse => {
+            const scenePos = mapToItem(null, mouse.x, mouse.y);
+            contextMenuRequested(scenePos.x, scenePos.y);
         }
-        onClicked: copyRequested()
     }
 }

quickshell/Modals/Clipboard/ClipboardHeader.qml

@@ -38,6 +38,7 @@ Item {
             font.weight: Font.Medium
             anchors.verticalCenter: parent.verticalCenter
         }
+
     }
 
     Row {

quickshell/Modals/Clipboard/ClipboardHistoryContent.qml

@@ -8,6 +8,7 @@ FocusScope {
     id: root
 
     property var clearConfirmDialog: null
+    property var surfaceHost: null
 
     property string activeTab: "recents"
     property bool showKeyboardHints: false
@@ -16,6 +17,7 @@ FocusScope {
 
     property string mode: "history"
     property string searchText: ClipboardService.searchText
+    property string activeFilter: SettingsData.clipboardRememberTypeFilter ? SettingsData.clipboardTypeFilter : "all"
 
     readonly property bool clipboardAvailable: ClipboardService.clipboardAvailable
     readonly property bool wtypeAvailable: ClipboardService.wtypeAvailable
@@ -31,6 +33,11 @@ FocusScope {
     property alias searchField: historyContent.searchField
     property alias editorView: editorView
     property alias keyboardController: keyboardController
+    readonly property alias contextMenuActive: historyContent.contextMenuActive
+
+    function closeContextMenu() {
+        historyContent.closeContextMenu();
+    }
 
     signal closeRequested
     signal instantCloseRequested
@@ -41,7 +48,7 @@ FocusScope {
             return;
         }
         ClipboardService.selectedIndex = 0;
-        ClipboardService.keyboardNavigationActive = false;
+        ClipboardService.keyboardNavigationActive = true;
     }
     onPinnedCountChanged: {
         if (activeTab === "saved" && pinnedCount === 0) {
@@ -50,16 +57,60 @@ FocusScope {
     }
     onSearchTextChanged: ClipboardService.searchText = searchText
 
+    onActiveFilterChanged: {
+        ClipboardService.activeFilter = activeFilter;
+        ClipboardService.selectedIndex = 0;
+        ClipboardService.keyboardNavigationActive = true;
+        ClipboardService.updateFilteredModel();
+        if (SettingsData.clipboardRememberTypeFilter) {
+            SettingsData.set("clipboardTypeFilter", activeFilter);
+        }
+    }
+
+    function releaseTextInputFocus() {
+        // Drop text-input focus before hiding the Wayland surface.
+        if (searchField) {
+            searchField.setFocus(false);
+        }
+        if (editorView) {
+            editorView.releaseTextInputFocus();
+        }
+        root.forceActiveFocus();
+    }
+
+    function requestClose(instant) {
+        releaseTextInputFocus();
+        if (instant) {
+            root.instantCloseRequested();
+        } else {
+            root.closeRequested();
+        }
+    }
+
     function hide() {
-        closeRequested();
+        requestClose(false);
     }
 
     function pasteSelected() {
-        ClipboardService.pasteSelected(() => root.instantCloseRequested());
+        const entry = selectedEntry();
+        if (!entry)
+            return;
+        ClipboardService.pasteEntry(entry, () => root.requestClose(true));
+    }
+
+    function pasteEntry(entry) {
+        ClipboardService.pasteEntry(entry, () => root.requestClose(true));
     }
 
     function copyEntry(entry) {
-        ClipboardService.copyEntry(entry, () => root.closeRequested());
+        ClipboardService.copyEntry(entry, () => root.requestClose(false));
+    }
+
+    function selectedEntry() {
+        const entries = activeTab === "saved" ? pinnedEntries : unpinnedEntries;
+        if (!entries || entries.length === 0 || selectedIndex < 0 || selectedIndex >= entries.length)
+            return null;
+        return entries[selectedIndex];
     }
 
     function deleteEntry(entry) {
@@ -118,6 +169,9 @@ FocusScope {
     function resetState() {
         activeImageLoads = 0;
         mode = "history";
+        historyContent.closeContextMenu();
+        historyContent.closeFilterMenu();
+        activeFilter = SettingsData.clipboardRememberTypeFilter ? SettingsData.clipboardTypeFilter : "all";
         ClipboardService.reset();
         keyboardController.reset();
     }

quickshell/Modals/Clipboard/ClipboardHistoryModal.qml

@@ -45,8 +45,22 @@ DankModal {
         });
     }
 
+    function releaseTextInputFocus() {
+        contentLoader.item?.releaseTextInputFocus();
+    }
+
     function hide() {
-        close();
+        releaseTextInputFocus();
+        Qt.callLater(function () {
+            clipboardHistoryModal.close();
+        });
+    }
+
+    function instantHide() {
+        releaseTextInputFocus();
+        Qt.callLater(function () {
+            clipboardHistoryModal.instantClose();
+        });
     }
 
     onDialogClosed: {
@@ -68,6 +82,11 @@ DankModal {
     enableShadow: true
     closeOnEscapeKey: (contentLoader.item?.mode ?? "history") !== "editor"
     onBackgroundClicked: hide()
+    onShouldBeVisibleChanged: {
+        if (!shouldBeVisible) {
+            releaseTextInputFocus();
+        }
+    }
 
     Ref {
         service: ClipboardService
@@ -110,9 +129,10 @@ DankModal {
 
     content: Component {
         ClipboardHistoryContent {
+            surfaceHost: clipboardHistoryModal
             clearConfirmDialog: clearConfirmDialog
             onCloseRequested: clipboardHistoryModal.hide()
-            onInstantCloseRequested: clipboardHistoryModal.instantClose()
+            onInstantCloseRequested: clipboardHistoryModal.instantHide()
         }
     }
 }

quickshell/Modals/Clipboard/ClipboardHistoryPopout.qml

@@ -37,8 +37,15 @@ DankPopout {
         });
     }
 
+    function releaseTextInputFocus() {
+        contentLoader.item?.releaseTextInputFocus();
+    }
+
     function hide() {
-        close();
+        releaseTextInputFocus();
+        Qt.callLater(function () {
+            root.close();
+        });
     }
 
     function clearAll() {
@@ -57,6 +64,7 @@ DankPopout {
 
     onShouldBeVisibleChanged: {
         if (!shouldBeVisible) {
+            releaseTextInputFocus();
             return;
         }
         if (clipboardAvailable) {
@@ -132,9 +140,10 @@ DankPopout {
             LayoutMirroring.enabled: I18n.isRtl
             LayoutMirroring.childrenInherit: true
 
+            surfaceHost: root
             clearConfirmDialog: clearConfirmDialog
             onCloseRequested: root.hide()
-            onInstantCloseRequested: root.close()
+            onInstantCloseRequested: root.hide()
 
             Component.onCompleted: {
                 activeTab = root.activeTab;

quickshell/Modals/Clipboard/ClipboardKeyboardController.qml

@@ -9,7 +9,7 @@ QtObject {
 
     function reset() {
         ClipboardService.selectedIndex = 0;
-        ClipboardService.keyboardNavigationActive = false;
+        ClipboardService.keyboardNavigationActive = true;
         modal.showKeyboardHints = false;
     }
 
@@ -89,13 +89,16 @@ QtObject {
             return;
         }
 
+        if (modal.contextMenuActive) {
+            if (event.key === Qt.Key_Escape)
+                modal.closeContextMenu();
+            event.accepted = true;
+            return;
+        }
+
         switch (event.key) {
         case Qt.Key_Escape:
-            if (ClipboardService.keyboardNavigationActive) {
+            modal.hide();
-                ClipboardService.keyboardNavigationActive = false;
-            } else {
-                modal.hide();
-            }
             event.accepted = true;
             return;
         case Qt.Key_Down:

quickshell/Modals/DankLauncherV2/Controller.qml

@@ -1883,10 +1883,10 @@ Item {
         }
         if (!selectedItem)
             return;
-        executeItem(selectedItem);
+        executeItem(selectedItem, true);
     }
 
-    function executeItem(item) {
+    function executeItem(item, isKeyboard = false) {
         if (!item)
             return;
 
@@ -1929,7 +1929,8 @@ Item {
             AppSearchService.executeBuiltInLauncherItem(item.data);
             break;
         case "clipboard":
-            if (SettingsData.clipboardEnterToPaste) {
+            var shouldPaste = isKeyboard ? SettingsData.clipboardEnterToPaste : SettingsData.clipboardClickToPaste;
+            if (shouldPaste) {
                 ClipboardService.pasteEntry(item.data, function () {
                     root.itemExecuted();
                 });

quickshell/Modals/DankLauncherV2/LauncherContent.qml

@@ -363,7 +363,7 @@ FocusScope {
                         width: buttonContent.width + Theme.spacingM * 2
                         height: 28
                         radius: Theme.cornerRadius
-                        color: controller.searchMode === modelData.id || modeArea.containsMouse ? Theme.primaryContainer : "transparent"
+                        color: controller.searchMode === modelData.id ? Theme.buttonBg : modeArea.containsMouse ? Theme.surfaceContainerHighest : "transparent"
 
                         Row {
                             id: buttonContent
@@ -374,14 +374,14 @@ FocusScope {
                                 anchors.verticalCenter: parent.verticalCenter
                                 name: modelData.icon
                                 size: 14
-                                color: controller.searchMode === modelData.id ? Theme.primary : Theme.surfaceVariantText
+                                color: controller.searchMode === modelData.id ? Theme.buttonText : Theme.surfaceVariantText
                             }
 
                             StyledText {
                                 anchors.verticalCenter: parent.verticalCenter
                                 text: modelData.label
                                 font.pixelSize: Theme.fontSizeSmall
-                                color: controller.searchMode === modelData.id ? Theme.primary : Theme.surfaceText
+                                color: controller.searchMode === modelData.id ? Theme.buttonText : Theme.surfaceText
                             }
                         }
 
@@ -636,7 +636,7 @@ FocusScope {
                                 width: chipContent.width + Theme.spacingM * 2
                                 height: sortDropdown.height
                                 radius: Theme.cornerRadius
-                                color: controller.fileSearchType === modelData.id || chipArea.containsMouse ? Theme.primaryContainer : "transparent"
+                                color: controller.fileSearchType === modelData.id ? Theme.buttonBg : chipArea.containsMouse ? Theme.surfaceContainerHighest : "transparent"
 
                                 Row {
                                     id: chipContent
@@ -647,14 +647,14 @@ FocusScope {
                                         anchors.verticalCenter: parent.verticalCenter
                                         name: modelData.icon
                                         size: 14
-                                        color: controller.fileSearchType === modelData.id ? Theme.primary : Theme.surfaceVariantText
+                                        color: controller.fileSearchType === modelData.id ? Theme.buttonText : Theme.surfaceVariantText
                                     }
 
                                     StyledText {
                                         anchors.verticalCenter: parent.verticalCenter
                                         text: modelData.label
                                         font.pixelSize: Theme.fontSizeSmall
-                                        color: controller.fileSearchType === modelData.id ? Theme.primary : Theme.surfaceText
+                                        color: controller.fileSearchType === modelData.id ? Theme.buttonText : Theme.surfaceVariantText
                                     }
                                 }
 

quickshell/Modals/DankLauncherV2/SourceBadge.qml

@@ -1,5 +1,6 @@
 import QtQuick
 import Quickshell.Widgets
+import qs.Common
 
 Item {
     id: root
@@ -16,7 +17,7 @@ Item {
 
     readonly property string assetPath: sourceAsset[source] || ""
 
-    visible: assetPath.length > 0
+    visible: SettingsData.dankLauncherV2ShowSourceBadges && assetPath.length > 0
     implicitWidth: glyphSize
     implicitHeight: glyphSize
 

quickshell/Modals/KeybindsContent.qml

@@ -0,0 +1,336 @@
+import QtQml
+import QtQuick
+import QtQuick.Layouts
+import qs.Common
+import qs.Services
+import qs.Widgets
+
+FocusScope {
+    id: content
+
+    property real scrollStep: 60
+    property var activeFlickable: mainFlickable
+    property bool showFloatingToggle: true
+    property bool floating: false
+    property alias searchField: searchField
+
+    signal closeRequested
+    signal floatingToggleRequested
+
+    function scrollDown() {
+        if (!activeFlickable)
+            return;
+        let newY = activeFlickable.contentY + scrollStep;
+        newY = Math.min(newY, activeFlickable.contentHeight - activeFlickable.height);
+        activeFlickable.contentY = newY;
+    }
+
+    function scrollUp() {
+        if (!activeFlickable)
+            return;
+        let newY = activeFlickable.contentY - scrollStep;
+        newY = Math.max(0, newY);
+        activeFlickable.contentY = newY;
+    }
+
+    Keys.onPressed: event => {
+        switch (event.key) {
+        case Qt.Key_J:
+            if (event.modifiers & Qt.ControlModifier) {
+                scrollDown();
+                event.accepted = true;
+            }
+            return;
+        case Qt.Key_K:
+            if (event.modifiers & Qt.ControlModifier) {
+                scrollUp();
+                event.accepted = true;
+            }
+            return;
+        case Qt.Key_Down:
+            scrollDown();
+            event.accepted = true;
+            return;
+        case Qt.Key_Up:
+            scrollUp();
+            event.accepted = true;
+            return;
+        }
+    }
+
+    Column {
+        anchors.fill: parent
+        anchors.margins: Theme.spacingL
+        spacing: Theme.spacingL
+
+        RowLayout {
+            width: parent.width
+            spacing: Theme.spacingM
+
+            StyledText {
+                Layout.alignment: Qt.AlignLeft
+                text: KeybindsService.cheatsheet.title || I18n.tr("Keybinds")
+                font.pixelSize: Theme.fontSizeLarge
+                font.weight: Font.Bold
+                color: Theme.primary
+            }
+
+            Item {
+                Layout.fillWidth: true
+            }
+
+            DankActionButton {
+                visible: content.showFloatingToggle
+                iconName: content.floating ? "close_fullscreen" : "open_in_new"
+                tooltipText: content.floating ? I18n.tr("Dock window") : I18n.tr("Open as window")
+                onClicked: content.floatingToggleRequested()
+            }
+
+            DankTextField {
+                id: searchField
+                Layout.alignment: Qt.AlignRight
+                leftIconName: "search"
+                keyForwardTargets: [content]
+                onTextEdited: searchDebounce.restart()
+                Keys.onEscapePressed: event => {
+                    content.closeRequested();
+                    event.accepted = true;
+                }
+            }
+        }
+
+        Timer {
+            id: searchDebounce
+            interval: 50
+            repeat: false
+            onTriggered: {
+                mainFlickable.categories = mainFlickable.generateCategories(searchField.text);
+            }
+        }
+
+        DankFlickable {
+            id: mainFlickable
+            width: parent.width
+            height: parent.height - parent.spacing - 40
+            contentWidth: rowLayout.implicitWidth
+            contentHeight: rowLayout.implicitHeight
+            clip: true
+
+            property var rawBinds: KeybindsService.cheatsheet.binds || {}
+
+            function generateCategories(query) {
+                const lowerQuery = query ? query.toLowerCase().trim() : "";
+                const lowerQueryWords = query.split(/\s+/);
+                const processed = {};
+
+                for (const cat in rawBinds) {
+                    const binds = rawBinds[cat];
+                    const catLower = cat.toLowerCase();
+                    const subcats = {};
+                    let hasSubcats = false;
+                    for (let i = 0; i < binds.length; i++) {
+                        const bind = binds[i];
+                        const keyLower = (bind.key || "").toLowerCase();
+                        const descLower = (bind.desc || "").toLowerCase();
+                        const actionLower = (bind.action || "").toLowerCase();
+
+                        if (bind.hideOnOverlay)
+                            continue;
+                        let shouldContinue = false;
+                        for (let j = 0; j < lowerQueryWords.length; j++) {
+                            const word = lowerQueryWords[j];
+                            if (!(word.length === 0 || keyLower.includes(word) || descLower.includes(word) || catLower.includes(word) || actionLower.includes(word))) {
+                                shouldContinue = true;
+                                break;
+                            }
+                        }
+                        if (shouldContinue)
+                            continue;
+
+                        if (bind.subcat) {
+                            hasSubcats = true;
+                            if (!subcats[bind.subcat])
+                                subcats[bind.subcat] = [];
+                            subcats[bind.subcat].push(bind);
+                        } else {
+                            if (!subcats["_root"])
+                                subcats["_root"] = [];
+                            subcats["_root"].push(bind);
+                        }
+                    }
+
+                    if (Object.keys(subcats).length === 0)
+                        continue;
+
+                    processed[cat] = {
+                        hasSubcats: hasSubcats,
+                        subcats: subcats,
+                        subcatKeys: Object.keys(subcats)
+                    };
+                }
+
+                return processed;
+            }
+
+            property var categories: generateCategories("")
+
+            function estimateCategoryHeight(catName) {
+                const catData = categories[catName];
+                if (!catData)
+                    return 0;
+                let bindCount = 0;
+                for (const key of catData.subcatKeys) {
+                    bindCount += catData.subcats[key]?.length || 0;
+                    if (key !== "_root")
+                        bindCount += 1;
+                }
+                return 40 + bindCount * 28;
+            }
+
+            property var categoryKeys: Object.keys(categories)
+
+            function distributeCategories(cols) {
+                const columns = [];
+                const heights = [];
+                for (let i = 0; i < cols; i++) {
+                    columns.push([]);
+                    heights.push(0);
+                }
+                const sorted = [...categoryKeys].sort((a, b) => estimateCategoryHeight(b) - estimateCategoryHeight(a));
+                for (const cat of sorted) {
+                    let minIdx = 0;
+                    for (let i = 1; i < cols; i++) {
+                        if (heights[i] < heights[minIdx])
+                            minIdx = i;
+                    }
+                    columns[minIdx].push(cat);
+                    heights[minIdx] += estimateCategoryHeight(cat);
+                }
+                return columns;
+            }
+
+            Row {
+                id: rowLayout
+                width: mainFlickable.width
+                spacing: Theme.spacingM
+
+                property int numColumns: Math.max(1, Math.min(3, Math.floor(width / 350)))
+                property var columnCategories: mainFlickable.distributeCategories(numColumns)
+
+                Repeater {
+                    model: rowLayout.numColumns
+
+                    Column {
+                        id: masonryColumn
+                        width: (rowLayout.width - rowLayout.spacing * (rowLayout.numColumns - 1)) / rowLayout.numColumns
+                        spacing: Theme.spacingXL
+
+                        Repeater {
+                            model: rowLayout.columnCategories[index] || []
+
+                            Column {
+                                id: categoryColumn
+                                width: parent.width
+                                spacing: Theme.spacingXS
+
+                                property string catName: modelData
+                                property var catData: mainFlickable.categories[catName]
+
+                                StyledText {
+                                    text: categoryColumn.catName
+                                    font.pixelSize: Theme.fontSizeMedium
+                                    font.weight: Font.Bold
+                                    color: Theme.primary
+                                }
+
+                                Rectangle {
+                                    width: parent.width
+                                    height: 1
+                                    color: Theme.primary
+                                    opacity: 0.3
+                                }
+
+                                Item {
+                                    width: 1
+                                    height: Theme.spacingXS
+                                }
+
+                                Column {
+                                    width: parent.width
+                                    spacing: Theme.spacingM
+
+                                    Repeater {
+                                        model: categoryColumn.catData?.subcatKeys || []
+
+                                        Column {
+                                            width: parent.width
+                                            spacing: Theme.spacingXS
+
+                                            property string subcatName: modelData
+                                            property var subcatBinds: categoryColumn.catData?.subcats?.[subcatName] || []
+
+                                            StyledText {
+                                                visible: parent.subcatName !== "_root"
+                                                text: parent.subcatName
+                                                font.pixelSize: Theme.fontSizeSmall
+                                                font.weight: Font.DemiBold
+                                                color: Theme.primary
+                                                opacity: 0.7
+                                            }
+
+                                            Column {
+                                                width: parent.width
+                                                spacing: Theme.spacingXS
+
+                                                Repeater {
+                                                    model: parent.parent.subcatBinds
+
+                                                    Item {
+                                                        width: parent.width
+                                                        height: 24
+
+                                                        StyledRect {
+                                                            id: keyBadge
+                                                            width: Math.min(keyText.implicitWidth + 12, 160)
+                                                            height: 22
+                                                            radius: 4
+                                                            anchors.verticalCenter: parent.verticalCenter
+
+                                                            StyledText {
+                                                                id: keyText
+                                                                anchors.centerIn: parent
+                                                                color: Theme.secondary
+                                                                text: (modelData.key || "").replace(/\+/g, " + ")
+                                                                font.pixelSize: Theme.fontSizeSmall
+                                                                font.weight: Font.Medium
+                                                                isMonospace: true
+                                                                elide: Text.ElideRight
+                                                                width: Math.min(implicitWidth, 148)
+                                                            }
+                                                        }
+
+                                                        StyledText {
+                                                            anchors.left: parent.left
+                                                            anchors.leftMargin: 170
+                                                            anchors.right: parent.right
+                                                            anchors.verticalCenter: parent.verticalCenter
+                                                            text: modelData.desc || modelData.action || ""
+                                                            font.pixelSize: Theme.fontSizeSmall
+                                                            opacity: 0.9
+                                                            elide: Text.ElideRight
+                                                            wrapMode: Text.NoWrap
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

quickshell/Modals/KeybindsModal.qml

@@ -1,334 +1,78 @@
-import QtQml
 import QtQuick
-import QtQuick.Layouts
 import qs.Common
-import qs.Modals.Common
+import qs.Modals
 import qs.Services
-import qs.Widgets
 
-DankModal {
+Item {
     id: root
 
-    layerNamespace: "dms:keybinds"
+    readonly property bool floating: SettingsData.keybindsFloatingWindow
-    useOverlayLayer: true
+    readonly property bool shouldBeVisible: floating ? (windowLoader.item ? windowLoader.item.visible : false) : (overlayLoader.item ? overlayLoader.item.shouldBeVisible : false)
-    property real scrollStep: 60
-    property var activeFlickable: null
-    property real _maxW: Math.min(root.screenWidth * 0.92, 1200)
-    property real _maxH: Math.min(root.screenHeight * 0.92, 900)
-    modalWidth: _maxW
-    modalHeight: _maxH
-    onBackgroundClicked: close()
-    onOpened: {
-        Qt.callLater(() => {
-            modalFocusScope.forceActiveFocus();
-            if (contentLoader.item?.searchField)
-                contentLoader.item.searchField.forceActiveFocus();
-        });
-        if (!Object.keys(KeybindsService.cheatsheet).length && KeybindsService.cheatsheetAvailable)
-            KeybindsService.loadCheatsheet();
-    }
 
-    function scrollDown() {
+    function open() {
-        if (!root.activeFlickable)
+        if (floating) {
+            windowLoader.active = true;
+            windowLoader.item.show();
             return;
-        let newY = root.activeFlickable.contentY + scrollStep;
+        }
-        newY = Math.min(newY, root.activeFlickable.contentHeight - root.activeFlickable.height);
+        overlayLoader.active = true;
-        root.activeFlickable.contentY = newY;
+        overlayLoader.item.open();
     }
 
-    function scrollUp() {
+    function close() {
-        if (!root.activeFlickable)
+        if (windowLoader.item)
+            windowLoader.item.hide();
+        if (overlayLoader.item)
+            overlayLoader.item.close();
+    }
+
+    function toggle() {
+        if (shouldBeVisible)
+            close();
+        else
+            open();
+    }
+
+    function _switchFloating(toFloating) {
+        if (toFloating) {
+            if (overlayLoader.item)
+                overlayLoader.item.close();
+            SettingsData.keybindsFloatingWindow = true;
+            windowLoader.active = true;
+            windowLoader.item.show();
             return;
-        let newY = root.activeFlickable.contentY - root.scrollStep;
+        }
-        newY = Math.max(0, newY);
+        if (windowLoader.item)
-        root.activeFlickable.contentY = newY;
+            windowLoader.item.hide();
+        SettingsData.keybindsFloatingWindow = false;
+        overlayLoader.active = true;
+        overlayLoader.item.open();
     }
 
-    modalFocusScope.Keys.onPressed: event => {
+    Loader {
-        if (event.key === Qt.Key_J && event.modifiers & Qt.ControlModifier) {
+        id: overlayLoader
-            scrollDown();
+        active: false
-            event.accepted = true;
+        asynchronous: false
-        } else if (event.key === Qt.Key_K && event.modifiers & Qt.ControlModifier) {
+
-            scrollUp();
+        sourceComponent: KeybindsModalOverlay {
-            event.accepted = true;
+            onFloatingToggleRequested: root._switchFloating(true)
-        } else if (event.key === Qt.Key_Down) {
+            onDialogClosed: Qt.callLater(() => {
-            scrollDown();
+                if (!shouldBeVisible)
-            event.accepted = true;
+                    overlayLoader.active = false;
-        } else if (event.key === Qt.Key_Up) {
+            })
-            scrollUp();
-            event.accepted = true;
         }
     }
 
-    content: Component {
+    Loader {
-        Item {
+        id: windowLoader
-            anchors.fill: parent
+        active: false
-            property alias searchField: searchField
+        asynchronous: false
 
-            Column {
+        sourceComponent: KeybindsModalWindow {
-                anchors.fill: parent
+            onFloatingToggleRequested: root._switchFloating(false)
-                anchors.margins: Theme.spacingL
+            onVisibleChanged: {
-                spacing: Theme.spacingL
+                if (!visible)
-
+                    Qt.callLater(() => windowLoader.active = false);
-                RowLayout {
-                    width: parent.width
-
-                    StyledText {
-                        Layout.alignment: Qt.AlignLeft
-                        text: KeybindsService.cheatsheet.title || I18n.tr("Keybinds")
-                        font.pixelSize: Theme.fontSizeLarge
-                        font.weight: Font.Bold
-                        color: Theme.primary
-                    }
-
-                    DankTextField {
-                        id: searchField
-                        Layout.alignment: Qt.AlignRight
-                        leftIconName: "search"
-                        keyForwardTargets: [root.modalFocusScope]
-                        onTextEdited: searchDebounce.restart()
-                        Keys.onEscapePressed: event => {
-                            root.close();
-                            event.accepted = true;
-                        }
-                    }
-                }
-
-                Timer {
-                    id: searchDebounce
-                    interval: 50
-                    repeat: false
-                    onTriggered: {
-                        mainFlickable.categories = mainFlickable.generateCategories(searchField.text);
-                    }
-                }
-
-                DankFlickable {
-                    id: mainFlickable
-                    width: parent.width
-                    height: parent.height - parent.spacing - 40
-                    contentWidth: rowLayout.implicitWidth
-                    contentHeight: rowLayout.implicitHeight
-                    clip: true
-
-                    Component.onCompleted: root.activeFlickable = mainFlickable
-
-                    property var rawBinds: KeybindsService.cheatsheet.binds || {}
-
-                    function generateCategories(query) {
-                        const lowerQuery = query ? query.toLowerCase().trim() : "";
-                        const lowerQueryWords = query.split(/\s+/);
-                        const processed = {};
-
-                        for (const cat in rawBinds) {
-                            const binds = rawBinds[cat];
-                            const catLower = cat.toLowerCase();
-                            const subcats = {};
-                            let hasSubcats = false;
-                            for (let i = 0; i < binds.length; i++) {
-                                const bind = binds[i];
-                                const keyLower = (bind.key || "").toLowerCase();
-                                const descLower = (bind.desc || "").toLowerCase();
-                                const actionLower = (bind.action || "").toLowerCase();
-
-                                if (bind.hideOnOverlay)
-                                    continue;
-                                let shouldContinue = false;
-                                for (let j = 0; j < lowerQueryWords.length; j++) {
-                                    const word = lowerQueryWords[j];
-                                    if (!(word.length === 0 || keyLower.includes(word) || descLower.includes(word) || catLower.includes(word) || actionLower.includes(word))) {
-                                        shouldContinue = true;
-                                        break;
-                                    }
-                                }
-                                if (shouldContinue)
-                                    continue;
-
-                                if (bind.subcat) {
-                                    hasSubcats = true;
-                                    if (!subcats[bind.subcat])
-                                        subcats[bind.subcat] = [];
-                                    subcats[bind.subcat].push(bind);
-                                } else {
-                                    if (!subcats["_root"])
-                                        subcats["_root"] = [];
-                                    subcats["_root"].push(bind);
-                                }
-                            }
-
-                            if (Object.keys(subcats).length === 0)
-                                continue;
-
-                            processed[cat] = {
-                                hasSubcats: hasSubcats,
-                                subcats: subcats,
-                                subcatKeys: Object.keys(subcats)
-                            };
-                        }
-
-                        return processed;
-                    }
-
-                    property var categories: generateCategories("")
-
-                    function estimateCategoryHeight(catName) {
-                        const catData = categories[catName];
-                        if (!catData)
-                            return 0;
-                        let bindCount = 0;
-                        for (const key of catData.subcatKeys) {
-                            bindCount += catData.subcats[key]?.length || 0;
-                            if (key !== "_root")
-                                bindCount += 1;
-                        }
-                        return 40 + bindCount * 28;
-                    }
-
-                    property var categoryKeys: Object.keys(categories)
-
-                    function distributeCategories(cols) {
-                        const columns = [];
-                        const heights = [];
-                        for (let i = 0; i < cols; i++) {
-                            columns.push([]);
-                            heights.push(0);
-                        }
-                        const sorted = [...categoryKeys].sort((a, b) => estimateCategoryHeight(b) - estimateCategoryHeight(a));
-                        for (const cat of sorted) {
-                            let minIdx = 0;
-                            for (let i = 1; i < cols; i++) {
-                                if (heights[i] < heights[minIdx])
-                                    minIdx = i;
-                            }
-                            columns[minIdx].push(cat);
-                            heights[minIdx] += estimateCategoryHeight(cat);
-                        }
-                        return columns;
-                    }
-
-                    Row {
-                        id: rowLayout
-                        width: mainFlickable.width
-                        spacing: Theme.spacingM
-
-                        property int numColumns: Math.max(1, Math.min(3, Math.floor(width / 350)))
-                        property var columnCategories: mainFlickable.distributeCategories(numColumns)
-
-                        Repeater {
-                            model: rowLayout.numColumns
-
-                            Column {
-                                id: masonryColumn
-                                width: (rowLayout.width - rowLayout.spacing * (rowLayout.numColumns - 1)) / rowLayout.numColumns
-                                spacing: Theme.spacingXL
-
-                                Repeater {
-                                    model: rowLayout.columnCategories[index] || []
-
-                                    Column {
-                                        id: categoryColumn
-                                        width: parent.width
-                                        spacing: Theme.spacingXS
-
-                                        property string catName: modelData
-                                        property var catData: mainFlickable.categories[catName]
-
-                                        StyledText {
-                                            text: categoryColumn.catName
-                                            font.pixelSize: Theme.fontSizeMedium
-                                            font.weight: Font.Bold
-                                            color: Theme.primary
-                                        }
-
-                                        Rectangle {
-                                            width: parent.width
-                                            height: 1
-                                            color: Theme.primary
-                                            opacity: 0.3
-                                        }
-
-                                        Item {
-                                            width: 1
-                                            height: Theme.spacingXS
-                                        }
-
-                                        Column {
-                                            width: parent.width
-                                            spacing: Theme.spacingM
-
-                                            Repeater {
-                                                model: categoryColumn.catData?.subcatKeys || []
-
-                                                Column {
-                                                    width: parent.width
-                                                    spacing: Theme.spacingXS
-
-                                                    property string subcatName: modelData
-                                                    property var subcatBinds: categoryColumn.catData?.subcats?.[subcatName] || []
-
-                                                    StyledText {
-                                                        visible: parent.subcatName !== "_root"
-                                                        text: parent.subcatName
-                                                        font.pixelSize: Theme.fontSizeSmall
-                                                        font.weight: Font.DemiBold
-                                                        color: Theme.primary
-                                                        opacity: 0.7
-                                                    }
-
-                                                    Column {
-                                                        width: parent.width
-                                                        spacing: Theme.spacingXS
-
-                                                        Repeater {
-                                                            model: parent.parent.subcatBinds
-
-                                                            Item {
-                                                                width: parent.width
-                                                                height: 24
-
-                                                                StyledRect {
-                                                                    id: keyBadge
-                                                                    width: Math.min(keyText.implicitWidth + 12, 160)
-                                                                    height: 22
-                                                                    radius: 4
-                                                                    anchors.verticalCenter: parent.verticalCenter
-
-                                                                    StyledText {
-                                                                        id: keyText
-                                                                        anchors.centerIn: parent
-                                                                        color: Theme.secondary
-                                                                        text: (modelData.key || "").replace(/\+/g, " + ")
-                                                                        font.pixelSize: Theme.fontSizeSmall
-                                                                        font.weight: Font.Medium
-                                                                        isMonospace: true
-                                                                        elide: Text.ElideRight
-                                                                        width: Math.min(implicitWidth, 148)
-                                                                    }
-                                                                }
-
-                                                                StyledText {
-                                                                    anchors.left: parent.left
-                                                                    anchors.leftMargin: 170
-                                                                    anchors.right: parent.right
-                                                                    anchors.verticalCenter: parent.verticalCenter
-                                                                    text: modelData.desc || modelData.action || ""
-                                                                    font.pixelSize: Theme.fontSizeSmall
-                                                                    opacity: 0.9
-                                                                    elide: Text.ElideRight
-                                                                    wrapMode: Text.NoWrap
-                                                                }
-                                                            }
-                                                        }
-                                                    }
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
             }
         }
     }

quickshell/Modals/KeybindsModalOverlay.qml

@@ -0,0 +1,38 @@
+import QtQml
+import QtQuick
+import qs.Common
+import qs.Modals
+import qs.Modals.Common
+import qs.Services
+
+DankModal {
+    id: overlay
+
+    signal floatingToggleRequested
+
+    layerNamespace: "dms:keybinds"
+    useOverlayLayer: true
+    property real _maxW: Math.min(overlay.screenWidth * 0.92, 1200)
+    property real _maxH: Math.min(overlay.screenHeight * 0.92, 900)
+    modalWidth: _maxW
+    modalHeight: _maxH
+    onBackgroundClicked: close()
+    onOpened: {
+        Qt.callLater(() => {
+            modalFocusScope.forceActiveFocus();
+            if (contentLoader.item?.searchField)
+                contentLoader.item.searchField.forceActiveFocus();
+        });
+        if (!Object.keys(KeybindsService.cheatsheet).length && KeybindsService.cheatsheetAvailable)
+            KeybindsService.loadCheatsheet();
+    }
+
+    content: Component {
+        KeybindsContent {
+            showFloatingToggle: true
+            floating: false
+            onCloseRequested: overlay.close()
+            onFloatingToggleRequested: overlay.floatingToggleRequested()
+        }
+    }
+}

quickshell/Modals/KeybindsModalWindow.qml

@@ -0,0 +1,140 @@
+import QtQuick
+import Quickshell
+import qs.Common
+import qs.Modals
+import qs.Services
+import qs.Widgets
+
+FloatingWindow {
+    id: win
+
+    property bool disablePopupTransparency: true
+    property alias shouldBeVisible: win.visible
+
+    signal floatingToggleRequested
+
+    function show() {
+        visible = true;
+    }
+
+    function hide() {
+        visible = false;
+    }
+
+    function toggle() {
+        visible = !visible;
+    }
+
+    objectName: "keybindsModalWindow"
+    title: I18n.tr("Keybinds")
+    minimumSize: Qt.size(Math.min(560, Screen.width), Math.min(400, Screen.height))
+    implicitWidth: 1000
+    implicitHeight: screen ? Math.min(820, screen.height - 100) : 820
+    color: Theme.surfaceContainer
+    visible: false
+
+    onVisibleChanged: {
+        if (!visible)
+            return;
+        if (!Object.keys(KeybindsService.cheatsheet).length && KeybindsService.cheatsheetAvailable)
+            KeybindsService.loadCheatsheet();
+        Qt.callLater(() => {
+            keybindsContent.forceActiveFocus();
+            keybindsContent.searchField.forceActiveFocus();
+        });
+    }
+
+    onClosed: win.visible = false
+
+    Column {
+        anchors.fill: parent
+        spacing: 0
+
+        Item {
+            width: parent.width
+            height: 48
+            z: 10
+
+            MouseArea {
+                anchors.fill: parent
+                onPressed: windowControls.tryStartMove()
+                onDoubleClicked: windowControls.tryToggleMaximize()
+            }
+
+            Rectangle {
+                anchors.fill: parent
+                color: Theme.surfaceContainer
+                opacity: 0.5
+            }
+
+            Row {
+                anchors.left: parent.left
+                anchors.leftMargin: Theme.spacingL
+                anchors.verticalCenter: parent.verticalCenter
+                spacing: Theme.spacingM
+
+                DankIcon {
+                    name: "keyboard"
+                    size: Theme.iconSize
+                    color: Theme.primary
+                    anchors.verticalCenter: parent.verticalCenter
+                }
+
+                StyledText {
+                    text: KeybindsService.cheatsheet.title || I18n.tr("Keybinds")
+                    font.pixelSize: Theme.fontSizeXLarge
+                    color: Theme.surfaceText
+                    font.weight: Font.Medium
+                    anchors.verticalCenter: parent.verticalCenter
+                }
+            }
+
+            Row {
+                anchors.right: parent.right
+                anchors.rightMargin: Theme.spacingM
+                anchors.verticalCenter: parent.verticalCenter
+                spacing: Theme.spacingXS
+
+                DankActionButton {
+                    circular: false
+                    iconName: "close_fullscreen"
+                    iconSize: Theme.iconSize - 4
+                    iconColor: Theme.surfaceText
+                    tooltipText: I18n.tr("Dock window")
+                    onClicked: win.floatingToggleRequested()
+                }
+
+                DankActionButton {
+                    visible: windowControls.canMaximize
+                    circular: false
+                    iconName: win.maximized ? "fullscreen_exit" : "fullscreen"
+                    iconSize: Theme.iconSize - 4
+                    iconColor: Theme.surfaceText
+                    onClicked: windowControls.tryToggleMaximize()
+                }
+
+                DankActionButton {
+                    circular: false
+                    iconName: "close"
+                    iconSize: Theme.iconSize - 4
+                    iconColor: Theme.surfaceText
+                    onClicked: win.hide()
+                }
+            }
+        }
+
+        KeybindsContent {
+            id: keybindsContent
+            width: parent.width
+            height: parent.height - 48
+            showFloatingToggle: false
+            floating: true
+            onCloseRequested: win.hide()
+        }
+    }
+
+    FloatingWindowControls {
+        id: windowControls
+        targetWindow: win
+    }
+}

quickshell/Modals/PowerMenuModal.qml

@@ -11,6 +11,7 @@ DankModal {
 
     layerNamespace: "dms:power-menu"
     keepPopoutsOpen: true
+    useOverlayLayer: true
 
     property int selectedIndex: 0
     property int selectedRow: 0

quickshell/Modals/Settings/SettingsContent.qml

@@ -686,5 +686,20 @@ FocusScope {
                     Qt.callLater(() => item.forceActiveFocus());
             }
         }
+
+        Loader {
+            id: batteryLoader
+            anchors.fill: parent
+            active: root.currentIndex === 42
+            visible: active
+            focus: active
+
+            sourceComponent: BatteryTab {}
+
+            onActiveChanged: {
+                if (active && item)
+                    Qt.callLater(() => item.forceActiveFocus());
+            }
+        }
     }
 }

quickshell/Modals/Settings/SettingsSidebar.qml

@@ -377,6 +377,12 @@ Rectangle {
                     "text": I18n.tr("Power & Sleep"),
                     "icon": "power_settings_new",
                     "tabIndex": 21
+                },
+                {
+                    "id": "battery",
+                    "text": I18n.tr("Battery"),
+                    "icon": "battery_charging_full",
+                    "tabIndex": 42
                 }
             ]
         },

quickshell/Modals/WifiPasswordModal.qml

@@ -1,12 +1,22 @@
 import QtQuick
-import Quickshell
 import qs.Common
+import qs.Modals.Common
 import qs.Services
 import qs.Widgets
 
-FloatingWindow {
+DankModal {
     id: root
 
+    layerNamespace: "dms:wifi-password"
+    keepPopoutsOpen: true
+    allowStacking: true
+    shouldBeVisible: false
+    modalWidth: 420
+    modalHeight: calculatedHeight
+    enableShadow: true
+    onBackgroundClicked: clearAndClose()
+    directContent: contentFocusScope
+
     property bool disablePopupTransparency: true
     property string wifiPasswordSSID: ""
     property string wifiPasswordInput: ""
@@ -102,7 +112,7 @@ FloatingWindow {
         const network = NetworkService.wifiNetworks.find(n => n.ssid === ssid);
         requiresEnterprise = network?.enterprise || false;
 
-        visible = true;
+        open();
         Qt.callLater(focusFirstField);
     }
 
@@ -126,7 +136,7 @@ FloatingWindow {
         secretValues = {};
         requiresEnterprise = false;
 
-        visible = true;
+        open();
         Qt.callLater(focusFirstField);
     }
 
@@ -144,6 +154,7 @@ FloatingWindow {
 
         isVpnPrompt = (connectionType === "vpn" || connectionType === "wireguard");
         wifiPasswordSSID = isVpnPrompt ? connectionName : ssid;
+        savePasswordCheckbox.checked = !isVpnPrompt;
 
         requiresEnterprise = setting === "802-1x";
 
@@ -152,7 +163,7 @@ FloatingWindow {
         wifiAnonymousIdentityInput = "";
         wifiDomainInput = "";
 
-        visible = true;
+        open();
         Qt.callLater(() => {
             if (reason === "wrong-password" && fieldsInfo.length === 0) {
                 passwordInput.text = "";
@@ -162,7 +173,7 @@ FloatingWindow {
     }
 
     function hide() {
-        visible = false;
+        close();
     }
 
     function getFieldLabel(fieldName) {
@@ -242,23 +253,8 @@ FloatingWindow {
         secretValues = {};
     }
 
-    objectName: "wifiPasswordModal"
+    onShouldBeVisibleChanged: {
-    title: {
+        if (shouldBeVisible) {
-        if (promptReason === "pkcs11")
-            return I18n.tr("Smartcard PIN");
-        if (isVpnPrompt)
-            return I18n.tr("VPN Password");
-        if (isHiddenNetwork)
-            return I18n.tr("Hidden Network");
-        return I18n.tr("Wi-Fi Password");
-    }
-    minimumSize: Qt.size(420, calculatedHeight)
-    maximumSize: Qt.size(420, calculatedHeight)
-    color: Theme.surfaceContainer
-    visible: false
-
-    onVisibleChanged: {
-        if (visible) {
             Qt.callLater(focusFirstField);
             return;
         }
@@ -287,7 +283,7 @@ FloatingWindow {
                 return;
             wifiPasswordSSID = NetworkService.connectingSSID;
             wifiPasswordInput = "";
-            visible = true;
+            open();
             NetworkService.passwordDialogShouldReopen = false;
         }
     }
@@ -296,7 +292,7 @@ FloatingWindow {
         id: contentFocusScope
 
         anchors.fill: parent
-        focus: true
+        focus: root.shouldBeVisible
 
         Keys.onEscapePressed: event => {
             clearAndClose();
@@ -318,8 +314,6 @@ FloatingWindow {
                     anchors.right: buttonRow.left
                     anchors.rightMargin: Theme.spacingM
                     height: headerCol.height
-                    onPressed: windowControls.tryStartMove()
-                    onDoubleClicked: windowControls.tryToggleMaximize()
 
                     Column {
                         id: headerCol
@@ -380,14 +374,6 @@ FloatingWindow {
                     anchors.right: parent.right
                     spacing: Theme.spacingXS
 
-                    DankActionButton {
-                        visible: windowControls.canMaximize
-                        iconName: root.maximized ? "fullscreen_exit" : "fullscreen"
-                        iconSize: Theme.iconSize - 4
-                        iconColor: Theme.surfaceText
-                        onClicked: windowControls.tryToggleMaximize()
-                    }
-
                     DankActionButton {
                         iconName: "close"
                         iconSize: Theme.iconSize - 4
@@ -419,7 +405,7 @@ FloatingWindow {
                     textColor: Theme.surfaceText
                     placeholderText: I18n.tr("Network Name (SSID)")
                     backgroundColor: "transparent"
-                    enabled: root.visible
+                    enabled: root.shouldBeVisible
                     keyNavigationTab: passwordInput
                     onAccepted: passwordInput.forceActiveFocus()
                 }
@@ -449,7 +435,7 @@ FloatingWindow {
                         echoMode: modelData.isSecret && !passwordVisible ? TextInput.Password : TextInput.Normal
                         placeholderText: getFieldLabel(modelData.name)
                         backgroundColor: "transparent"
-                        enabled: root.visible
+                        enabled: root.shouldBeVisible
 
                         Keys.onTabPressed: event => {
                             if (index < fieldsInfo.length - 1) {
@@ -519,7 +505,7 @@ FloatingWindow {
                     text: wifiUsernameInput
                     placeholderText: I18n.tr("Username")
                     backgroundColor: "transparent"
-                    enabled: root.visible
+                    enabled: root.shouldBeVisible
                     keyNavigationTab: passwordInput
                     keyNavigationBacktab: domainMatchInput
                     onTextEdited: wifiUsernameInput = text
@@ -552,7 +538,7 @@ FloatingWindow {
                     echoMode: passwordVisible ? TextInput.Normal : TextInput.Password
                     placeholderText: (requiresEnterprise && !isVpnPrompt) ? I18n.tr("Password") : ""
                     backgroundColor: "transparent"
-                    enabled: root.visible
+                    enabled: root.shouldBeVisible
                     keyNavigationTab: (requiresEnterprise && !isVpnPrompt) ? anonInput : null
                     keyNavigationBacktab: (requiresEnterprise && !isVpnPrompt) ? usernameInput : null
                     onTextEdited: wifiPasswordInput = text
@@ -589,7 +575,7 @@ FloatingWindow {
                     text: wifiAnonymousIdentityInput
                     placeholderText: I18n.tr("Anonymous Identity (optional)")
                     backgroundColor: "transparent"
-                    enabled: root.visible
+                    enabled: root.shouldBeVisible
                     keyNavigationTab: domainMatchInput
                     keyNavigationBacktab: passwordInput
                     onTextEdited: wifiAnonymousIdentityInput = text
@@ -620,7 +606,7 @@ FloatingWindow {
                     text: wifiDomainInput
                     placeholderText: I18n.tr("Domain (optional)")
                     backgroundColor: "transparent"
-                    enabled: root.visible
+                    enabled: root.shouldBeVisible
                     keyNavigationTab: usernameInput
                     keyNavigationBacktab: anonInput
                     onTextEdited: wifiDomainInput = text
@@ -757,8 +743,5 @@ FloatingWindow {
         }
     }
 
-    FloatingWindowControls {
+    onOpened: Qt.callLater(() => contentFocusScope.forceActiveFocus())
-        id: windowControls
-        targetWindow: root
-    }
 }

quickshell/Modules/BlurredWallpaperBackground.qml

@@ -43,6 +43,11 @@ Variants {
             id: root
             anchors.fill: parent
 
+            Rectangle {
+                anchors.fill: parent
+                color: SettingsData.effectiveWallpaperBackgroundColor
+            }
+
             function encodeFileUrl(path) {
                 if (!path)
                     return "";
@@ -137,6 +142,12 @@ Variants {
                 function onWallpaperFillModeChanged() {
                     root.invalidate();
                 }
+                function onWallpaperBackgroundColorModeChanged() {
+                    root.invalidate();
+                }
+                function onWallpaperBackgroundCustomColorChanged() {
+                    root.invalidate();
+                }
             }
 
             Connections {

quickshell/Modules/ControlCenter/BuiltinPlugins/TailscaleWidget.qml

@@ -25,7 +25,14 @@ PluginComponent {
     }
     ccWidgetIsActive: TailscaleService.connected
 
-    onCcWidgetToggled: {}
+    onCcWidgetToggled: {
+        if (!TailscaleService.available)
+            return;
+        if (TailscaleService.connected)
+            TailscaleService.disconnectTailscale(null);
+        else
+            TailscaleService.connectTailscale(null);
+    }
 
     ccDetailContent: Component {
         Rectangle {
@@ -88,6 +95,122 @@ PluginComponent {
                         width: parent.width
                         spacing: Theme.spacingS
 
+                        // Connection status + connect/disconnect. Always shown
+                        // (when available) so the connection can be toggled from
+                        // the detail, including while disconnected.
+                        RowLayout {
+                            width: parent.width
+                            spacing: Theme.spacingS
+
+                            Column {
+                                Layout.fillWidth: true
+                                Layout.alignment: Qt.AlignVCenter
+                                spacing: 1
+
+                                StyledText {
+                                    text: TailscaleService.connected ? I18n.tr("Connected", "Tailscale connection status: connected") : I18n.tr("Disconnected", "Tailscale connection status: disconnected")
+                                    font.pixelSize: Theme.fontSizeMedium
+                                    font.weight: Font.Medium
+                                    color: Theme.surfaceText
+                                }
+
+                                StyledText {
+                                    visible: TailscaleService.connected && TailscaleService.tailnetName.length > 0
+                                    text: TailscaleService.tailnetName
+                                    font.pixelSize: Theme.fontSizeSmall
+                                    color: Theme.surfaceVariantText
+                                    width: parent.width
+                                    elide: Text.ElideRight
+                                }
+                            }
+
+                            Rectangle {
+                                id: connButton
+                                Layout.alignment: Qt.AlignVCenter
+                                height: 28
+                                radius: 14
+                                width: connButtonRow.implicitWidth + Theme.spacingM * 2
+
+                                readonly property bool isConnected: TailscaleService.connected
+                                color: isConnected ? (connButtonArea.containsMouse ? Theme.errorHover : Theme.surfaceLight) : (connButtonArea.containsMouse ? Theme.primaryHoverLight : Theme.surfaceLight)
+
+                                Row {
+                                    id: connButtonRow
+                                    anchors.centerIn: parent
+                                    spacing: Theme.spacingXS
+
+                                    DankIcon {
+                                        name: connButton.isConnected ? "link_off" : "link"
+                                        size: Theme.fontSizeSmall
+                                        color: connButton.isConnected ? Theme.surfaceText : Theme.primary
+                                        anchors.verticalCenter: parent.verticalCenter
+                                    }
+
+                                    StyledText {
+                                        text: connButton.isConnected ? I18n.tr("Disconnect", "Tailscale disconnect button") : I18n.tr("Connect", "Tailscale connect button")
+                                        font.pixelSize: Theme.fontSizeSmall
+                                        font.weight: Font.Medium
+                                        color: connButton.isConnected ? Theme.surfaceText : Theme.primary
+                                        anchors.verticalCenter: parent.verticalCenter
+                                    }
+                                }
+
+                                MouseArea {
+                                    id: connButtonArea
+                                    anchors.fill: parent
+                                    hoverEnabled: true
+                                    cursorShape: Qt.PointingHandCursor
+                                    onClicked: {
+                                        if (TailscaleService.connected)
+                                            TailscaleService.disconnectTailscale(null);
+                                        else
+                                            TailscaleService.connectTailscale(null);
+                                    }
+                                }
+                            }
+                        }
+
+                        // Connection controls: exit node picker + LAN access.
+                        // Only meaningful while the backend is connected.
+                        Column {
+                            id: controlsColumn
+                            width: parent.width
+                            spacing: Theme.spacingS
+                            visible: TailscaleService.connected
+
+                            readonly property string noneLabel: I18n.tr("None", "Tailscale exit node: none selected")
+
+                            DankDropdown {
+                                width: parent.width
+                                text: I18n.tr("Exit node", "Tailscale exit node selector label")
+                                currentValue: TailscaleService.currentExitNode ? TailscaleService.currentExitNode.hostname : controlsColumn.noneLabel
+                                options: {
+                                    const opts = [controlsColumn.noneLabel];
+                                    for (const p of TailscaleService.exitNodeOptions)
+                                        opts.push(p.hostname);
+                                    return opts;
+                                }
+                                onValueChanged: value => {
+                                    if (value === controlsColumn.noneLabel) {
+                                        TailscaleService.clearExitNode(null);
+                                        return;
+                                    }
+                                    const peer = TailscaleService.exitNodeOptions.find(p => p.hostname === value);
+                                    if (peer)
+                                        TailscaleService.setExitNode(peer.id, null);
+                                }
+                            }
+
+                            DankToggle {
+                                width: parent.width
+                                text: I18n.tr("Allow LAN access", "Tailscale allow LAN access toggle")
+                                description: I18n.tr("Reach local network devices while using an exit node", "Tailscale allow LAN access description")
+                                visible: TailscaleService.currentExitNode !== null
+                                checked: TailscaleService.exitNodeAllowLanAccess
+                                onToggled: value => TailscaleService.setAllowLanAccess(value, null)
+                            }
+                        }
+
                         // Search bar + refresh button
                         RowLayout {
                             width: parent.width

quickshell/Modules/ControlCenter/ControlCenterPopout.qml

@@ -93,7 +93,7 @@ DankPopout {
     shouldBeVisible: false
 
     property bool credentialsPromptOpen: NetworkService.credentialsRequested
-    property bool wifiPasswordModalOpen: PopoutService.wifiPasswordModal?.visible ?? false
+    property bool wifiPasswordModalOpen: PopoutService.wifiPasswordModal?.shouldBeVisible ?? false
     property bool polkitModalOpen: PopoutService.polkitAuthModal?.visible ?? false
     property bool anyModalOpen: credentialsPromptOpen || wifiPasswordModalOpen || polkitModalOpen || powerMenuOpen
 

quickshell/Modules/ControlCenter/Details/NetworkDetail.qml

@@ -2,6 +2,7 @@ import QtQuick
 import QtQuick.Controls
 import Quickshell
 import qs.Common
+import qs.Modules.Network
 import qs.Services
 import qs.Widgets
 import qs.Modals
@@ -721,7 +722,7 @@ Rectangle {
 
             DankActionButton {
                 id: qrCodeButton
-                visible: modelData.secured && modelData.saved
+                visible: modelData.secured && modelData.saved && !(modelData.enterprise || false)
                 anchors.right: parent.right
                 anchors.rightMargin: optionsButton.width + pinWifiRow.width + 3 * Theme.spacingM + Theme.spacingS
                 anchors.verticalCenter: parent.verticalCenter
@@ -749,11 +750,9 @@ Rectangle {
                         event.accepted = true;
                         return;
                     }
-                    if (modelData.secured && !modelData.saved && (DMSService.apiVersion < 7 || modelData.enterprise)) {
+                    WifiConnectionActions.connectToNetwork(modelData, {
-                        PopoutService.showWifiPasswordModal(modelData.ssid);
+                        connected: wifiDelegate.isConnected
-                    } else {
+                    });
-                        NetworkService.connectToWifi(modelData.ssid);
-                    }
                     event.accepted = true;
                 }
             }
@@ -804,15 +803,9 @@ Rectangle {
             }
 
             onTriggered: {
-                if (networkContextMenu.currentConnected) {
+                WifiConnectionActions.connectToNetworkFromDetails(networkContextMenu.currentSSID, networkContextMenu.currentSecured, networkContextMenu.currentSaved, networkContextMenu.currentEnterprise, networkContextMenu.currentConnected, {
-                    NetworkService.disconnectWifi();
+                    disconnectWhenConnected: true
-                    return;
+                });
-                }
-                if (networkContextMenu.currentSecured && !networkContextMenu.currentSaved && (DMSService.apiVersion < 7 || networkContextMenu.currentEnterprise)) {
-                    PopoutService.showWifiPasswordModal(networkContextMenu.currentSSID);
-                    return;
-                }
-                NetworkService.connectToWifi(networkContextMenu.currentSSID);
             }
         }
 

quickshell/Modules/DankBar/DankBarWindow.qml

@@ -150,6 +150,9 @@ PanelWindow {
         function onUsesFrameBarChromeChanged() {
             _blurRebuildTimer.restart();
         }
+        function onBarRevealedChanged() {
+            _blurRebuildTimer.restart();
+        }
     }
 
     Component {
@@ -176,6 +179,13 @@ PanelWindow {
             teardown();
             if (!BlurService.enabled || !BlurService.available)
                 return;
+            // When the bar is hidden (auto-hide, or config not visible) keep the blur
+            // region empty rather than sliding it off-surface. Some compositors (Hyprland)
+            // gate blur on a non-empty region and then blur the whole surface box when the
+            // clip degenerates to empty, leaving the bar strip blurred while the bar is
+            // hidden (issue #2656). A null region disables the effect cleanly.
+            if (!barWindow.barRevealed)
+                return;
             // In frame mode, FrameWindow owns the blur region for the entire screen edge
             // (including the bar area). The bar must not set its own competing blur region
             // so that frameBlurEnabled acts as the single control for all blur in frame mode.

quickshell/Modules/DankBar/Widgets/AppsDock.qml

@@ -933,19 +933,17 @@ BasePill {
                         tooltipLoader.active = true;
                         if (tooltipLoader.item) {
                             if (root.isVerticalOrientation) {
-                                const globalPos = delegateItem.mapToGlobal(0, delegateItem.height / 2);
+                                const localPos = delegateItem.mapToItem(null, 0, delegateItem.height / 2);
-                                const screenX = root.parentScreen ? root.parentScreen.x : 0;
-                                const screenY = root.parentScreen ? root.parentScreen.y : 0;
                                 const isLeft = root.axis?.edge === "left";
                                 const tooltipX = isLeft ? (root.barThickness + root.barSpacing + Theme.spacingXS) : (root.parentScreen.width - root.barThickness - root.barSpacing - Theme.spacingXS);
-                                const screenRelativeY = globalPos.y - screenY + root.minTooltipY;
+                                const screenRelativeY = localPos.y + root.minTooltipY;
-                                tooltipLoader.item.show(appItem.tooltipText, screenX + tooltipX, screenRelativeY, root.parentScreen, isLeft, !isLeft);
+                                tooltipLoader.item.show(appItem.tooltipText, tooltipX, screenRelativeY, root.parentScreen, isLeft, !isLeft);
                             } else {
-                                const globalPos = delegateItem.mapToGlobal(delegateItem.width / 2, delegateItem.height);
+                                const localPos = delegateItem.mapToItem(null, delegateItem.width / 2, delegateItem.height);
                                 const screenHeight = root.parentScreen ? root.parentScreen.height : Screen.height;
                                 const isBottom = root.axis?.edge === "bottom";
                                 const tooltipY = isBottom ? (screenHeight - root.barThickness - root.barSpacing - Theme.spacingXS - 35) : (root.barThickness + root.barSpacing + Theme.spacingXS);
-                                tooltipLoader.item.show(appItem.tooltipText, globalPos.x, tooltipY, root.parentScreen, false, false);
+                                tooltipLoader.item.show(appItem.tooltipText, localPos.x, tooltipY, root.parentScreen, false, false);
                             }
                         }
                     }
@@ -967,14 +965,12 @@ BasePill {
                             contextMenuLoader.active = true;
 
                             if (contextMenuLoader.item) {
-                                const globalPos = delegateItem.mapToGlobal(delegateItem.width / 2, delegateItem.height / 2);
+                                const localPos = delegateItem.mapToItem(null, delegateItem.width / 2, delegateItem.height / 2);
-                                const screenX = root.parentScreen ? root.parentScreen.x : 0;
-                                const screenY = root.parentScreen ? root.parentScreen.y : 0;
                                 const isBarVertical = root.axis?.isVertical ?? false;
                                 const barEdge = root.axis?.edge ?? "top";
 
-                                let x = globalPos.x - screenX;
+                                let x = localPos.x;
-                                let y = globalPos.y - screenY;
+                                let y = localPos.y;
 
                                 switch (barEdge) {
                                 case "bottom":

quickshell/Modules/DankBar/Widgets/Battery.qml

@@ -118,10 +118,18 @@ BasePill {
         width: battery.width + battery.leftMargin + battery.rightMargin
         height: battery.height + battery.topMargin + battery.bottomMargin
         cursorShape: Qt.PointingHandCursor
-        acceptedButtons: Qt.LeftButton
+        acceptedButtons: Qt.LeftButton | Qt.RightButton
         onPressed: mouse => {
             battery.triggerRipple(this, mouse.x, mouse.y);
-            toggleBatteryPopup();
+            if (mouse.button === Qt.LeftButton) {
+                toggleBatteryPopup();
+            } else if (mouse.button === Qt.RightButton) {
+                if (PowerProfileWatcher.available) {
+                    PowerProfileWatcher.cycleProfile();
+                } else {
+                    ToastService.showError(I18n.tr("power-profiles-daemon not available"));
+                }
+            }
         }
         onWheel: wheel => {
             var delta = wheel.angleDelta.y;
@@ -131,33 +139,20 @@ BasePill {
             // Check if this is a touchpad
             if (delta !== 120 && delta !== -120) {
                 touchpadAccumulator += delta;
-                log.info("Acc: " + touchpadAccumulator);
                 if (Math.abs(touchpadAccumulator) < 500)
                     return;
                 delta = touchpadAccumulator;
                 touchpadAccumulator = 0;
             }
-            log.info("Trigger! Delta: " + delta);
 
-            // This is after the other delta checks so it only shows on valid Y scroll
+            if (!DisplayService.brightnessAvailable) {
-            if (!PowerProfileWatcher.available) {
-                ToastService.showError(I18n.tr("power-profiles-daemon not available"));
                 return;
             }
 
-            const profiles = PowerProfileWatcher.availableProfiles;
+            const step = 5;
-            var index = profiles.findIndex(profile => PowerProfiles.profile === profile);
+            const change = delta > 0 ? step : -step;
-
+            const newBrightness = Math.max(0, Math.min(100, DisplayService.brightnessLevel + change));
-            if (delta > 0)
+            DisplayService.setBrightness(newBrightness, "", false);
-                index += 1;
-            else
-                index -= 1;
-
-            if (index < 0 || index >= profiles.length)
-                return;
-
-            if (!PowerProfileWatcher.applyProfile(profiles[index]))
-                ToastService.showError(I18n.tr("Failed to set power profile"));
         }
     }
 }

quickshell/Modules/DankBar/Widgets/ControlCenterButton.qml

@@ -513,7 +513,7 @@ BasePill {
                                 case "vpn":
                                     return "vpn_lock";
                                 case "bluetooth":
-                                    return "bluetooth";
+                                    return BluetoothService.connected ? "bluetooth_connected" : "bluetooth";
                                 case "battery":
                                     return Theme.getBatteryIcon(BatteryService.batteryLevel, BatteryService.isCharging, BatteryService.batteryAvailable);
                                 case "printer":
@@ -698,7 +698,7 @@ BasePill {
                                 case "vpn":
                                     return "vpn_lock";
                                 case "bluetooth":
-                                    return "bluetooth";
+                                    return BluetoothService.connected ? "bluetooth_connected" : "bluetooth";
                                 case "battery":
                                     return Theme.getBatteryIcon(BatteryService.batteryLevel, BatteryService.isCharging, BatteryService.batteryAvailable);
                                 case "printer":

quickshell/Modules/DankBar/Widgets/DiskUsage.qml

@@ -276,15 +276,12 @@ BasePill {
             if (root.isVerticalOrientation && root.selectedMount) {
                 tooltipLoader.active = true;
                 if (tooltipLoader.item) {
-                    const globalPos = mapToGlobal(width / 2, height / 2);
+                    const localPos = mapToItem(null, width / 2, height / 2);
                     const currentScreen = root.parentScreen || Screen;
-                    const screenX = currentScreen ? currentScreen.x : 0;
+                    const adjustedY = localPos.y + root.minTooltipY;
-                    const screenY = currentScreen ? currentScreen.y : 0;
-                    const relativeY = globalPos.y - screenY;
-                    const adjustedY = relativeY + root.minTooltipY;
                     const tooltipX = root.axis?.edge === "left" ? (root.barThickness + root.barSpacing + Theme.spacingXS) : (currentScreen.width - root.barThickness - root.barSpacing - Theme.spacingXS);
                     const isLeft = root.axis?.edge === "left";
-                    tooltipLoader.item.show(root.selectedMount.mount, screenX + tooltipX, adjustedY, currentScreen, isLeft, !isLeft);
+                    tooltipLoader.item.show(root.selectedMount.mount, tooltipX, adjustedY, currentScreen, isLeft, !isLeft);
                 }
             }
         }

quickshell/Modules/DankBar/Widgets/FocusedApp.qml

@@ -304,13 +304,9 @@ BasePill {
             if (root.isVerticalOrientation && activeWindow && activeWindow.appId && root.parentScreen) {
                 tooltipLoader.active = true;
                 if (tooltipLoader.item) {
-                    const globalPos = mapToGlobal(width / 2, height / 2);
+                    const localPos = mapToItem(null, width / 2, height / 2);
                     const currentScreen = root.parentScreen;
-                    const screenX = currentScreen ? currentScreen.x : 0;
+                    const adjustedY = localPos.y + root.minTooltipY;
-                    const screenY = currentScreen ? currentScreen.y : 0;
-                    const relativeY = globalPos.y - screenY;
-                    // Add minTooltipY offset to account for top bar
-                    const adjustedY = relativeY + root.minTooltipY;
                     const tooltipX = root.axis?.edge === "left" ? (Theme.barHeight + (barConfig?.spacing ?? 4) + Theme.spacingXS) : (currentScreen.width - Theme.barHeight - (barConfig?.spacing ?? 4) - Theme.spacingXS);
 
                     const appName = Paths.getAppName(activeWindow.appId, activeDesktopEntry);
@@ -318,7 +314,7 @@ BasePill {
                     const tooltipText = appName + (title ? " • " + title : "");
 
                     const isLeft = root.axis?.edge === "left";
-                    tooltipLoader.item.show(tooltipText, screenX + tooltipX, adjustedY, currentScreen, isLeft, !isLeft);
+                    tooltipLoader.item.show(tooltipText, tooltipX, adjustedY, currentScreen, isLeft, !isLeft);
                 }
             }
         }

quickshell/Modules/DankBar/Widgets/RunningApps.qml

@@ -18,6 +18,14 @@ BasePill {
 
     property var widgetData: null
     property var hoveredItem: null
+
+    onHoveredItemChanged: {
+        if (hoveredItem)
+            return;
+        if (tooltipLoader.item)
+            tooltipLoader.item.hide();
+        tooltipLoader.active = false;
+    }
     property var topBar: null
     property bool isAutoHideBar: false
     property Item windowRoot: (Window.window ? Window.window.contentItem : null)
@@ -236,6 +244,11 @@ BasePill {
                 delegate: Item {
                     id: delegateItem
 
+                    Component.onDestruction: {
+                        if (root.hoveredItem === delegateItem)
+                            root.hoveredItem = null;
+                    }
+
                     property bool isGrouped: root._groupByApp
                     property var groupData: isGrouped ? modelData : null
                     property var toplevelData: isGrouped ? (modelData.windows.length > 0 ? modelData.windows[0].toplevel : null) : modelData
@@ -411,22 +424,16 @@ BasePill {
                                     windowContextMenuLoader.item.triggerBarThickness = root.barThickness;
                                     windowContextMenuLoader.item.triggerBarSpacing = root.barSpacing;
                                     if (root.isVerticalOrientation) {
-                                        const globalPos = delegateItem.mapToGlobal(delegateItem.width / 2, delegateItem.height / 2);
+                                        const localPos = delegateItem.mapToItem(null, delegateItem.width / 2, delegateItem.height / 2);
-                                        const screenX = root.parentScreen ? root.parentScreen.x : 0;
+                                        const adjustedY = localPos.y + root.minTooltipY;
-                                        const screenY = root.parentScreen ? root.parentScreen.y : 0;
-                                        const relativeY = globalPos.y - screenY;
-                                        // Add minTooltipY offset to account for top bar
-                                        const adjustedY = relativeY + root.minTooltipY;
                                         const xPos = root.axis?.edge === "left" ? (root.barThickness + root.barSpacing + Theme.spacingXS) : (root.parentScreen.width - root.barThickness - root.barSpacing - Theme.spacingXS);
                                         windowContextMenuLoader.item.showAt(xPos, adjustedY, true, root.axis?.edge);
                                     } else {
-                                        const globalPos = delegateItem.mapToGlobal(delegateItem.width / 2, 0);
+                                        const localPos = delegateItem.mapToItem(null, delegateItem.width / 2, 0);
-                                        const screenX = root.parentScreen ? root.parentScreen.x : 0;
-                                        const relativeX = globalPos.x - screenX;
                                         const screenHeight = root.parentScreen ? root.parentScreen.height : Screen.height;
                                         const isBottom = root.axis?.edge === "bottom";
                                         const yPos = isBottom ? (screenHeight - root.barThickness - root.barSpacing - 32 - Theme.spacingXS) : (root.barThickness + root.barSpacing + Theme.spacingXS);
-                                        windowContextMenuLoader.item.showAt(relativeX, yPos, false, root.axis?.edge);
+                                        windowContextMenuLoader.item.showAt(localPos.x, yPos, false, root.axis?.edge);
                                     }
                                 }
                             } else if (mouse.button === Qt.MiddleButton) {
@@ -442,33 +449,23 @@ BasePill {
                             tooltipLoader.active = true;
                             if (tooltipLoader.item) {
                                 if (root.isVerticalOrientation) {
-                                    const globalPos = delegateItem.mapToGlobal(delegateItem.width / 2, delegateItem.height / 2);
+                                    const localPos = delegateItem.mapToItem(null, delegateItem.width / 2, delegateItem.height / 2);
-                                    const screenX = root.parentScreen ? root.parentScreen.x : 0;
-                                    const screenY = root.parentScreen ? root.parentScreen.y : 0;
-                                    const relativeY = globalPos.y - screenY;
                                     const tooltipX = root.axis?.edge === "left" ? (root.barThickness + root.barSpacing + Theme.spacingXS) : (root.parentScreen.width - root.barThickness - root.barSpacing - Theme.spacingXS);
                                     const isLeft = root.axis?.edge === "left";
-                                    const adjustedY = relativeY + root.minTooltipY;
+                                    const adjustedY = localPos.y + root.minTooltipY;
-                                    const finalX = screenX + tooltipX;
+                                    tooltipLoader.item.show(delegateItem.tooltipText, tooltipX, adjustedY, root.parentScreen, isLeft, !isLeft);
-                                    tooltipLoader.item.show(delegateItem.tooltipText, finalX, adjustedY, root.parentScreen, isLeft, !isLeft);
                                 } else {
-                                    const globalPos = delegateItem.mapToGlobal(delegateItem.width / 2, delegateItem.height);
+                                    const localPos = delegateItem.mapToItem(null, delegateItem.width / 2, delegateItem.height);
                                     const screenHeight = root.parentScreen ? root.parentScreen.height : Screen.height;
                                     const isBottom = root.axis?.edge === "bottom";
                                     const tooltipY = isBottom ? (screenHeight - root.barThickness - root.barSpacing - Theme.spacingXS - 35) : (root.barThickness + root.barSpacing + Theme.spacingXS);
-                                    tooltipLoader.item.show(delegateItem.tooltipText, globalPos.x, tooltipY, root.parentScreen, false, false);
+                                    tooltipLoader.item.show(delegateItem.tooltipText, localPos.x, tooltipY, root.parentScreen, false, false);
                                 }
                             }
                         }
                         onExited: {
-                            if (root.hoveredItem === delegateItem) {
+                            if (root.hoveredItem === delegateItem)
                                 root.hoveredItem = null;
-                                if (tooltipLoader.item) {
-                                    tooltipLoader.item.hide();
-                                }
-
-                                tooltipLoader.active = false;
-                            }
                         }
                     }
                 }
@@ -491,6 +488,11 @@ BasePill {
                 delegate: Item {
                     id: delegateItem
 
+                    Component.onDestruction: {
+                        if (root.hoveredItem === delegateItem)
+                            root.hoveredItem = null;
+                    }
+
                     property bool isGrouped: root._groupByApp
                     property var groupData: isGrouped ? modelData : null
                     property var toplevelData: isGrouped ? (modelData.windows.length > 0 ? modelData.windows[0].toplevel : null) : modelData
@@ -665,22 +667,16 @@ BasePill {
                                     windowContextMenuLoader.item.triggerBarThickness = root.barThickness;
                                     windowContextMenuLoader.item.triggerBarSpacing = root.barSpacing;
                                     if (root.isVerticalOrientation) {
-                                        const globalPos = delegateItem.mapToGlobal(delegateItem.width / 2, delegateItem.height / 2);
+                                        const localPos = delegateItem.mapToItem(null, delegateItem.width / 2, delegateItem.height / 2);
-                                        const screenX = root.parentScreen ? root.parentScreen.x : 0;
+                                        const adjustedY = localPos.y + root.minTooltipY;
-                                        const screenY = root.parentScreen ? root.parentScreen.y : 0;
-                                        const relativeY = globalPos.y - screenY;
-                                        // Add minTooltipY offset to account for top bar
-                                        const adjustedY = relativeY + root.minTooltipY;
                                         const xPos = root.axis?.edge === "left" ? (root.barThickness + root.barSpacing + Theme.spacingXS) : (root.parentScreen.width - root.barThickness - root.barSpacing - Theme.spacingXS);
                                         windowContextMenuLoader.item.showAt(xPos, adjustedY, true, root.axis?.edge);
                                     } else {
-                                        const globalPos = delegateItem.mapToGlobal(delegateItem.width / 2, 0);
+                                        const localPos = delegateItem.mapToItem(null, delegateItem.width / 2, 0);
-                                        const screenX = root.parentScreen ? root.parentScreen.x : 0;
-                                        const relativeX = globalPos.x - screenX;
                                         const screenHeight = root.parentScreen ? root.parentScreen.height : Screen.height;
                                         const isBottom = root.axis?.edge === "bottom";
                                         const yPos = isBottom ? (screenHeight - root.barThickness - root.barSpacing - 32 - Theme.spacingXS) : (root.barThickness + root.barSpacing + Theme.spacingXS);
-                                        windowContextMenuLoader.item.showAt(relativeX, yPos, false, root.axis?.edge);
+                                        windowContextMenuLoader.item.showAt(localPos.x, yPos, false, root.axis?.edge);
                                     }
                                 }
                             } else if (mouse.button === Qt.MiddleButton) {
@@ -696,33 +692,23 @@ BasePill {
                             tooltipLoader.active = true;
                             if (tooltipLoader.item) {
                                 if (root.isVerticalOrientation) {
-                                    const globalPos = delegateItem.mapToGlobal(delegateItem.width / 2, delegateItem.height / 2);
+                                    const localPos = delegateItem.mapToItem(null, delegateItem.width / 2, delegateItem.height / 2);
-                                    const screenX = root.parentScreen ? root.parentScreen.x : 0;
-                                    const screenY = root.parentScreen ? root.parentScreen.y : 0;
-                                    const relativeY = globalPos.y - screenY;
                                     const tooltipX = root.axis?.edge === "left" ? (root.barThickness + root.barSpacing + Theme.spacingXS) : (root.parentScreen.width - root.barThickness - root.barSpacing - Theme.spacingXS);
                                     const isLeft = root.axis?.edge === "left";
-                                    const adjustedY = relativeY + root.minTooltipY;
+                                    const adjustedY = localPos.y + root.minTooltipY;
-                                    const finalX = screenX + tooltipX;
+                                    tooltipLoader.item.show(delegateItem.tooltipText, tooltipX, adjustedY, root.parentScreen, isLeft, !isLeft);
-                                    tooltipLoader.item.show(delegateItem.tooltipText, finalX, adjustedY, root.parentScreen, isLeft, !isLeft);
                                 } else {
-                                    const globalPos = delegateItem.mapToGlobal(delegateItem.width / 2, delegateItem.height);
+                                    const localPos = delegateItem.mapToItem(null, delegateItem.width / 2, delegateItem.height);
                                     const screenHeight = root.parentScreen ? root.parentScreen.height : Screen.height;
                                     const isBottom = root.axis?.edge === "bottom";
                                     const tooltipY = isBottom ? (screenHeight - root.barThickness - root.barSpacing - Theme.spacingXS - 35) : (root.barThickness + root.barSpacing + Theme.spacingXS);
-                                    tooltipLoader.item.show(delegateItem.tooltipText, globalPos.x, tooltipY, root.parentScreen, false, false);
+                                    tooltipLoader.item.show(delegateItem.tooltipText, localPos.x, tooltipY, root.parentScreen, false, false);
                                 }
                             }
                         }
                         onExited: {
-                            if (root.hoveredItem === delegateItem) {
+                            if (root.hoveredItem === delegateItem)
                                 root.hoveredItem = null;
-                                if (tooltipLoader.item) {
-                                    tooltipLoader.item.hide();
-                                }
-
-                                tooltipLoader.active = false;
-                            }
                         }
                     }
                 }

quickshell/Modules/DankBar/Widgets/Vpn.qml

@@ -106,18 +106,15 @@ BasePill {
             }
 
             if (root.isVerticalOrientation) {
-                const globalPos = mapToGlobal(width / 2, height / 2);
+                const localPos = mapToItem(null, width / 2, height / 2);
                 const currentScreen = root.parentScreen || Screen;
-                const screenX = currentScreen ? currentScreen.x : 0;
+                const adjustedY = localPos.y + root.minTooltipY;
-                const screenY = currentScreen ? currentScreen.y : 0;
-                const relativeY = globalPos.y - screenY;
-                const adjustedY = relativeY + root.minTooltipY;
                 const tooltipX = root.axis?.edge === "left" ? (root.barThickness + root.barSpacing + Theme.spacingXS) : (currentScreen.width - root.barThickness - root.barSpacing - Theme.spacingXS);
                 const isLeft = root.axis?.edge === "left";
-                tooltipLoader.item.show(tooltipText, screenX + tooltipX, adjustedY, currentScreen, isLeft, !isLeft);
+                tooltipLoader.item.show(tooltipText, tooltipX, adjustedY, currentScreen, isLeft, !isLeft);
             } else {
                 const isBottom = root.axis?.edge === "bottom";
-                const globalPos = mapToGlobal(width / 2, 0);
+                const localPos = mapToItem(null, width / 2, 0);
                 const currentScreen = root.parentScreen || Screen;
 
                 let tooltipY;
@@ -128,7 +125,7 @@ BasePill {
                     tooltipY = root.barThickness + root.barSpacing + Theme.spacingXS;
                 }
 
-                tooltipLoader.item.show(tooltipText, globalPos.x, tooltipY, currentScreen, false, false);
+                tooltipLoader.item.show(tooltipText, localPos.x, tooltipY, currentScreen, false, false);
             }
         }
         onExited: {

quickshell/Modules/DankBar/Widgets/Weather.qml

@@ -9,9 +9,8 @@ BasePill {
 
     visible: SettingsData.weatherEnabled
 
-    Ref {
+    Component.onCompleted: WeatherService.addRef()
-        service: WeatherService
+    Component.onDestruction: WeatherService.removeRef()
-    }
 
     content: Component {
         Item {

quickshell/Modules/DankBar/Widgets/WorkspaceSwitcher.qml

@@ -1192,38 +1192,25 @@ Item {
                     return Math.max(baseHeight + iconsExtraHeight, contentImplicitHeight + padding);
                 }
 
-                readonly property color unfocusedColor: {
+                function colorFromMode(mode, fallbackColor, customColor, customFallbackColor) {
-                    switch (SettingsData.workspaceUnfocusedColorMode) {
+                    switch (mode) {
-                    case "s":
+                    case "primary":
-                        return Theme.surface;
+                    case "pri":
-                    case "sc":
-                        return Theme.surfaceContainer;
-                    case "sch":
-                        return Theme.surfaceContainerHigh;
-                    default:
-                        return Theme.surfaceTextAlpha;
-                    }
-                }
-
-                readonly property color activeColor: {
-                    switch (SettingsData.workspaceColorMode) {
-                    case "s":
-                        return Theme.surface;
-                    case "sc":
-                        return Theme.surfaceContainer;
-                    case "sch":
-                        return Theme.surfaceContainerHigh;
-                    case "none":
-                        return unfocusedColor;
-                    default:
                         return Theme.primary;
-                    }
+                    case "primaryContainer":
-                }
+                        return Theme.primaryContainer;
-
+                    case "secondary":
-                readonly property color occupiedColor: {
-                    switch (SettingsData.workspaceOccupiedColorMode) {
                     case "sec":
                         return Theme.secondary;
+                    case "secondaryContainer":
+                        return Theme.secondaryContainer;
+                    case "tertiary":
+                    case "ter":
+                        return Theme.tertiary;
+                    case "tertiaryContainer":
+                        return Theme.tertiaryContainer;
+                    case "surfaceText":
+                        return Theme.surfaceText;
                     case "s":
                         return Theme.surface;
                     case "sc":
@@ -1232,37 +1219,34 @@ Item {
                         return Theme.surfaceContainerHigh;
                     case "schh":
                         return Theme.surfaceContainerHighest;
-                    default:
+                    case "error":
-                        return unfocusedColor;
+                    case "err":
-                    }
-                }
-
-                readonly property color urgentColor: {
-                    switch (SettingsData.workspaceUrgentColorMode) {
-                    case "primary":
-                        return Theme.primary;
-                    case "secondary":
-                        return Theme.secondary;
-                    case "s":
-                        return Theme.surface;
-                    case "sc":
-                        return Theme.surfaceContainer;
-                    default:
                         return Theme.error;
+                    case "custom":
+                        return Theme.safeColor(customColor, customFallbackColor);
+                    default:
+                        return fallbackColor;
                     }
                 }
 
-                readonly property color focusedBorderColor: {
+                readonly property color unfocusedColor: colorFromMode(SettingsData.workspaceUnfocusedColorMode, Theme.surfaceTextAlpha, SettingsData.workspaceUnfocusedCustomColor, Theme.surfaceTextAlpha)
-                    switch (SettingsData.workspaceFocusedBorderColor) {
+
-                    case "surfaceText":
+                readonly property color activeColor: {
-                        return Theme.surfaceText;
+                    if (SettingsData.workspaceColorMode === "none")
-                    case "secondary":
+                        return unfocusedColor;
-                        return Theme.secondary;
+                    return colorFromMode(SettingsData.workspaceColorMode, Theme.primary, SettingsData.workspaceFocusedCustomColor, Theme.primary);
-                    default:
-                        return Theme.primary;
-                    }
                 }
 
+                readonly property color occupiedColor: {
+                    if (SettingsData.workspaceOccupiedColorMode === "none")
+                        return unfocusedColor;
+                    return colorFromMode(SettingsData.workspaceOccupiedColorMode, unfocusedColor, SettingsData.workspaceOccupiedCustomColor, Theme.secondary);
+                }
+
+                readonly property color urgentColor: colorFromMode(SettingsData.workspaceUrgentColorMode, Theme.error, SettingsData.workspaceUrgentCustomColor, Theme.error)
+
+                readonly property color focusedBorderColor: colorFromMode(SettingsData.workspaceFocusedBorderColor, Theme.primary, SettingsData.workspaceFocusedBorderCustomColor, Theme.primary)
+
                 function getContrastingIconColor(bgColor) {
                     const luminance = 0.299 * bgColor.r + 0.587 * bgColor.g + 0.114 * bgColor.b;
                     return luminance > 0.4 ? Qt.rgba(0.15, 0.15, 0.15, 1) : Qt.rgba(0.8, 0.8, 0.8, 1);

quickshell/Modules/DankDash/WeatherTab.qml

@@ -18,6 +18,9 @@ Item {
     property bool showHourly: false
     property bool available: WeatherService.weather.available
 
+    Component.onCompleted: WeatherService.addRef()
+    Component.onDestruction: WeatherService.removeRef()
+
     function syncFrom(type) {
         if (!dailyLoader.item || !hourlyLoader.item)
             return;

quickshell/Modules/Dock/Dock.qml

@@ -511,13 +511,11 @@ Variants {
             if (!dock.hoveredButton || !dock.reveal || slideXAnimation.running || slideYAnimation.running)
                 return;
 
-            const buttonGlobalPos = dock.hoveredButton.mapToGlobal(0, 0);
+            const buttonLocalPos = dock.hoveredButton.mapToItem(null, 0, 0);
             const tooltipText = dock.hoveredButton.tooltipText || "";
             if (!tooltipText)
                 return;
 
-            const screenX = dock.screen ? (dock.screen.x || 0) : 0;
-            const screenY = dock.screen ? (dock.screen.y || 0) : 0;
             const screenHeight = dock.screen ? dock.screen.height : 0;
 
             const gap = Theme.spacingS;
@@ -527,19 +525,19 @@ Variants {
 
             if (!dock.isVertical) {
                 const isBottom = SettingsData.dockPosition === SettingsData.Position.Bottom;
-                const globalX = buttonGlobalPos.x + btnW / 2 + adjacentLeftBarWidth;
+                const tooltipX = buttonLocalPos.x + btnW / 2 + adjacentLeftBarWidth;
                 const tooltipHeight = 32;
                 const totalFromEdge = bgMargin + dockBackground.height + dock.borderThickness + gap;
                 const screenRelativeY = isBottom ? (screenHeight - totalFromEdge - tooltipHeight) : totalFromEdge;
-                dockTooltip.show(tooltipText, globalX, screenRelativeY, dock.screen, false, false);
+                dockTooltip.show(tooltipText, tooltipX, screenRelativeY, dock.screen, false, false);
                 return;
             }
 
             const isLeft = SettingsData.dockPosition === SettingsData.Position.Left;
             const screenWidth = dock.screen ? dock.screen.width : 0;
             const totalFromEdge = bgMargin + dockBackground.width + dock.borderThickness + gap;
-            const tooltipX = isLeft ? (screenX + totalFromEdge) : (screenX + screenWidth - totalFromEdge);
+            const tooltipX = isLeft ? totalFromEdge : (screenWidth - totalFromEdge);
-            const screenRelativeY = buttonGlobalPos.y - screenY + btnH / 2 + adjacentTopBarHeight;
+            const screenRelativeY = buttonLocalPos.y + btnH / 2 + adjacentTopBarHeight;
             dockTooltip.show(tooltipText, tooltipX, screenRelativeY, dock.screen, isLeft, !isLeft);
         }
 

quickshell/Modules/Greetd/GreetdSettings.qml

@@ -79,6 +79,24 @@ Singleton {
     property var screenPreferences: ({})
     property int animationSpeed: 2
     property string wallpaperFillMode: "Fill"
+    property string wallpaperBackgroundColorMode: "black"
+    property string wallpaperBackgroundCustomColor: "#000000"
+    readonly property color effectiveWallpaperBackgroundColor: {
+        switch (wallpaperBackgroundColorMode) {
+        case "black":
+            return "#000000";
+        case "white":
+            return "#ffffff";
+        case "primary":
+            return (typeof Theme !== "undefined") ? Theme.primary : "#000000";
+        case "surface":
+            return (typeof Theme !== "undefined") ? Theme.surfaceContainer : "#000000";
+        case "custom":
+            return wallpaperBackgroundCustomColor;
+        default:
+            return "#000000";
+        }
+    }
 
     function parseSettings(content) {
         try {
@@ -147,6 +165,8 @@ Singleton {
             screenPreferences = settings.screenPreferences !== undefined ? settings.screenPreferences : ({});
             animationSpeed = settings.animationSpeed !== undefined ? settings.animationSpeed : 2;
             wallpaperFillMode = settings.wallpaperFillMode !== undefined ? settings.wallpaperFillMode : "Fill";
+            wallpaperBackgroundColorMode = settings.wallpaperBackgroundColorMode !== undefined ? settings.wallpaperBackgroundColorMode : "black";
+            wallpaperBackgroundCustomColor = settings.wallpaperBackgroundCustomColor !== undefined ? settings.wallpaperBackgroundCustomColor : "#000000";
 
             if (typeof Theme !== "undefined") {
                 if (currentThemeName === "custom" && customThemeFile) {

quickshell/Modules/Greetd/GreeterContent.qml

@@ -794,6 +794,11 @@ Item {
         }
     }
 
+    Rectangle {
+        anchors.fill: parent
+        color: GreetdSettings.effectiveWallpaperBackgroundColor
+    }
+
     DankBackdrop {
         anchors.fill: parent
         screenName: root.screenName

quickshell/Modules/Greetd/assets/dms-greeter

@@ -227,6 +227,15 @@ export XDG_STATE_HOME="$CACHE_DIR/.local/state"
 export XDG_DATA_HOME="$CACHE_DIR/.local/share"
 export XDG_CACHE_HOME="$CACHE_DIR/.cache"
 
+# Fallback runtime dir for systems without logind/pam_rundir (e.g. Void+seatd),
+# where Wayland compositors abort with "RuntimeDirNotSet". Guarded so logind
+# systems keep their own.
+if [[ -z "${XDG_RUNTIME_DIR:-}" || ! -d "${XDG_RUNTIME_DIR:-}" ]]; then
+    export XDG_RUNTIME_DIR="$CACHE_DIR/run"
+    mkdir -p "$XDG_RUNTIME_DIR"
+    chmod 700 "$XDG_RUNTIME_DIR"
+fi
+
 
 # Keep greeter VT clean by default; callers can override via env or --debug.
 if [[ -z "${RUST_LOG:-}" ]]; then

quickshell/Modules/Lock/Lock.qml

@@ -60,6 +60,10 @@ Scope {
     function lock() {
         if (SettingsData.customPowerActionLock?.length > 0) {
             Quickshell.execDetached(["sh", "-c", SettingsData.customPowerActionLock]);
+            // The custom locker manages its own surface; DMS never engages
+            // WlSessionLock here, so isShellLocked stays false and the fade
+            // overlay would never be dismissed. Hand off by dismissing it now.
+            IdleService.dismissFadeToLock();
             return;
         }
         if (shouldLock || pendingLock)

quickshell/Modules/Lock/LockScreenContent.qml

@@ -182,6 +182,11 @@ Item {
         }
     }
 
+    Rectangle {
+        anchors.fill: parent
+        color: SettingsData.effectiveWallpaperBackgroundColor
+    }
+
     Loader {
         anchors.fill: parent
         active: {

quickshell/Modules/Lock/Pam.qml

@@ -23,6 +23,9 @@ Scope {
     property string u2fPendingMode
     property string buffer
 
+    property var attemptInfoMessages: []
+    property bool lockoutAnnouncedThisAttempt: false
+
     signal flashMsg
     signal unlockRequested
 
@@ -118,23 +121,37 @@ Scope {
         configDirectory: (dankshellConfigWatcher.loaded || nixosMarker.loaded || root.runningFromNixStore) ? "/etc/pam.d" : Quickshell.shellDir + "/assets/pam"
 
         onMessageChanged: {
-            if (message.startsWith("The account is locked")) {
+            // collected by position, not text, so it works in any locale
-                root.lockMessage = message;
+            if (message.length > 0 && !responseRequired)
-            } else if (root.lockMessage && message.endsWith(" left to unlock)")) {
+                root.attemptInfoMessages = root.attemptInfoMessages.concat([message]);
-                root.lockMessage += "\n" + message;
-            } else if (root.lockMessage && message && message.length > 0) {
-                root.lockMessage = "";
-            }
         }
 
         onResponseRequiredChanged: {
             if (!responseRequired)
                 return;
 
+            const notice = root.attemptInfoMessages.filter(m => m !== message);
+            if (notice.length > 0) {
+                root.lockMessage = notice.join("\n");
+                root.lockoutAnnouncedThisAttempt = true;
+            }
+            root.attemptInfoMessages = [];
+
             respond(root.buffer);
         }
 
         onCompleted: res => {
+            // requisite preauth can lock without ever prompting; surface it here too
+            if (!root.lockoutAnnouncedThisAttempt) {
+                if (root.attemptInfoMessages.length > 0) {
+                    root.lockMessage = root.attemptInfoMessages.join("\n");
+                    root.lockoutAnnouncedThisAttempt = true;
+                } else {
+                    root.lockMessage = "";
+                }
+                root.attemptInfoMessages = [];
+            }
+
             if (res === PamResult.Success) {
                 if (!root.unlockInProgress) {
                     fprint.abort();
@@ -168,6 +185,8 @@ Scope {
 
         function onActiveChanged() {
             if (passwd.active) {
+                root.attemptInfoMessages = [];
+                root.lockoutAnnouncedThisAttempt = false;
                 passwdActiveTimeout.restart();
             } else {
                 passwdActiveTimeout.running = false;
@@ -393,6 +412,8 @@ Scope {
         root.u2fPending = false;
         root.u2fPendingMode = "";
         root.lockMessage = "";
+        root.attemptInfoMessages = [];
+        root.lockoutAnnouncedThisAttempt = false;
         root.resetAuthFlows();
         fprint.checkAvail();
         u2f.checkAvail();

quickshell/Modules/Network/WifiConnectionActions.qml

@@ -0,0 +1,47 @@
+pragma Singleton
+pragma ComponentBehavior: Bound
+
+import Quickshell
+import qs.Services
+
+Singleton {
+    id: root
+
+    function connectToNetwork(network, options) {
+        if (!network)
+            return;
+
+        const actionOptions = options || {};
+        const ssid = network.ssid || "";
+        if (!ssid)
+            return;
+
+        const connected = actionOptions.connected ?? network.connected ?? (ssid === NetworkService.currentWifiSSID);
+        if (connected) {
+            if (actionOptions.disconnectWhenConnected ?? false)
+                NetworkService.disconnectWifi();
+            return;
+        }
+
+        if (shouldPromptForCredentials(network)) {
+            PopoutService.showWifiPasswordModal(ssid);
+            return;
+        }
+
+        NetworkService.connectToWifi(ssid);
+    }
+
+    function connectToNetworkFromDetails(ssid, secured, saved, enterprise, connected, options) {
+        connectToNetwork({
+            ssid: ssid,
+            secured: secured,
+            saved: saved,
+            enterprise: enterprise,
+            connected: connected
+        }, options);
+    }
+
+    function shouldPromptForCredentials(network) {
+        return (network.secured ?? false) && !(network.saved ?? false);
+    }
+}

quickshell/Modules/Settings/BatteryTab.qml

@@ -0,0 +1,344 @@
+import QtQuick
+import Quickshell
+import Quickshell.Io
+import qs.Common
+import qs.Services
+import qs.Widgets
+import qs.Modules.Settings.Widgets
+
+Item {
+    id: root
+
+    Process {
+        id: applyLimitProcess
+        command: ["pkexec", "sh", "-c", "
+for bat in /sys/class/power_supply/BAT*; do
+  if [ -f \"$bat/charge_control_limit_max\" ]; then
+    echo " + SettingsData.batteryChargeLimit + " > \"$bat/charge_control_limit_max\"
+  elif [ -f \"$bat/charge_stop_threshold\" ]; then
+    echo " + SettingsData.batteryChargeLimit + " > \"$bat/charge_stop_threshold\"
+  elif [ -f \"$bat/charge_control_end_threshold\" ]; then
+    echo " + SettingsData.batteryChargeLimit + " > \"$bat/charge_control_end_threshold\"
+  fi
+done
+"]
+        running: false
+        onExited: exitCode => {
+            if (exitCode !== 0) {
+                ToastService.showError(I18n.tr("Failed to apply charge limit to system"), I18n.tr("Process exited with code %1").arg(exitCode));
+            } else {
+                ToastService.showInfo(I18n.tr("Charge limit applied successfully"), I18n.tr("Limit set to %1%").arg(SettingsData.batteryChargeLimit));
+            }
+        }
+    }
+
+    DankFlickable {
+        anchors.fill: parent
+        clip: true
+        contentHeight: mainColumn.height + Theme.spacingXL
+        contentWidth: width
+
+        Column {
+            id: mainColumn
+            topPadding: 4
+            width: Math.min(550, parent.width - Theme.spacingL * 2)
+            anchors.horizontalCenter: parent.horizontalCenter
+            spacing: Theme.spacingXL
+
+            // 1. Information Card
+            SettingsCard {
+                width: parent.width
+                iconName: "battery_charging_full"
+                title: I18n.tr("Battery Status")
+                settingKey: "batteryStatusCard"
+
+                Column {
+                    width: parent.width
+                    spacing: Theme.spacingM
+
+                    Row {
+                        width: parent.width
+                        StyledText {
+                            text: I18n.tr("Power Source")
+                            font.pixelSize: Theme.fontSizeMedium
+                            color: Theme.surfaceVariantText
+                            width: parent.width / 2
+                        }
+                        StyledText {
+                            text: BatteryService.isPluggedIn ? I18n.tr("AC Adapter (Plugged In)") : I18n.tr("Battery Power")
+                            font.pixelSize: Theme.fontSizeMedium
+                            font.weight: Font.Medium
+                            color: Theme.surfaceText
+                            width: parent.width / 2
+                        }
+                    }
+
+                    Rectangle {
+                        width: parent.width
+                        height: 1
+                        color: Theme.outline
+                        opacity: 0.1
+                    }
+
+                    Row {
+                        width: parent.width
+                        StyledText {
+                            text: I18n.tr("Charge Level")
+                            font.pixelSize: Theme.fontSizeMedium
+                            color: Theme.surfaceVariantText
+                            width: parent.width / 2
+                        }
+                        StyledText {
+                            text: `${BatteryService.batteryLevel}%`
+                            font.pixelSize: Theme.fontSizeMedium
+                            font.weight: Font.Medium
+                            color: Theme.surfaceText
+                            width: parent.width / 2
+                        }
+                    }
+
+                    Rectangle {
+                        width: parent.width
+                        height: 1
+                        color: Theme.outline
+                        opacity: 0.1
+                    }
+
+                    Row {
+                        width: parent.width
+                        StyledText {
+                            text: I18n.tr("Status")
+                            font.pixelSize: Theme.fontSizeMedium
+                            color: Theme.surfaceVariantText
+                            width: parent.width / 2
+                        }
+                        StyledText {
+                            text: BatteryService.batteryStatus
+                            font.pixelSize: Theme.fontSizeMedium
+                            font.weight: Font.Medium
+                            color: Theme.surfaceText
+                            width: parent.width / 2
+                        }
+                    }
+
+                    Rectangle {
+                        width: parent.width
+                        height: 1
+                        color: Theme.outline
+                        opacity: 0.1
+                    }
+
+                    Row {
+                        width: parent.width
+                        StyledText {
+                            text: I18n.tr("Estimated Time")
+                            font.pixelSize: Theme.fontSizeMedium
+                            color: Theme.surfaceVariantText
+                            width: parent.width / 2
+                        }
+                        StyledText {
+                            text: BatteryService.formatTimeRemaining()
+                            font.pixelSize: Theme.fontSizeMedium
+                            font.weight: Font.Medium
+                            color: Theme.surfaceText
+                            width: parent.width / 2
+                        }
+                    }
+
+                    Rectangle {
+                        width: parent.width
+                        height: 1
+                        color: Theme.outline
+                        opacity: 0.1
+                    }
+
+                    Row {
+                        width: parent.width
+                        StyledText {
+                            text: I18n.tr("Battery Health")
+                            font.pixelSize: Theme.fontSizeMedium
+                            color: Theme.surfaceVariantText
+                            width: parent.width / 2
+                        }
+                        StyledText {
+                            text: BatteryService.batteryHealth
+                            font.pixelSize: Theme.fontSizeMedium
+                            font.weight: Font.Medium
+                            color: Theme.surfaceText
+                            width: parent.width / 2
+                        }
+                    }
+                }
+            }
+
+            // 2. Threshold & Limits Card
+            SettingsCard {
+                width: parent.width
+                iconName: "tune"
+                title: I18n.tr("Battery Protection & Charging")
+                settingKey: "batteryProtection"
+
+                SettingsSliderRow {
+                    settingKey: "batteryChargeLimit"
+                    text: I18n.tr("Battery Charge Limit")
+                    description: I18n.tr("Limit the maximum battery charge level to extend lifespan.")
+                    value: SettingsData.batteryChargeLimit
+                    minimum: 50
+                    maximum: 100
+                    defaultValue: 100
+                    onSliderValueChanged: newValue => SettingsData.set("batteryChargeLimit", newValue)
+                }
+
+                Row {
+                    width: parent.width
+                    height: applyButton.height
+                    layoutDirection: Qt.RightToLeft
+
+                    DankButton {
+                        id: applyButton
+                        text: I18n.tr("Apply to Hardware")
+                        iconName: "lock"
+                        backgroundColor: Theme.primary
+                        textColor: Theme.onPrimary
+                        onClicked: {
+                            applyLimitProcess.running = true;
+                        }
+                    }
+                }
+
+                SettingsToggleRow {
+                    settingKey: "batteryNotifyChargeLimit"
+                    text: I18n.tr("Notify when limit is reached")
+                    description: I18n.tr("Show a notification when battery reaches the charge limit.")
+                    checked: SettingsData.batteryNotifyChargeLimit
+                    onToggled: checked => SettingsData.set("batteryNotifyChargeLimit", checked)
+                }
+
+                Rectangle {
+                    width: parent.width
+                    height: 1
+                    color: Theme.outline
+                    opacity: 0.15
+                }
+
+                SettingsSliderRow {
+                    settingKey: "batteryLowThreshold"
+                    text: I18n.tr("Low Battery Threshold")
+                    description: I18n.tr("Set the percentage at which the battery is considered low.")
+                    value: SettingsData.batteryLowThreshold
+                    minimum: 5
+                    maximum: 40
+                    defaultValue: 20
+                    onSliderValueChanged: newValue => SettingsData.set("batteryLowThreshold", newValue)
+                }
+
+                SettingsToggleRow {
+                    settingKey: "batteryNotifyLow"
+                    text: I18n.tr("Low Battery Notifications")
+                    description: I18n.tr("Show a warning popup when battery is running low.")
+                    checked: SettingsData.batteryNotifyLow
+                    onToggled: checked => SettingsData.set("batteryNotifyLow", checked)
+                }
+
+                SettingsButtonGroupRow {
+                    settingKey: "batteryNotificationType"
+                    text: I18n.tr("Notification Type")
+                    description: I18n.tr("Choose how to be notified about battery alerts.")
+                    model: [I18n.tr("Toast"), I18n.tr("Notification")]
+                    currentIndex: SettingsData.batteryNotificationType
+                    onSelectionChanged: (index, selected) => {
+                        if (selected) {
+                            SettingsData.set("batteryNotificationType", index);
+                        }
+                    }
+                }
+
+                SettingsToggleRow {
+                    settingKey: "batteryAutoPowerSaver"
+                    text: I18n.tr("Auto Power Saver")
+                    description: I18n.tr("Automatically turn on Power Saver profile when battery is low.")
+                    checked: SettingsData.batteryAutoPowerSaver
+                    onToggled: checked => SettingsData.set("batteryAutoPowerSaver", checked)
+                }
+
+                Rectangle {
+                    width: parent.width
+                    height: 1
+                    color: Theme.outline
+                    opacity: 0.15
+                }
+
+                StyledText {
+                    text: I18n.tr("Critical Battery Alert")
+                    font.pixelSize: Theme.fontSizeMedium
+                    font.weight: Font.DemiBold
+                    color: Theme.surfaceText
+                    topPadding: Theme.spacingM
+                }
+
+                SettingsSliderRow {
+                    settingKey: "batteryCriticalThreshold"
+                    text: I18n.tr("Critical Threshold")
+                    description: I18n.tr("Battery percentage to trigger a critical alert.")
+                    value: SettingsData.batteryCriticalThreshold
+                    minimum: 1
+                    maximum: 30
+                    defaultValue: 10
+                    onSliderValueChanged: newValue => SettingsData.set("batteryCriticalThreshold", newValue)
+                }
+
+                SettingsToggleRow {
+                    settingKey: "batteryNotifyCritical"
+                    text: I18n.tr("Critical Battery Notifications")
+                    description: I18n.tr("Show an urgent alert when battery reaches critical level.")
+                    checked: SettingsData.batteryNotifyCritical
+                    onToggled: checked => SettingsData.set("batteryNotifyCritical", checked)
+                }
+            }
+
+            // 3. Power Profiles Card
+            SettingsCard {
+                width: parent.width
+                iconName: "power"
+                title: I18n.tr("Power Profiles Auto-Switching")
+                settingKey: "powerProfilesAuto"
+
+                SettingsDropdownRow {
+                    settingKey: "acProfileName"
+                    text: I18n.tr("Profile when Plugged In (AC)")
+                    description: I18n.tr("Power profile to use when AC power is connected.")
+                    options: [I18n.tr("Don't Change"), Theme.getPowerProfileLabel(0), Theme.getPowerProfileLabel(1), Theme.getPowerProfileLabel(2)]
+                    currentValue: {
+                        const val = SettingsData.acProfileName;
+                        const idx = ["", "0", "1", "2"].indexOf(val);
+                        return idx >= 0 ? options[idx] : options[0];
+                    }
+                    onValueChanged: value => {
+                        const idx = options.indexOf(value);
+                        if (idx >= 0) {
+                            SettingsData.set("acProfileName", ["", "0", "1", "2"][idx]);
+                        }
+                    }
+                }
+
+                SettingsDropdownRow {
+                    settingKey: "batteryProfileName"
+                    text: I18n.tr("Profile when on Battery")
+                    description: I18n.tr("Power profile to use when running on battery power.")
+                    options: [I18n.tr("Don't Change"), Theme.getPowerProfileLabel(0), Theme.getPowerProfileLabel(1), Theme.getPowerProfileLabel(2)]
+                    currentValue: {
+                        const val = SettingsData.batteryProfileName;
+                        const idx = ["", "0", "1", "2"].indexOf(val);
+                        return idx >= 0 ? options[idx] : options[0];
+                    }
+                    onValueChanged: value => {
+                        const idx = options.indexOf(value);
+                        if (idx >= 0) {
+                            SettingsData.set("batteryProfileName", ["", "0", "1", "2"][idx]);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

quickshell/Modules/Settings/ClipboardTab.qml

@@ -152,8 +152,8 @@ Item {
         }
     ]
 
-    readonly property var entryActionKeys: ["pin", "edit", "delete"]
+    readonly property var entryActionKeys: ["copy", "paste", "pin", "edit", "delete"]
-    readonly property var entryActionLabels: [I18n.tr("Pin"), I18n.tr("Edit"), I18n.tr("Delete")]
+    readonly property var entryActionLabels: [I18n.tr("Copy"), I18n.tr("Paste"), I18n.tr("Pin"), I18n.tr("Edit"), I18n.tr("Delete")]
 
     function getMaxHistoryText(value) {
         if (value <= 0)
@@ -454,6 +454,16 @@ Item {
                     onToggled: checked => root.saveConfig("clearAtStartup", checked)
                 }
 
+                SettingsToggleRow {
+                    tab: "clipboard"
+                    tags: ["clipboard", "click", "paste", "behavior"]
+                    settingKey: "clipboardClickToPaste"
+                    text: I18n.tr("Click to Paste")
+                    description: I18n.tr("Click an entry to paste directly instead of copying", "Clipboard behavior setting description")
+                    checked: SettingsData.clipboardClickToPaste
+                    onToggled: checked => SettingsData.set("clipboardClickToPaste", checked)
+                }
+
                 SettingsToggleRow {
                     tab: "clipboard"
                     tags: ["clipboard", "enter", "paste", "behavior"]
@@ -464,9 +474,19 @@ Item {
                     onToggled: checked => SettingsData.set("clipboardEnterToPaste", checked)
                 }
 
+                SettingsToggleRow {
+                    tab: "clipboard"
+                    tags: ["clipboard", "filter", "type", "remember", "behavior"]
+                    settingKey: "clipboardRememberTypeFilter"
+                    text: I18n.tr("Remember Type Filter", "Clipboard behavior setting title")
+                    description: I18n.tr("Keep the clipboard type filter when reopening history", "Clipboard behavior setting description")
+                    checked: SettingsData.clipboardRememberTypeFilter
+                    onToggled: checked => SettingsData.set("clipboardRememberTypeFilter", checked)
+                }
+
                 SettingsButtonGroupRow {
                     tab: "clipboard"
-                    tags: ["clipboard", "actions", "buttons", "hide", "density", "pin", "edit", "delete"]
+                    tags: ["clipboard", "actions", "buttons", "hide", "density", "copy", "paste", "pin", "edit", "delete"]
                     settingKey: "clipboardVisibleEntryActions"
                     text: I18n.tr("Visible Entry Actions")
                     description: I18n.tr("Choose which action buttons appear on clipboard entries")

quickshell/Modules/Settings/ColorDropdownRow.qml

@@ -0,0 +1,183 @@
+pragma ComponentBehavior: Bound
+
+import QtQuick
+import qs.Common
+import qs.Services
+import qs.Widgets
+import qs.Modules.Settings.Widgets
+
+Column {
+    id: root
+
+    property string text: ""
+    property string description: ""
+    property string settingKey: ""
+    property string tab: ""
+    property var tags: []
+    property var options: []
+    property string currentMode: "default"
+    property color customColor: "#6750A4"
+    property string pickerTitle: text
+    property int dropdownWidth: 230
+    property color defaultColor: Theme.primary
+
+    readonly property var optionColorMap: {
+        var map = {};
+        for (var i = 0; i < options.length; i++)
+            map[options[i].label] = root.colorForValue(options[i].value);
+        return map;
+    }
+
+    function colorForValue(value) {
+        switch (value) {
+        case "custom":
+            return root.customColor;
+        case "none":
+            return "transparent";
+        case "default":
+            return root.defaultColor;
+        default:
+            return Theme.roleColor(value);
+        }
+    }
+
+    signal modeSelected(string mode)
+    signal customColorSelected(color selectedColor)
+
+    width: parent?.width ?? 0
+    spacing: Theme.spacingS
+
+    function optionLabels() {
+        return options.map(option => option.label);
+    }
+
+    function optionLabel(value) {
+        for (var i = 0; i < options.length; i++) {
+            if (options[i].value === value)
+                return options[i].label;
+        }
+        return options.length > 0 ? options[0].label : "";
+    }
+
+    function optionValue(label) {
+        for (var i = 0; i < options.length; i++) {
+            if (options[i].label === label)
+                return options[i].value;
+        }
+        return options.length > 0 ? options[0].value : "default";
+    }
+
+    function openCustomColorPicker() {
+        PopoutService.colorPickerModal.selectedColor = root.customColor;
+        PopoutService.colorPickerModal.pickerTitle = root.pickerTitle;
+        PopoutService.colorPickerModal.onColorSelectedCallback = function (selectedColor) {
+            root.customColorSelected(selectedColor);
+            root.modeSelected("custom");
+        };
+        PopoutService.colorPickerModal.show();
+    }
+
+    SettingsDropdownRow {
+        text: root.text
+        description: root.description
+        tab: root.tab
+        settingKey: root.settingKey
+        tags: root.tags
+        options: root.optionLabels()
+        optionColorMap: root.optionColorMap
+        currentValue: root.optionLabel(root.currentMode)
+        dropdownWidth: root.dropdownWidth
+        onValueChanged: value => root.modeSelected(root.optionValue(value))
+    }
+
+    Item {
+        width: parent.width
+        height: root.currentMode === "custom" ? customChip.height : 0
+        opacity: root.currentMode === "custom" ? 1 : 0
+        clip: true
+
+        Behavior on height {
+            NumberAnimation {
+                duration: Theme.mediumDuration
+                easing.type: Theme.emphasizedEasing
+            }
+        }
+
+        Behavior on opacity {
+            NumberAnimation {
+                duration: Theme.mediumDuration
+                easing.type: Theme.emphasizedEasing
+            }
+        }
+
+        Rectangle {
+            id: customChip
+
+            width: parent.width
+            height: 56
+            radius: Theme.cornerRadius
+            color: Theme.surfaceContainerHigh
+
+            Row {
+                anchors.fill: parent
+                anchors.leftMargin: Theme.spacingM
+                anchors.rightMargin: Theme.spacingM
+                spacing: Theme.spacingM
+
+                Rectangle {
+                    width: 36
+                    height: 36
+                    radius: 18
+                    color: root.customColor
+                    border.color: Theme.outline
+                    border.width: 1
+                    anchors.verticalCenter: parent.verticalCenter
+
+                    DankIcon {
+                        anchors.centerIn: parent
+                        name: "colorize"
+                        size: 16
+                        color: (root.customColor.r * 0.299 + root.customColor.g * 0.587 + root.customColor.b * 0.114) > 0.5 ? "#000000" : "#ffffff"
+                    }
+                }
+
+                Column {
+                    width: parent.width - 36 - editIcon.width - Theme.spacingM * 2
+                    anchors.verticalCenter: parent.verticalCenter
+                    spacing: Theme.spacingXS
+
+                    StyledText {
+                        text: I18n.tr("Custom Color")
+                        font.pixelSize: Theme.fontSizeMedium
+                        font.weight: Font.Medium
+                        color: Theme.surfaceText
+                        width: parent.width
+                        horizontalAlignment: Text.AlignLeft
+                    }
+
+                    StyledText {
+                        text: root.customColor.toString()
+                        font.pixelSize: Theme.fontSizeSmall
+                        color: Theme.surfaceVariantText
+                        width: parent.width
+                        elide: Text.ElideRight
+                        horizontalAlignment: Text.AlignLeft
+                    }
+                }
+
+                DankIcon {
+                    id: editIcon
+                    name: "edit"
+                    size: Theme.iconSizeSmall
+                    color: Theme.surfaceVariantText
+                    anchors.verticalCenter: parent.verticalCenter
+                }
+            }
+
+            StateLayer {
+                stateColor: Theme.surfaceText
+                onClicked: root.openCustomColorPicker()
+            }
+        }
+    }
+}

quickshell/Modules/Settings/DankBarTab.qml

@@ -858,13 +858,6 @@ Item {
                 }
             }
 
-            SettingsControlledByFrame {
-                visible: dankBarTab.appearanceOnly && SettingsData.frameEnabled
-                parentModal: dankBarTab.parentModal
-                settingLabel: I18n.tr("Bar spacing and size")
-                reason: I18n.tr("Managed by Frame")
-            }
-
             SettingsCard {
                 tab: "appearance"
                 iconName: "space_bar"

quickshell/Modules/Settings/LauncherTab.qml

@@ -671,6 +671,15 @@ Item {
                     onToggled: checked => SettingsData.set("dankLauncherV2UnloadOnClose", checked)
                 }
 
+                 SettingsToggleRow {
+                    settingKey: "dankLauncherV2ShowSourceBadges"
+                    tags: ["launcher", "appearance", "badge", "source", "flatpak"]
+                    text: I18n.tr("Show Package Source Badges")
+                    description: I18n.tr("Show Flatpak, Snap, AppImage, or Nix badge icons on launcher items.")
+                    checked: SettingsData.dankLauncherV2ShowSourceBadges
+                    onToggled: checked => SettingsData.set("dankLauncherV2ShowSourceBadges", checked)
+                }
+
                 SettingsToggleRow {
                     settingKey: "dankLauncherV2BorderEnabled"
                     tags: ["launcher", "border", "outline"]
@@ -769,7 +778,7 @@ Item {
                     spacing: Theme.spacingS
 
                     Repeater {
-                        model: ["dms_settings", "dms_notepad", "dms_sysmon", "dms_settings_search", "dms_clipboard_search"]
+                        model: ["dms_settings", "dms_notepad", "dms_sysmon", "dms_settings_search", "dms_clipboard_search", "dms_colorpicker"]
 
                         delegate: Rectangle {
                             id: pluginDelegate

quickshell/Modules/Settings/NetworkWifiTab.qml

@@ -1,8 +1,10 @@
 pragma ComponentBehavior: Bound
 
 import QtQuick
+import QtQuick.Controls
 import QtQuick.Layouts
 import qs.Common
+import qs.Modules.Network
 import qs.Modules.Settings.Widgets
 import qs.Modals.Common
 import qs.Services
@@ -16,6 +18,7 @@ Item {
 
     Component.onCompleted: {
         NetworkService.addRef();
+        Qt.callLater(() => NetworkService.refreshSavedWifiNetworks());
     }
 
     Component.onDestruction: {
@@ -40,6 +43,7 @@ Item {
                 id: root
 
                 property string expandedWifiSsid: ""
+                property string expandedSavedWifiSsid: ""
                 property int maxPinnedWifiNetworks: 3
 
                 function normalizePinList(value) {
@@ -84,6 +88,79 @@ Item {
                 settingKey: "networkWifi"
                 tags: ["wifi", "wi-fi", "wireless", "network", "ssid", "adapter", "radio"]
 
+                function visibleWifiBySsid(ssid) {
+                    const networks = NetworkService.wifiNetworks || [];
+                    return networks.find(network => network.ssid === ssid) || null;
+                }
+
+                function mergedSavedWifiNetworks() {
+                    const saved = NetworkService.savedWifiNetworks || [];
+                    const supportsSavedWifiState = DMSService.apiVersion >= NetworkService.savedWifiStateApiVersion;
+                    const result = [];
+                    const seen = new Set();
+
+                    for (const network of saved) {
+                        if (!network?.ssid || seen.has(network.ssid))
+                            continue;
+                        const isOutOfRange = supportsSavedWifiState ? network.outOfRange === true : false;
+                        const visibleNetwork = !isOutOfRange ? visibleWifiBySsid(network.ssid) : null;
+                        if (visibleNetwork) {
+                            result.push(Object.assign({}, network, visibleNetwork, {
+                                saved: true,
+                                autoconnect: network.autoconnect ?? visibleNetwork.autoconnect,
+                                hidden: (network.hidden || false) || (visibleNetwork.hidden || false),
+                                outOfRange: false
+                            }));
+                        } else {
+                            result.push(Object.assign({}, network, {
+                                saved: true,
+                                outOfRange: isOutOfRange
+                            }));
+                        }
+                        seen.add(network.ssid);
+                    }
+
+                    return result;
+                }
+
+                function sortedSavedWifiNetworks() {
+                    const ssid = NetworkService.currentWifiSSID;
+                    const pinnedList = root.getPinnedWifiNetworks();
+                    let sorted = root.mergedSavedWifiNetworks();
+
+                    sorted.sort((a, b) => {
+                        const aPinnedIndex = pinnedList.indexOf(a.ssid);
+                        const bPinnedIndex = pinnedList.indexOf(b.ssid);
+                        if (aPinnedIndex !== -1 || bPinnedIndex !== -1) {
+                            if (aPinnedIndex === -1)
+                                return 1;
+                            if (bPinnedIndex === -1)
+                                return -1;
+                            return aPinnedIndex - bPinnedIndex;
+                        }
+                        if (a.ssid === ssid)
+                            return -1;
+                        if (b.ssid === ssid)
+                            return 1;
+                        if ((a.outOfRange || false) !== (b.outOfRange || false))
+                            return (a.outOfRange || false) ? 1 : -1;
+                        if ((a.signal || 0) !== (b.signal || 0))
+                            return (b.signal || 0) - (a.signal || 0);
+                        return (a.ssid || "").localeCompare(b.ssid || "");
+                    });
+                    return sorted;
+                }
+
+                function showForgetNetworkConfirm(ssid) {
+                    forgetNetworkConfirm.showWithOptions({
+                        title: I18n.tr("Forget Network"),
+                        message: I18n.tr("Forget \"%1\"?").arg(ssid),
+                        confirmText: I18n.tr("Forget"),
+                        confirmColor: Theme.error,
+                        onConfirm: () => NetworkService.forgetWifiNetwork(ssid)
+                    });
+                }
+
                 Column {
                     id: wifiSection
 
@@ -563,7 +640,7 @@ Item {
                                                 DankActionButton {
                                                     iconName: "qr_code"
                                                     buttonSize: 28
-                                                    visible: modelData.secured && modelData.saved
+                                                    visible: modelData.secured && modelData.saved && !(modelData.enterprise || false)
                                                     onClicked: {
                                                         PopoutService.showWifiQRCodeModal(modelData.ssid);
                                                     }
@@ -584,13 +661,7 @@ Item {
                                                     iconColor: Theme.error
                                                     visible: modelData.saved || isConnected
                                                     onClicked: {
-                                                        forgetNetworkConfirm.showWithOptions({
+                                                        root.showForgetNetworkConfirm(modelData.ssid);
-                                                            title: I18n.tr("Forget Network"),
-                                                            message: I18n.tr("Forget \"%1\"?").arg(modelData.ssid),
-                                                            confirmText: I18n.tr("Forget"),
-                                                            confirmColor: Theme.error,
-                                                            onConfirm: () => NetworkService.forgetWifiNetwork(modelData.ssid)
-                                                        });
                                                     }
                                                 }
                                             }
@@ -603,15 +674,10 @@ Item {
                                                 hoverEnabled: true
                                                 cursorShape: Qt.PointingHandCursor
                                                 onClicked: {
-                                                    if (isConnected) {
+                                                    WifiConnectionActions.connectToNetwork(modelData, {
-                                                        NetworkService.disconnectWifi();
+                                                        connected: isConnected,
-                                                        return;
+                                                        disconnectWhenConnected: true
-                                                    }
+                                                    });
-                                                    if (modelData.secured && !modelData.saved && (DMSService.apiVersion < 7 || modelData.enterprise)) {
-                                                        PopoutService.showWifiPasswordModal(modelData.ssid);
-                                                        return;
-                                                    }
-                                                    NetworkService.connectToWifi(modelData.ssid);
                                                 }
                                             }
                                         }
@@ -756,6 +822,420 @@ Item {
                     }
                 }
             }
+            SettingsCard {
+                id: savedWifiCard
+
+                readonly property var savedNetworks: root.sortedSavedWifiNetworks()
+
+                width: parent.width
+                title: I18n.tr("Saved Networks")
+                iconName: "bookmark"
+                settingKey: "networkSavedWifi"
+                tags: ["wifi", "wi-fi", "wireless", "network", "saved", "known", "ssid", "autoconnect", "forget"]
+                collapsible: true
+                expanded: false
+                visible: savedNetworks.length > 0
+
+                headerActions: [
+                    StyledText {
+                        text: savedWifiCard.savedNetworks.length
+                        font.pixelSize: Theme.fontSizeSmall
+                        color: Theme.surfaceVariantText
+                        verticalAlignment: Text.AlignVCenter
+                    }
+                ]
+
+                Column {
+                    width: parent.width
+                    spacing: 4
+
+                    Repeater {
+                        model: savedWifiCard.expanded ? savedWifiCard.savedNetworks : []
+
+                        delegate: Rectangle {
+                            id: savedWifiDelegate
+
+                            required property var modelData
+                            required property int index
+
+                            readonly property bool isConnected: modelData.ssid === NetworkService.currentWifiSSID
+                            readonly property bool isPinned: root.getPinnedWifiNetworks().includes(modelData.ssid)
+                            readonly property bool isOutOfRange: modelData.outOfRange || false
+                            readonly property bool isExpanded: !isOutOfRange && root.expandedSavedWifiSsid === modelData.ssid
+
+                            width: parent.width
+                            height: isExpanded ? 56 + savedWifiExpandedContent.height : 56
+                            radius: Theme.cornerRadius
+                            color: savedWifiMouseArea.containsMouse ? Theme.primaryHoverLight : Theme.surfaceLight
+                            border.width: isConnected ? 2 : 0
+                            border.color: Theme.primary
+                            clip: true
+
+                            Behavior on height {
+                                NumberAnimation {
+                                    duration: 150
+                                    easing.type: Easing.OutQuad
+                                }
+                            }
+
+                            Column {
+                                anchors.fill: parent
+                                spacing: 0
+
+                                Item {
+                                    width: parent.width
+                                    height: 56
+
+                                    Row {
+                                        anchors.left: parent.left
+                                        anchors.leftMargin: Theme.spacingM
+                                        anchors.verticalCenter: parent.verticalCenter
+                                        anchors.right: savedWifiActions.left
+                                        anchors.rightMargin: Theme.spacingS
+                                        spacing: Theme.spacingS
+
+                                        DankIcon {
+                                            name: {
+                                                if (isOutOfRange)
+                                                    return "wifi_off";
+                                                const s = modelData.signal || 0;
+                                                if (s >= 50)
+                                                    return "wifi";
+                                                if (s >= 25)
+                                                    return "wifi_2_bar";
+                                                return "wifi_1_bar";
+                                            }
+                                            size: 20
+                                            color: isConnected ? Theme.primary : Theme.surfaceText
+                                            anchors.verticalCenter: parent.verticalCenter
+                                        }
+
+                                        Column {
+                                            anchors.verticalCenter: parent.verticalCenter
+                                            spacing: 2
+                                            width: parent.width - 20 - Theme.spacingS
+
+                                            Row {
+                                                anchors.left: parent.left
+                                                spacing: Theme.spacingXS
+                                                width: parent.width
+
+                                                StyledText {
+                                                    text: modelData.ssid || I18n.tr("Unknown")
+                                                    font.pixelSize: Theme.fontSizeMedium
+                                                    color: isConnected ? Theme.primary : Theme.surfaceText
+                                                    font.weight: isConnected ? Font.Medium : Font.Normal
+                                                    elide: Text.ElideRight
+                                                    width: Math.max(0, parent.width - (savedWifiHiddenIcon.visible ? savedWifiHiddenIcon.width + Theme.spacingXS : 0))
+                                                }
+
+                                                DankIcon {
+                                                    id: savedWifiHiddenIcon
+                                                    name: "visibility_off"
+                                                    size: 14
+                                                    color: Theme.surfaceVariantText
+                                                    visible: modelData.hidden || false
+                                                    anchors.verticalCenter: parent.verticalCenter
+                                                }
+                                            }
+
+                                            StyledText {
+                                                text: {
+                                                    const parts = [isConnected ? I18n.tr("Connected") : (modelData.secured ? I18n.tr("Secured") : I18n.tr("Open"))];
+                                                    parts.push(isOutOfRange ? I18n.tr("Unavailable") : (modelData.signal || 0) + "%");
+                                                    if (modelData.hidden || false)
+                                                        parts.push(I18n.tr("Hidden"));
+                                                    return parts.join(" • ");
+                                                }
+                                                font.pixelSize: Theme.fontSizeSmall
+                                                color: isConnected ? Theme.primary : Theme.surfaceVariantText
+                                                width: parent.width
+                                                elide: Text.ElideRight
+                                            }
+                                        }
+                                    }
+
+                                    Row {
+                                        id: savedWifiActions
+                                        anchors.right: parent.right
+                                        anchors.rightMargin: Theme.spacingS
+                                        anchors.verticalCenter: parent.verticalCenter
+                                        spacing: Theme.spacingXS
+
+                                        Rectangle {
+                                            width: 28
+                                            height: 28
+                                            radius: 14
+                                            color: savedWifiExpandBtn.containsMouse ? Theme.surfacePressed : "transparent"
+                                            visible: !isOutOfRange
+
+                                            DankIcon {
+                                                anchors.centerIn: parent
+                                                name: isExpanded ? "expand_less" : "expand_more"
+                                                size: 18
+                                                color: Theme.surfaceText
+                                            }
+
+                                            MouseArea {
+                                                id: savedWifiExpandBtn
+                                                anchors.fill: parent
+                                                hoverEnabled: true
+                                                cursorShape: Qt.PointingHandCursor
+                                                onClicked: {
+                                                    if (isExpanded) {
+                                                        root.expandedSavedWifiSsid = "";
+                                                    } else {
+                                                        root.expandedSavedWifiSsid = modelData.ssid;
+                                                    }
+                                                }
+                                            }
+                                        }
+
+                                        DankActionButton {
+                                            iconName: "qr_code"
+                                            buttonSize: 28
+                                            visible: modelData.secured && !(modelData.enterprise || false)
+                                            onClicked: {
+                                                PopoutService.showWifiQRCodeModal(modelData.ssid);
+                                            }
+                                        }
+
+                                        DankActionButton {
+                                            iconName: "push_pin"
+                                            buttonSize: 28
+                                            iconColor: isPinned ? Theme.primary : Theme.surfaceVariantText
+                                            onClicked: {
+                                                root.toggleWifiPin(modelData.ssid);
+                                            }
+                                        }
+
+                                        DankActionButton {
+                                            id: savedWifiMoreButton
+                                            iconName: "more_horiz"
+                                            buttonSize: 28
+                                            onClicked: {
+                                                if (savedWifiMenu.visible) {
+                                                    savedWifiMenu.close();
+                                                    return;
+                                                }
+                                                savedWifiMenu.popup(savedWifiMoreButton, -savedWifiMenu.width + savedWifiMoreButton.width, savedWifiMoreButton.height + Theme.spacingXS);
+                                            }
+                                        }
+                                    }
+
+                                    MouseArea {
+                                        id: savedWifiMouseArea
+                                        anchors.fill: parent
+                                        anchors.rightMargin: savedWifiActions.width + Theme.spacingM
+                                        hoverEnabled: true
+                                        cursorShape: isOutOfRange ? Qt.ArrowCursor : Qt.PointingHandCursor
+                                        onClicked: {
+                                            if (isOutOfRange)
+                                                return;
+                                            if (isExpanded) {
+                                                root.expandedSavedWifiSsid = "";
+                                            } else {
+                                                root.expandedSavedWifiSsid = modelData.ssid;
+                                            }
+                                        }
+                                    }
+                                }
+
+                                Column {
+                                    id: savedWifiExpandedContent
+                                    width: parent.width
+                                    visible: isExpanded
+
+                                    Rectangle {
+                                        width: parent.width - Theme.spacingM * 2
+                                        height: 1
+                                        x: Theme.spacingM
+                                        color: Theme.outlineLight
+                                    }
+
+                                    Item {
+                                        width: parent.width
+                                        height: savedWifiDetailsColumn.implicitHeight + Theme.spacingM * 2
+
+                                        Column {
+                                            id: savedWifiDetailsColumn
+                                            anchors.fill: parent
+                                            anchors.margins: Theme.spacingM
+                                            spacing: Theme.spacingS
+
+                                            Flow {
+                                                width: parent.width
+                                                spacing: Theme.spacingXS
+
+                                                Repeater {
+                                                    model: {
+                                                        const fields = [];
+                                                        const net = modelData;
+                                                        if (!net)
+                                                            return fields;
+
+                                                        fields.push({
+                                                            label: I18n.tr("Signal"),
+                                                            value: (net.signal || 0) + "%"
+                                                        });
+                                                        if (net.frequency)
+                                                            fields.push({
+                                                                label: I18n.tr("Frequency"),
+                                                                value: (net.frequency / 1000).toFixed(1) + " GHz"
+                                                            });
+                                                        if (net.channel)
+                                                            fields.push({
+                                                                label: I18n.tr("Channel"),
+                                                                value: String(net.channel)
+                                                            });
+                                                        if (net.rate)
+                                                            fields.push({
+                                                                label: I18n.tr("Rate"),
+                                                                value: net.rate + " Mbps"
+                                                            });
+                                                        if (net.mode)
+                                                            fields.push({
+                                                                label: I18n.tr("Mode"),
+                                                                value: net.mode
+                                                            });
+                                                        if (net.bssid)
+                                                            fields.push({
+                                                                label: I18n.tr("BSSID"),
+                                                                value: net.bssid
+                                                            });
+                                                        fields.push({
+                                                            label: I18n.tr("Security"),
+                                                            value: net.secured ? (net.enterprise ? I18n.tr("Enterprise") : I18n.tr("WPA/WPA2")) : I18n.tr("Open")
+                                                        });
+
+                                                        return fields;
+                                                    }
+
+                                                    delegate: Rectangle {
+                                                        required property var modelData
+                                                        required property int index
+
+                                                        width: savedWifiFieldContent.width + Theme.spacingM * 2
+                                                        height: 32
+                                                        radius: Theme.cornerRadius - 2
+                                                        color: Theme.surfaceContainerHigh
+                                                        border.width: 1
+                                                        border.color: Theme.outlineLight
+
+                                                        Row {
+                                                            id: savedWifiFieldContent
+                                                            anchors.centerIn: parent
+                                                            spacing: Theme.spacingXS
+
+                                                            StyledText {
+                                                                text: modelData.label + ":"
+                                                                font.pixelSize: Theme.fontSizeSmall
+                                                                color: Theme.surfaceVariantText
+                                                                anchors.verticalCenter: parent.verticalCenter
+                                                            }
+
+                                                            StyledText {
+                                                                text: modelData.value
+                                                                font.pixelSize: Theme.fontSizeSmall
+                                                                color: Theme.surfaceText
+                                                                font.weight: Font.Medium
+                                                                anchors.verticalCenter: parent.verticalCenter
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+
+                            Menu {
+                                id: savedWifiMenu
+                                width: 170
+                                closePolicy: Popup.CloseOnEscape | Popup.CloseOnPressOutsideParent
+
+                                background: Rectangle {
+                                    color: Theme.withAlpha(Theme.surfaceContainer, Theme.popupTransparency)
+                                    radius: Theme.cornerRadius
+                                    border.width: 0
+                                }
+
+                                MenuItem {
+                                    text: isConnected ? I18n.tr("Disconnect") : I18n.tr("Connect")
+                                    height: isOutOfRange ? 0 : 32
+                                    visible: !isOutOfRange
+
+                                    contentItem: StyledText {
+                                        text: parent.text
+                                        font.pixelSize: Theme.fontSizeSmall
+                                        color: Theme.surfaceText
+                                        leftPadding: Theme.spacingS
+                                        verticalAlignment: Text.AlignVCenter
+                                    }
+
+                                    background: Rectangle {
+                                        color: parent.hovered ? Qt.rgba(Theme.primary.r, Theme.primary.g, Theme.primary.b, 0.08) : "transparent"
+                                        radius: Theme.cornerRadius / 2
+                                    }
+
+                                    onTriggered: {
+                                        WifiConnectionActions.connectToNetwork(modelData, {
+                                            connected: isConnected,
+                                            disconnectWhenConnected: true
+                                        });
+                                    }
+                                }
+
+                                MenuItem {
+                                    text: modelData.autoconnect ? I18n.tr("Disable Autoconnect") : I18n.tr("Enable Autoconnect")
+                                    height: DMSService.apiVersion > 13 ? 32 : 0
+                                    visible: DMSService.apiVersion > 13
+
+                                    contentItem: StyledText {
+                                        text: parent.text
+                                        font.pixelSize: Theme.fontSizeSmall
+                                        color: Theme.surfaceText
+                                        leftPadding: Theme.spacingS
+                                        verticalAlignment: Text.AlignVCenter
+                                    }
+
+                                    background: Rectangle {
+                                        color: parent.hovered ? Qt.rgba(Theme.primary.r, Theme.primary.g, Theme.primary.b, 0.08) : "transparent"
+                                        radius: Theme.cornerRadius / 2
+                                    }
+
+                                    onTriggered: {
+                                        NetworkService.setWifiAutoconnect(modelData.ssid, !(modelData.autoconnect || false));
+                                    }
+                                }
+
+                                MenuItem {
+                                    text: I18n.tr("Forget Network")
+                                    height: 32
+
+                                    contentItem: StyledText {
+                                        text: parent.text
+                                        font.pixelSize: Theme.fontSizeSmall
+                                        color: Theme.error
+                                        leftPadding: Theme.spacingS
+                                        verticalAlignment: Text.AlignVCenter
+                                    }
+
+                                    background: Rectangle {
+                                        color: parent.hovered ? Qt.rgba(Theme.error.r, Theme.error.g, Theme.error.b, 0.08) : "transparent"
+                                        radius: Theme.cornerRadius / 2
+                                    }
+
+                                    onTriggered: {
+                                        root.showForgetNetworkConfirm(modelData.ssid);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
 }

quickshell/Modules/Settings/PowerSleepTab.qml

@@ -603,26 +603,6 @@ Item {
                 }
             }
 
-            SettingsCard {
-                width: parent.width
-                iconName: "tune"
-                title: I18n.tr("Advanced")
-                settingKey: "powerAdvanced"
-                collapsible: true
-                expanded: false
-
-                SettingsSliderRow {
-                    settingKey: "batteryChargeLimit"
-                    tags: ["battery", "charge", "limit", "percentage", "power"]
-                    text: I18n.tr("Battery Charge Limit")
-                    description: I18n.tr("Note: this only changes the percentage, it does not actually limit charging.")
-                    value: SettingsData.batteryChargeLimit
-                    minimum: 50
-                    maximum: 100
-                    defaultValue: 100
-                    onSliderValueChanged: newValue => SettingsData.set("batteryChargeLimit", newValue)
-                }
-            }
         }
     }
 }

quickshell/Modules/Settings/SoundsTab.qml

@@ -131,6 +131,23 @@ Item {
                         checked: SettingsData.soundPluggedIn
                         onToggled: checked => SettingsData.set("soundPluggedIn", checked)
                     }
+
+                    Rectangle {
+                        width: parent.width
+                        height: 1
+                        color: Theme.outline
+                        opacity: 0.2
+                    }
+
+                    SettingsToggleRow {
+                        tab: "sounds"
+                        tags: ["sound", "media", "playback", "mute", "mpris", "music"]
+                        settingKey: "muteSoundsWhenMediaPlaying"
+                        text: I18n.tr("Mute During Playback")
+                        description: I18n.tr("Silence system sounds while media is playing")
+                        checked: SettingsData.muteSoundsWhenMediaPlaying
+                        onToggled: checked => SettingsData.set("muteSoundsWhenMediaPlaying", checked)
+                    }
                 }
             }
 

quickshell/Modules/Settings/ThemeColorsTab.qml

@@ -20,6 +20,31 @@ Item {
     property var cachedMatugenSchemes: Theme.availableMatugenSchemes.map(option => option.label)
     property var installedRegistryThemes: []
     property var templateDetection: []
+    readonly property var widgetBackgroundOptions: [({
+                "value": "sth",
+                "label": I18n.tr("Subtle Overlay", "widget background color option")
+            }), ({
+                "value": "s",
+                "label": I18n.tr("Surface", "widget background color option")
+            }), ({
+                "value": "sc",
+                "label": I18n.tr("Surface Container", "widget background color option")
+            }), ({
+                "value": "sch",
+                "label": I18n.tr("Surface High", "widget background color option")
+            }), ({
+                "value": "primaryContainer",
+                "label": I18n.tr("Primary Container", "widget background color option")
+            }), ({
+                "value": "secondaryContainer",
+                "label": I18n.tr("Secondary Container", "widget background color option")
+            }), ({
+                "value": "tertiaryContainer",
+                "label": I18n.tr("Tertiary Container", "widget background color option")
+            }), ({
+                "value": "custom",
+                "label": I18n.tr("Custom", "widget background color option")
+            })]
 
     property var cursorIncludeStatus: ({
             "exists": false,
@@ -166,6 +191,12 @@ Item {
         PopoutService.colorPickerModal.show();
     }
 
+    function warnIfMissingQtTheme() {
+        if (Quickshell.env("QT_QPA_PLATFORMTHEME") === "gtk3" || Quickshell.env("QT_QPA_PLATFORMTHEME") === "qt6ct" || Quickshell.env("QT_QPA_PLATFORMTHEME_QT6") === "qt6ct")
+            return;
+        ToastService.showError(I18n.tr("Missing Environment Variables", "qt theme env error title"), I18n.tr("You need to set either:\nQT_QPA_PLATFORMTHEME=gtk3 OR\nQT_QPA_PLATFORMTHEME=qt6ct\nas environment variables, and then restart the shell.\n\nqt6ct requires qt6ct-kde to be installed.", "qt theme env error body"));
+    }
+
     function formatThemeAutoTime(isoString) {
         if (!isoString)
             return "";
@@ -1524,10 +1555,10 @@ Item {
 
                 SettingsButtonGroupRow {
                     tab: "theme"
-                    tags: ["widget", "style", "colorful", "default"]
+                    tags: ["widget", "text", "style", "colorful", "default"]
                     settingKey: "widgetColorMode"
-                    text: I18n.tr("Widget Style")
+                    text: I18n.tr("Widget Text Style")
-                    description: I18n.tr("Change bar appearance")
+                    description: I18n.tr("Choose neutral or accent-colored widget text")
                     model: [I18n.tr("Default", "widget style option"), I18n.tr("Colorful", "widget style option")]
                     currentIndex: SettingsData.widgetColorMode === "colorful" ? 1 : 0
                     onSelectionChanged: (index, selected) => {
@@ -1537,38 +1568,41 @@ Item {
                     }
                 }
 
-                SettingsButtonGroupRow {
+                ColorDropdownRow {
                     tab: "theme"
-                    tags: ["widget", "background", "color"]
+                    tags: ["widget", "background", "color", "surface", "material"]
                     settingKey: "widgetBackgroundColor"
                     text: I18n.tr("Widget Background Color")
                     description: I18n.tr("Choose the background color for widgets")
-                    model: ["sth", "s", "sc", "sch"]
+                    dropdownWidth: 220
-                    buttonHeight: 20
+                    options: themeColorsTab.widgetBackgroundOptions
-                    minButtonWidth: 32
+                    currentMode: SettingsData.widgetBackgroundColor
-                    buttonPadding: Theme.spacingS
+                    customColor: SettingsData.widgetBackgroundCustomColor || "#6750A4"
-                    checkIconSize: Theme.iconSizeSmall - 2
+                    pickerTitle: I18n.tr("Widget Background Color")
-                    textSize: Theme.fontSizeSmall - 2
+                    onModeSelected: mode => SettingsData.set("widgetBackgroundColor", mode)
-                    spacing: 1
+                    onCustomColorSelected: selectedColor => SettingsData.set("widgetBackgroundCustomColor", selectedColor.toString())
-                    currentIndex: {
+                }
-                        switch (SettingsData.widgetBackgroundColor) {
+
-                        case "sth":
+                SettingsSliderRow {
-                            return 0;
+                    id: widgetBackgroundCustomStrengthSlider
-                        case "s":
+                    visible: SettingsData.widgetBackgroundColor === "custom"
-                            return 1;
+                    tab: "theme"
-                        case "sc":
+                    tags: ["widget", "background", "color", "custom", "blend"]
-                            return 2;
+                    settingKey: "widgetBackgroundCustomStrength"
-                        case "sch":
+                    text: I18n.tr("Custom Blend")
-                            return 3;
+                    description: I18n.tr("Blend between Surface High and the selected custom color")
-                        default:
+                    value: Math.round(SettingsData.widgetBackgroundCustomStrength * 100)
-                            return 0;
+                    minimum: 0
-                        }
+                    maximum: 100
-                    }
+                    unit: "%"
-                    onSelectionChanged: (index, selected) => {
+                    defaultValue: 40
-                        if (!selected)
+                    onSliderValueChanged: newValue => SettingsData.set("widgetBackgroundCustomStrength", newValue / 100)
-                            return;
+
-                        const colorOptions = ["sth", "s", "sc", "sch"];
+                    Binding {
-                        SettingsData.set("widgetBackgroundColor", colorOptions[index]);
+                        target: widgetBackgroundCustomStrengthSlider
+                        property: "value"
+                        value: Math.round(SettingsData.widgetBackgroundCustomStrength * 100)
+                        restoreMode: Binding.RestoreBinding
                     }
                 }
 
@@ -1579,6 +1613,12 @@ Item {
                     text: I18n.tr("Control Center Tile Color")
                     description: I18n.tr("Active tile background and icon color", "control center tile color setting description")
                     options: [I18n.tr("Primary", "tile color option"), I18n.tr("Primary Container", "tile color option"), I18n.tr("Secondary", "tile color option"), I18n.tr("Surface Variant", "tile color option")]
+                    optionColorMap: ({
+                            [I18n.tr("Primary", "tile color option")]: Theme.roleColor("primary"),
+                            [I18n.tr("Primary Container", "tile color option")]: Theme.roleColor("primaryContainer"),
+                            [I18n.tr("Secondary", "tile color option")]: Theme.roleColor("secondary"),
+                            [I18n.tr("Surface Variant", "tile color option")]: Theme.roleColor("surfaceVariant")
+                        })
                     currentValue: {
                         switch (SettingsData.controlCenterTileColorMode) {
                         case "primaryContainer":
@@ -1611,6 +1651,12 @@ Item {
                     text: I18n.tr("Button Color")
                     description: I18n.tr("Color for primary action buttons")
                     options: [I18n.tr("Primary", "button color option"), I18n.tr("Primary Container", "button color option"), I18n.tr("Secondary", "button color option"), I18n.tr("Surface Variant", "button color option")]
+                    optionColorMap: ({
+                            [I18n.tr("Primary", "button color option")]: Theme.roleColor("primary"),
+                            [I18n.tr("Primary Container", "button color option")]: Theme.roleColor("primaryContainer"),
+                            [I18n.tr("Secondary", "button color option")]: Theme.roleColor("secondary"),
+                            [I18n.tr("Surface Variant", "button color option")]: Theme.roleColor("surfaceVariant")
+                        })
                     currentValue: {
                         switch (SettingsData.buttonColorMode) {
                         case "primaryContainer":
@@ -2224,22 +2270,67 @@ Item {
                 settingKey: "iconTheme"
                 iconName: "interests"
 
+                SettingsToggleRow {
+                    tab: "theme"
+                    tags: ["icon", "theme", "light", "dark", "mode"]
+                    settingKey: "iconThemePerMode"
+                    text: I18n.tr("Separate Light & Dark Themes")
+                    description: I18n.tr("Use different icon themes for light and dark mode")
+                    checked: SettingsData.iconThemePerMode
+                    onToggled: checked => SettingsData.setIconThemePerMode(checked)
+                }
+
                 SettingsDropdownRow {
                     tab: "theme"
                     tags: ["icon", "theme", "system"]
                     settingKey: "iconTheme"
                     text: I18n.tr("Icon Theme")
                     description: I18n.tr("DankShell & System Icons (requires restart)")
-                    currentValue: SettingsData.iconTheme
+                    visible: !SettingsData.iconThemePerMode
+                    currentValue: SettingsData.iconThemeDark
                     enableFuzzySearch: true
                     popupWidthOffset: 100
                     maxPopupHeight: 236
                     options: cachedIconThemes
                     onValueChanged: value => {
-                        SettingsData.setIconTheme(value);
+                        SettingsData.setIconThemeForMode(value, false);
-                        if (Quickshell.env("QT_QPA_PLATFORMTHEME") != "gtk3" && Quickshell.env("QT_QPA_PLATFORMTHEME") != "qt6ct" && Quickshell.env("QT_QPA_PLATFORMTHEME_QT6") != "qt6ct") {
+                        warnIfMissingQtTheme();
-                            ToastService.showError(I18n.tr("Missing Environment Variables", "qt theme env error title"), I18n.tr("You need to set either:\nQT_QPA_PLATFORMTHEME=gtk3 OR\nQT_QPA_PLATFORMTHEME=qt6ct\nas environment variables, and then restart the shell.\n\nqt6ct requires qt6ct-kde to be installed.", "qt theme env error body"));
+                    }
-                        }
+                }
+
+                SettingsDropdownRow {
+                    tab: "theme"
+                    tags: ["icon", "theme", "system", "dark"]
+                    settingKey: "iconThemeDark"
+                    text: I18n.tr("Dark Mode Icon Theme")
+                    description: I18n.tr("DankShell & System Icons (requires restart)")
+                    visible: SettingsData.iconThemePerMode
+                    currentValue: SettingsData.iconThemeDark
+                    enableFuzzySearch: true
+                    popupWidthOffset: 100
+                    maxPopupHeight: 236
+                    options: cachedIconThemes
+                    onValueChanged: value => {
+                        SettingsData.setIconThemeForMode(value, false);
+                        warnIfMissingQtTheme();
+                    }
+                }
+
+                SettingsDropdownRow {
+                    tab: "theme"
+                    tags: ["icon", "theme", "system", "light"]
+                    settingKey: "iconThemeLight"
+                    text: I18n.tr("Light Mode Icon Theme")
+                    description: I18n.tr("DankShell & System Icons (requires restart)")
+                    visible: SettingsData.iconThemePerMode
+                    currentValue: SettingsData.iconThemeLight
+                    enableFuzzySearch: true
+                    popupWidthOffset: 100
+                    maxPopupHeight: 236
+                    options: cachedIconThemes
+                    onValueChanged: value => {
+                        SettingsData.setIconThemeForMode(value, true);
+                        warnIfMissingQtTheme();
                     }
                 }
             }

quickshell/Modules/Settings/TimeWeatherTab.qml

@@ -143,15 +143,6 @@ Item {
                     }
                 }
 
-                DankButton {
-                    text: I18n.tr("Launch DankCalendar")
-                    iconName: "calendar_month"
-                    backgroundColor: Theme.primary
-                    textColor: Theme.primaryText
-                    visible: CalendarService.dankNeedsLaunch && CalendarService.dankBinaryExists
-                    onClicked: CalendarService.launchDankCalendar()
-                }
-
                 Rectangle {
                     width: parent.width
                     height: 1

quickshell/Modules/Settings/WallpaperTab.qml

@@ -354,6 +354,28 @@ Item {
                     }
                 }
 
+                ColorDropdownRow {
+                    tab: "wallpaper"
+                    tags: ["background", "color", "fill", "fit", "custom"]
+                    settingKey: "wallpaperBackgroundColorMode"
+                    text: I18n.tr("Background Color")
+                    description: I18n.tr("Color shown for areas not covered by wallpaper (e.g. Fit or Pad modes)")
+                    visible: root.currentWallpaper !== "" && !root.currentWallpaper.startsWith("#")
+                    dropdownWidth: 220
+                    options: [
+                        { "value": "black", "label": I18n.tr("Black") },
+                        { "value": "white", "label": I18n.tr("White") },
+                        { "value": "primary", "label": I18n.tr("Primary Theme Color") },
+                        { "value": "surface", "label": I18n.tr("Surface Container") },
+                        { "value": "custom", "label": I18n.tr("Custom") }
+                    ]
+                    currentMode: SettingsData.wallpaperBackgroundColorMode
+                    customColor: SettingsData.wallpaperBackgroundCustomColor || "#000000"
+                    pickerTitle: I18n.tr("Wallpaper Background Color")
+                    onModeSelected: mode => SettingsData.set("wallpaperBackgroundColorMode", mode)
+                    onCustomColorSelected: selectedColor => SettingsData.set("wallpaperBackgroundCustomColor", selectedColor.toString())
+                }
+
                 Rectangle {
                     width: parent.width
                     height: 1

quickshell/Modules/Settings/WorkspaceAppearanceCard.qml

@@ -4,41 +4,195 @@ import qs.Services
 import qs.Modules.Settings.Widgets
 
 SettingsCard {
+    id: root
+
     iconName: "palette"
     title: I18n.tr("Workspace Appearance")
     settingKey: "workspaceAppearance"
     collapsible: true
     expanded: false
 
-    SettingsButtonGroupRow {
+    readonly property var focusedColorOptions: [({
+                "value": "default",
+                "label": I18n.tr("Primary", "workspace color option")
+            }), ({
+                "value": "primaryContainer",
+                "label": I18n.tr("Primary Container", "workspace color option")
+            }), ({
+                "value": "secondary",
+                "label": I18n.tr("Secondary", "workspace color option")
+            }), ({
+                "value": "secondaryContainer",
+                "label": I18n.tr("Secondary Container", "workspace color option")
+            }), ({
+                "value": "tertiary",
+                "label": I18n.tr("Tertiary", "workspace color option")
+            }), ({
+                "value": "tertiaryContainer",
+                "label": I18n.tr("Tertiary Container", "workspace color option")
+            }), ({
+                "value": "s",
+                "label": I18n.tr("Surface", "workspace color option")
+            }), ({
+                "value": "sc",
+                "label": I18n.tr("Surface Container", "workspace color option")
+            }), ({
+                "value": "sch",
+                "label": I18n.tr("Surface High", "workspace color option")
+            }), ({
+                "value": "schh",
+                "label": I18n.tr("Surface Highest", "workspace color option")
+            }), ({
+                "value": "none",
+                "label": I18n.tr("None", "workspace color option")
+            }), ({
+                "value": "custom",
+                "label": I18n.tr("Custom", "workspace color option")
+            })]
+
+    readonly property var occupiedColorOptions: [({
+                "value": "none",
+                "label": I18n.tr("None", "workspace color option")
+            }), ({
+                "value": "primary",
+                "label": I18n.tr("Primary", "workspace color option")
+            }), ({
+                "value": "primaryContainer",
+                "label": I18n.tr("Primary Container", "workspace color option")
+            }), ({
+                "value": "sec",
+                "label": I18n.tr("Secondary", "workspace color option")
+            }), ({
+                "value": "secondaryContainer",
+                "label": I18n.tr("Secondary Container", "workspace color option")
+            }), ({
+                "value": "tertiary",
+                "label": I18n.tr("Tertiary", "workspace color option")
+            }), ({
+                "value": "tertiaryContainer",
+                "label": I18n.tr("Tertiary Container", "workspace color option")
+            }), ({
+                "value": "s",
+                "label": I18n.tr("Surface", "workspace color option")
+            }), ({
+                "value": "sc",
+                "label": I18n.tr("Surface Container", "workspace color option")
+            }), ({
+                "value": "sch",
+                "label": I18n.tr("Surface High", "workspace color option")
+            }), ({
+                "value": "schh",
+                "label": I18n.tr("Surface Highest", "workspace color option")
+            }), ({
+                "value": "custom",
+                "label": I18n.tr("Custom", "workspace color option")
+            })]
+
+    readonly property var unfocusedColorOptions: [({
+                "value": "default",
+                "label": I18n.tr("Default", "workspace color option")
+            }), ({
+                "value": "surfaceText",
+                "label": I18n.tr("Surface Text", "workspace color option")
+            }), ({
+                "value": "primary",
+                "label": I18n.tr("Primary", "workspace color option")
+            }), ({
+                "value": "secondary",
+                "label": I18n.tr("Secondary", "workspace color option")
+            }), ({
+                "value": "tertiary",
+                "label": I18n.tr("Tertiary", "workspace color option")
+            }), ({
+                "value": "s",
+                "label": I18n.tr("Surface", "workspace color option")
+            }), ({
+                "value": "sc",
+                "label": I18n.tr("Surface Container", "workspace color option")
+            }), ({
+                "value": "sch",
+                "label": I18n.tr("Surface High", "workspace color option")
+            }), ({
+                "value": "schh",
+                "label": I18n.tr("Surface Highest", "workspace color option")
+            }), ({
+                "value": "custom",
+                "label": I18n.tr("Custom", "workspace color option")
+            })]
+
+    readonly property var urgentColorOptions: [({
+                "value": "default",
+                "label": I18n.tr("Error", "workspace color option")
+            }), ({
+                "value": "primary",
+                "label": I18n.tr("Primary", "workspace color option")
+            }), ({
+                "value": "primaryContainer",
+                "label": I18n.tr("Primary Container", "workspace color option")
+            }), ({
+                "value": "secondary",
+                "label": I18n.tr("Secondary", "workspace color option")
+            }), ({
+                "value": "secondaryContainer",
+                "label": I18n.tr("Secondary Container", "workspace color option")
+            }), ({
+                "value": "tertiary",
+                "label": I18n.tr("Tertiary", "workspace color option")
+            }), ({
+                "value": "tertiaryContainer",
+                "label": I18n.tr("Tertiary Container", "workspace color option")
+            }), ({
+                "value": "s",
+                "label": I18n.tr("Surface", "workspace color option")
+            }), ({
+                "value": "sc",
+                "label": I18n.tr("Surface Container", "workspace color option")
+            }), ({
+                "value": "sch",
+                "label": I18n.tr("Surface High", "workspace color option")
+            }), ({
+                "value": "custom",
+                "label": I18n.tr("Custom", "workspace color option")
+            })]
+
+    readonly property var borderColorOptions: [({
+                "value": "surfaceText",
+                "label": I18n.tr("Surface Text", "workspace color option")
+            }), ({
+                "value": "primary",
+                "label": I18n.tr("Primary", "workspace color option")
+            }), ({
+                "value": "primaryContainer",
+                "label": I18n.tr("Primary Container", "workspace color option")
+            }), ({
+                "value": "secondary",
+                "label": I18n.tr("Secondary", "workspace color option")
+            }), ({
+                "value": "secondaryContainer",
+                "label": I18n.tr("Secondary Container", "workspace color option")
+            }), ({
+                "value": "tertiary",
+                "label": I18n.tr("Tertiary", "workspace color option")
+            }), ({
+                "value": "tertiaryContainer",
+                "label": I18n.tr("Tertiary Container", "workspace color option")
+            }), ({
+                "value": "custom",
+                "label": I18n.tr("Custom", "workspace color option")
+            })]
+
+    readonly property bool workspaceStateColorsVisible: CompositorService.isNiri || CompositorService.isHyprland || CompositorService.isMango
+    readonly property bool urgentWorkspaceColorsVisible: workspaceStateColorsVisible || CompositorService.isSway || CompositorService.isScroll || CompositorService.isMiracle
+
+    ColorDropdownRow {
         text: I18n.tr("Focused Color")
-        model: ["pri", "s", "sc", "sch", "none"]
+        settingKey: "workspaceColorMode"
-        buttonHeight: 22
+        tags: ["workspace", "focused", "color", "custom"]
-        minButtonWidth: 36
+        options: root.focusedColorOptions
-        buttonPadding: Theme.spacingS
+        currentMode: SettingsData.workspaceColorMode
-        checkIconSize: Theme.iconSizeSmall - 2
+        customColor: SettingsData.workspaceFocusedCustomColor || "#6750A4"
-        textSize: Theme.fontSizeSmall - 1
+        onModeSelected: mode => SettingsData.set("workspaceColorMode", mode)
-        spacing: 1
+        onCustomColorSelected: selectedColor => SettingsData.set("workspaceFocusedCustomColor", selectedColor.toString())
-        currentIndex: {
-            switch (SettingsData.workspaceColorMode) {
-            case "s":
-                return 1;
-            case "sc":
-                return 2;
-            case "sch":
-                return 3;
-            case "none":
-                return 4;
-            default:
-                return 0;
-            }
-        }
-        onSelectionChanged: (index, selected) => {
-            if (!selected)
-                return;
-            const modes = ["default", "s", "sc", "sch", "none"];
-            SettingsData.set("workspaceColorMode", modes[index]);
-        }
     }
 
     Rectangle {
@@ -48,38 +202,16 @@ SettingsCard {
         opacity: 0.15
     }
 
-    SettingsButtonGroupRow {
+    ColorDropdownRow {
         text: I18n.tr("Occupied Color")
-        model: ["none", "sec", "s", "sc", "sch", "schh"]
+        settingKey: "workspaceOccupiedColorMode"
-        visible: CompositorService.isNiri || CompositorService.isHyprland || CompositorService.isMango
+        tags: ["workspace", "occupied", "color", "custom"]
-        buttonHeight: 22
+        visible: root.workspaceStateColorsVisible
-        minButtonWidth: 36
+        options: root.occupiedColorOptions
-        buttonPadding: Theme.spacingS
+        currentMode: SettingsData.workspaceOccupiedColorMode
-        checkIconSize: Theme.iconSizeSmall - 2
+        customColor: SettingsData.workspaceOccupiedCustomColor || "#625B71"
-        textSize: Theme.fontSizeSmall - 1
+        onModeSelected: mode => SettingsData.set("workspaceOccupiedColorMode", mode)
-        spacing: 1
+        onCustomColorSelected: selectedColor => SettingsData.set("workspaceOccupiedCustomColor", selectedColor.toString())
-        currentIndex: {
-            switch (SettingsData.workspaceOccupiedColorMode) {
-            case "sec":
-                return 1;
-            case "s":
-                return 2;
-            case "sc":
-                return 3;
-            case "sch":
-                return 4;
-            case "schh":
-                return 5;
-            default:
-                return 0;
-            }
-        }
-        onSelectionChanged: (index, selected) => {
-            if (!selected)
-                return;
-            const modes = ["none", "sec", "s", "sc", "sch", "schh"];
-            SettingsData.set("workspaceOccupiedColorMode", modes[index]);
-        }
     }
 
     Rectangle {
@@ -90,33 +222,16 @@ SettingsCard {
         visible: CompositorService.isNiri || CompositorService.isHyprland || CompositorService.isMango
     }
 
-    SettingsButtonGroupRow {
+    ColorDropdownRow {
         text: I18n.tr("Unfocused Color")
-        model: ["def", "s", "sc", "sch"]
+        settingKey: "workspaceUnfocusedColorMode"
-        buttonHeight: 22
+        tags: ["workspace", "unfocused", "color", "custom"]
-        minButtonWidth: 36
+        options: root.unfocusedColorOptions
-        buttonPadding: Theme.spacingS
+        defaultColor: Theme.surfaceText
-        checkIconSize: Theme.iconSizeSmall - 2
+        currentMode: SettingsData.workspaceUnfocusedColorMode
-        textSize: Theme.fontSizeSmall - 1
+        customColor: SettingsData.workspaceUnfocusedCustomColor || "#49454E"
-        spacing: 1
+        onModeSelected: mode => SettingsData.set("workspaceUnfocusedColorMode", mode)
-        currentIndex: {
+        onCustomColorSelected: selectedColor => SettingsData.set("workspaceUnfocusedCustomColor", selectedColor.toString())
-            switch (SettingsData.workspaceUnfocusedColorMode) {
-            case "s":
-                return 1;
-            case "sc":
-                return 2;
-            case "sch":
-                return 3;
-            default:
-                return 0;
-            }
-        }
-        onSelectionChanged: (index, selected) => {
-            if (!selected)
-                return;
-            const modes = ["default", "s", "sc", "sch"];
-            SettingsData.set("workspaceUnfocusedColorMode", modes[index]);
-        }
     }
 
     Rectangle {
@@ -127,36 +242,17 @@ SettingsCard {
         visible: CompositorService.isNiri || CompositorService.isHyprland || CompositorService.isMango || CompositorService.isSway || CompositorService.isScroll || CompositorService.isMiracle
     }
 
-    SettingsButtonGroupRow {
+    ColorDropdownRow {
         text: I18n.tr("Urgent Color")
-        visible: CompositorService.isNiri || CompositorService.isHyprland || CompositorService.isMango || CompositorService.isSway || CompositorService.isScroll || CompositorService.isMiracle
+        settingKey: "workspaceUrgentColorMode"
-        model: ["err", "pri", "sec", "s", "sc"]
+        tags: ["workspace", "urgent", "color", "custom"]
-        buttonHeight: 22
+        visible: root.urgentWorkspaceColorsVisible
-        minButtonWidth: 36
+        options: root.urgentColorOptions
-        buttonPadding: Theme.spacingS
+        defaultColor: Theme.error
-        checkIconSize: Theme.iconSizeSmall - 2
+        currentMode: SettingsData.workspaceUrgentColorMode
-        textSize: Theme.fontSizeSmall - 1
+        customColor: SettingsData.workspaceUrgentCustomColor || "#B3261E"
-        spacing: 1
+        onModeSelected: mode => SettingsData.set("workspaceUrgentColorMode", mode)
-        currentIndex: {
+        onCustomColorSelected: selectedColor => SettingsData.set("workspaceUrgentCustomColor", selectedColor.toString())
-            switch (SettingsData.workspaceUrgentColorMode) {
-            case "primary":
-                return 1;
-            case "secondary":
-                return 2;
-            case "s":
-                return 3;
-            case "sc":
-                return 4;
-            default:
-                return 0;
-            }
-        }
-        onSelectionChanged: (index, selected) => {
-            if (!selected)
-                return;
-            const modes = ["default", "primary", "secondary", "s", "sc"];
-            SettingsData.set("workspaceUrgentColorMode", modes[index]);
-        }
     }
 
     Rectangle {
@@ -181,39 +277,16 @@ SettingsCard {
         visible: SettingsData.workspaceFocusedBorderEnabled
         leftPadding: Theme.spacingM
 
-        SettingsButtonGroupRow {
+        ColorDropdownRow {
             width: parent.width - parent.leftPadding
             text: I18n.tr("Border Color")
-            model: [I18n.tr("Surface"), I18n.tr("Secondary"), I18n.tr("Primary")]
+            settingKey: "workspaceFocusedBorderColor"
-            currentIndex: {
+            tags: ["workspace", "focused", "border", "color", "custom"]
-                switch (SettingsData.workspaceFocusedBorderColor) {
+            options: root.borderColorOptions
-                case "surfaceText":
+            currentMode: SettingsData.workspaceFocusedBorderColor
-                    return 0;
+            customColor: SettingsData.workspaceFocusedBorderCustomColor || "#6750A4"
-                case "secondary":
+            onModeSelected: mode => SettingsData.set("workspaceFocusedBorderColor", mode)
-                    return 1;
+            onCustomColorSelected: selectedColor => SettingsData.set("workspaceFocusedBorderCustomColor", selectedColor.toString())
-                case "primary":
-                    return 2;
-                default:
-                    return 2;
-                }
-            }
-            onSelectionChanged: (index, selected) => {
-                if (!selected)
-                    return;
-                let newColor = "primary";
-                switch (index) {
-                case 0:
-                    newColor = "surfaceText";
-                    break;
-                case 1:
-                    newColor = "secondary";
-                    break;
-                case 2:
-                    newColor = "primary";
-                    break;
-                }
-                SettingsData.set("workspaceFocusedBorderColor", newColor);
-            }
         }
 
         SettingsSliderRow {

quickshell/Modules/Toast.qml

@@ -422,13 +422,6 @@ PanelWindow {
             }
         }
 
-        Behavior on color {
-            ColorAnimation {
-                duration: Theme.shortDuration
-                easing.type: Theme.standardEasing
-            }
-        }
-
         Behavior on height {
             enabled: false
         }
@@ -441,4 +434,14 @@ PanelWindow {
     mask: Region {
         item: toast
     }
+
+    WindowBlur {
+        targetWindow: root
+        blurEnabled: root.shouldBeVisible
+        blurX: toast.x
+        blurY: toast.y
+        blurWidth: root.shouldBeVisible ? toast.width : 0
+        blurHeight: root.shouldBeVisible ? toast.height : 0
+        blurRadius: toast.radius
+    }
 }

quickshell/Modules/WallpaperBackground.qml

@@ -42,6 +42,11 @@ Variants {
             id: root
             anchors.fill: parent
 
+            Rectangle {
+                anchors.fill: parent
+                color: SettingsData.effectiveWallpaperBackgroundColor
+            }
+
             function encodeFileUrl(path) {
                 if (!path)
                     return "";
@@ -131,6 +136,12 @@ Variants {
                 function onWallpaperFillModeChanged() {
                     root.invalidate();
                 }
+                function onWallpaperBackgroundColorModeChanged() {
+                    root.invalidate();
+                }
+                function onWallpaperBackgroundCustomColorChanged() {
+                    root.invalidate();
+                }
             }
 
             Connections {