39 files changed, 2460 insertions, 343 deletions

diff --git a/accounts/gkleen@sif/default.nix b/accounts/gkleen@sif/default.nix
index f2978b6e..c786c629 100644
--- a/accounts/gkleen@sif/default.nix
+++ b/accounts/gkleen@sif/default.nix
@@ -49,7 +49,8 @@ let
     ];
   };
 
-  lockCommand = "${lib.getExe' config.systemd.package "systemctl"} --user start gtklock.service";
+  # lockCommand = "${lib.getExe' config.systemd.package "systemctl"} --user start gtklock.service";
+  lockCommand = "${lib.getExe' cfg.programs.quickshell.package "qs"} ipc call Lockscreen setLocked true";
 
   editor = pkgs.symlinkJoin {
     inherit (cfg.services.emacs.package) name;
@@ -374,7 +375,7 @@ in {
 
       services = {
         wpaperd = {
-          enable = true;
+          enable = false;
           settings.default = {
             path = "~/.wallpapers";
             duration = "15m";
@@ -594,10 +595,10 @@ in {
             "--subst-var-by" "ksshaskpass" (lib.getExe pkgs.kdePackages.ksshaskpass)
           ];
         };
-        "systemd/user/xdg-desktop-portal.service.d/after-graphical-session.conf".text = ''
-          [Unit]
-          After=graphical-session.target
-        '';
+        # "systemd/user/xdg-desktop-portal.service.d/after-graphical-session.conf".text = ''
+        #   [Unit]
+        #   After=graphical-session.target
+        # '';
         "systemd/user/home-manager.service.d/before-graphical-session.conf".text = ''
           [Unit]
           Before=graphical-session-pre.target
diff --git a/accounts/gkleen@sif/niri/default.nix b/accounts/gkleen@sif/niri/default.nix
index 35a3d799..e1eca4c4 100644
--- a/accounts/gkleen@sif/niri/default.nix
+++ b/accounts/gkleen@sif/niri/default.nix
@@ -231,25 +231,7 @@ in {
   };
 
   config = {
-    systemd.user.services.xwayland-satellite = {
-      Unit = {
-        BindsTo = [ "graphical-session.target" ];
-        PartOf = [ "graphical-session.target" ];
-        After = [ "graphical-session.target" ];
-        Requisite = [ "graphical-session.target" ];
-      };
-      Service = {
-        Type = "notify";
-        NotifyAccess = "all";
-        Environment = [ "DISPLAY=:0" ];
-        ExecStart = ''${lib.getExe pkgs.xwayland-satellite-unstable} ''${DISPLAY}'';
-        ExecStartPre = "${systemctl} --user import-environment DISPLAY";
-        StandardOutput = "journal";
-      };
-      Install = {
-        WantedBy = [ "graphical-session.target" ];
-      };
-    };
+    home.packages = [ pkgs.xwayland-satellite-unstable ];
 
     services.swayidle = {
       events = [
diff --git a/accounts/gkleen@sif/shell/default.nix b/accounts/gkleen@sif/shell/default.nix
index 26c8bd98..5025dd90 100644
--- a/accounts/gkleen@sif/shell/default.nix
+++ b/accounts/gkleen@sif/shell/default.nix
@@ -4,17 +4,110 @@
   config = {
     programs.quickshell = {
       enable = true;
+      package = pkgs.symlinkJoin {
+        pname = pkgs.quickshell.pname + "-wrapped";
+        inherit (pkgs.quickshell) version meta;
+        paths = [ pkgs.quickshell ];
+        buildInputs = [ pkgs.makeWrapper ];
+        postBuild = ''
+          for binary in quickshell qs; do
+            wrapProgram $out/bin/$binary \
+              --prefix QML_IMPORT_PATH : ${pkgs.qt6Packages.callPackage ./quickshell-plugins {}}/${pkgs.qt6.qtbase.qtQmlPrefix}
+          done
+        '';
+      };
       config = {
         src = ./quickshell;
         replacements = {
-          coreutils = toString pkgs.coreutils;
           ignore_workspaces = builtins.toJSON (map ({ name, ... }: name) config.programs.niri.scratchspaces);
+          wallpapers = builtins.toJSON (pkgs.stdenvNoCC.mkDerivation {
+            name = "wallpapers";
+            srcs = [
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/publicationtiff10k/carinanebula3.tif";
+                hash = "sha256-YxZEweDKJfvfrdxb/QFmgJhcZDEJYxotoHrG+RRn1tw=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/original/pillarsofcreation_composite.tif";
+                hash = "sha256-qRiODxR0lZWdxgYXna0fNRFFDErpBJDwOJuQl6sNjRc=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/publicationtiff10k/weic2212a.tif";
+                hash = "sha256-l2fqE/z//C1a0xkvZwsnwPbTSb+WuA11h+SUl3E1dhw=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/publicationtiff10k/weic2415a.tif";
+                hash = "sha256-onBy7cPoUpDuzQStbY2E+qmlGgSLXPwFCLX53ukAb4c=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/publicationtiff10k/weic2330a.tif";
+                hash = "sha256-nn0ZtjZIrPcpj3YcLTsrL7XiXvyh3QYgCSmdDMD+3OM=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/original/weic2426a.tif";
+                hash = "sha256-EDnfPn3GE9jt6XPqiGInP7E2F3Az7d25NqATSWltDv0=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/original/weic2503a.tif";
+                hash = "sha256-3/RX6RQp8naELcgReHPd5/zhJkoCjnA10w5BEnNo+qI=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/original/weic2506a.tif";
+                hash = "sha256-aDld0aoY1owRxDVf7Jcyw71TH42M1foYotxn2thyFYw=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/original/weic2514a.tif";
+                hash = "sha256-jTi1G1Ofo5xsF6ggrbtYJHxqLaCQ7edM5B3uORiVQtg=";
+              })
+              (pkgs.fetchurl {
+                url = "https://esawebb.org/media/archives/images/original/weic2425c.tif";
+                hash = "sha256-oaEOexSJHEGj090dJF3ct5HAoR+Y5gRiPrUlxdvnTRo=";
+              })
+            ];
+
+            dontUnpack = true;
+
+            buildInputs = [ pkgs.imagemagick ];
+            buildPhase = ''
+              runHook preBuild
+
+              typeset sources=($srcs)
+
+              mkdir -p $out
+              magick ''${sources[0]} -crop 10000x5625+0+79 +repage -define jpeg:extent=10MB $out/carinanebula3.jpeg
+              magick ''${sources[1]} -crop 6716x3778+329+80 +repage -define jpeg:extent=10MB $out/pillarsofcreation_composite.jpeg
+              magick ''${sources[2]} -crop 10000x5625+0+79 +repage -define jpeg:extent=10MB $out/weic2212a.jpeg
+              magick ''${sources[3]} -crop 7650x4302+1166+389 +repage -define jpeg:extent=10MB $out/weic2415a.jpeg
+              magick ''${sources[4]} -crop 8732x4912+0+434 +repage -define jpeg:extent=10MB $out/weic2330a.jpeg
+              magick ''${sources[5]} -crop 5302x2982+636+0 +repage -define jpeg:extent=10MB $out/weic2426a.jpeg
+              magick ''${sources[6]} -crop 4328x2434+0+906 +repage -define jpeg:extent=10MB $out/weic2503a.jpeg
+              magick ''${sources[7]} -crop 4152x2335+0+666 +repage -define jpeg:extent=10MB $out/weic2506a.jpeg
+              magick ''${sources[8]} -crop 4320x2430+0+0 +repage -define jpeg:extent=10MB $out/weic2514a.jpeg
+              magick ''${sources[9]} -crop 5863x3298+0+477 +repage -define jpeg:extent=10MB $out/weic2425c.jpeg
+
+              runHook postBuild
+            '';
+          });
+          niri_session = builtins.toJSON [
+            (pkgs.writeShellScript "niri-session" ''
+              exec ${lib.getExe pkgs.dex} -w ${config.programs.niri.package}/share/wayland-sessions/niri.desktop &>/tmp/niri-session-$$.log
+            '')
+            # (lib.getExe pkgs.dex)
+            # "${config.programs.niri.package}/share/wayland-sessions/niri.desktop"
+          ];
+          username = builtins.toJSON config.home.username;
+          mdi = builtins.toJSON (pkgs.fetchFromGitHub {
+            owner = "Templarian";
+            repo = "MaterialDesign";
+            rev = "2424e748e0cc63ab7b9c095a099b9fe239b737c0";
+            hash = "sha256-QMGl7soAhErrrnY3aKOZpt49yebkSNzy10p/v5OaqQ0=";
+          });
         };
       };
     };
     systemd.user.services.quickshell = {
       Service = {
-        Environment = "QML_IMPORT_PATH=${pkgs.qt6Packages.callPackage ./quickshell-plugins {}}/${pkgs.qt6.qtbase.qtQmlPrefix}";
+        RuntimeDirectory = "quickshell";
       };
     };
   };
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/CMakeLists.txt b/accounts/gkleen@sif/shell/quickshell-plugins/CMakeLists.txt
index aa363c4c..a7e88fa7 100644
--- a/accounts/gkleen@sif/shell/quickshell-plugins/CMakeLists.txt
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/CMakeLists.txt
@@ -92,7 +92,7 @@ endfunction()
 cmake_minimum_required(VERSION 3.20)
 project(custom LANGUAGES CXX)
 
-find_package(Qt6 REQUIRED COMPONENTS Core Qml)
+find_package(Qt6 REQUIRED COMPONENTS Core Qml DBus)
 
 qt_standard_project_setup(REQUIRES 6.6)
 
@@ -102,15 +102,32 @@ qt6_add_qml_module(customplugin
     PLUGIN_TARGET customplugin
 )
 
-target_sources(customplugin PRIVATE
-    Chrono.cpp Chrono.hpp
+set_source_files_properties(org.keepassxc.KeePassXC.MainWindow.xml PROPERTIES
+        CLASSNAME DBusKeePassXC
+        NO_NAMESPACE TRUE
 )
 
+qt_add_dbus_interface(DBUS_INTERFACES
+        org.keepassxc.KeePassXC.MainWindow.xml
+        dbus_keepassxc
+)
+
+include_directories(${CMAKE_SOURCE_DIR}/build)
+
 target_compile_features(customplugin PUBLIC cxx_std_26)
 
 target_link_libraries(customplugin PRIVATE
     Qt6::Core
     Qt6::Qml
+    Qt6::DBus
+)
+
+target_sources(customplugin PRIVATE
+    Chrono.cpp Chrono.hpp
+    FileSelector.cpp FileSelector.hpp
+    KeePassXC.cpp KeePassXC.hpp
+    Systemd.cpp Systemd.hpp
+    ${DBUS_INTERFACES}
 )
 
 install_qml_module(customplugin)
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.cpp b/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.cpp
index 929b7be6..22b3469b 100644
--- a/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.cpp
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.cpp
@@ -42,9 +42,11 @@ void Chrono::update() {
 }
 
 void Chrono::setTime(const std::chrono::time_point<std::chrono::system_clock>& targetTime) {
+  using namespace std::chrono_literals;
+
   auto currentTime = std::chrono::system_clock::now();
   auto offset = std::chrono::duration_cast<std::chrono::milliseconds>(targetTime - currentTime);
-  this->currentTime = abs(offset.count()) < 500 ? targetTime : currentTime;
+  this->currentTime = abs(offset) < 500ms ? targetTime : currentTime;
 
   switch (this->mPrecision) {
   case Chrono::Hours: this->currentTime = std::chrono::time_point_cast<std::chrono::hours>(this->currentTime);
@@ -56,33 +58,26 @@ void Chrono::setTime(const std::chrono::time_point<std::chrono::system_clock>& t
 }
 
 void Chrono::schedule(const std::chrono::time_point<std::chrono::system_clock>& targetTime) {
+  using namespace std::chrono_literals;
+
   auto currentTime = std::chrono::system_clock::now();
   auto offset = std::chrono::duration_cast<std::chrono::milliseconds>(targetTime - currentTime);
-  auto nextTime = abs(offset.count()) < 500 ? targetTime : currentTime;
-
-  {
-    using namespace std::chrono_literals;
+  auto nextTime = abs(offset) < 500ms ? targetTime : currentTime;
 
-    switch (this->mPrecision) {
-    case Chrono::Hours: nextTime = std::chrono::time_point_cast<std::chrono::hours>(nextTime) + 1h;
-    case Chrono::Minutes: nextTime = std::chrono::time_point_cast<std::chrono::minutes>(nextTime) + 1min;
-    case Chrono::Seconds: nextTime = std::chrono::time_point_cast<std::chrono::seconds>(nextTime) + 1s;
-    }
+  switch (this->mPrecision) {
+  case Chrono::Hours: nextTime = std::chrono::time_point_cast<std::chrono::hours>(nextTime) + 1h;
+  case Chrono::Minutes: nextTime = std::chrono::time_point_cast<std::chrono::minutes>(nextTime) + 1min;
+  case Chrono::Seconds: nextTime = std::chrono::time_point_cast<std::chrono::seconds>(nextTime) + 1s;
   }
 
   this->targetTime = nextTime;
-  auto delay = std::chrono::duration_cast<std::chrono::milliseconds>(nextTime - currentTime);
-  this->timer.start(delay);
+  this->timer.start(std::chrono::duration_cast<std::chrono::milliseconds>(nextTime - currentTime));
 }
 
-QString Chrono::format() const { return this->mFormat; }
-void Chrono::setFormat(QString format) {
-  if (format == this->mFormat) return;
-  this->mFormat = format;
-  emit this->formatChanged();
-  this->update();
+QString Chrono::format(const QString& fmt) const {
+  return QString::fromStdString(std::format(std::runtime_format(fmt.toStdString()), std::chrono::zoned_time(std::chrono::current_zone(), std::chrono::time_point_cast<std::chrono::seconds>(this->currentTime))));
 }
 
-QString Chrono::date() const {
-  return QString::fromStdString(std::format(std::runtime_format(this->mFormat.toStdString()), std::chrono::zoned_time(std::chrono::current_zone(), std::chrono::time_point_cast<std::chrono::seconds>(this->currentTime))));
+QDateTime Chrono::date() const {
+  return QDateTime::fromStdTimePoint(std::chrono::time_point_cast<std::chrono::milliseconds>(this->currentTime));
 }
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.hpp b/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.hpp
index 788fa88e..04080187 100644
--- a/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.hpp
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/Chrono.hpp
@@ -1,17 +1,18 @@
 #pragma once
 
+#include <chrono>
+
+#include <QDateTime>
 #include <QObject>
 #include <QTimer>
 
 #include <qqmlintegration.h>
-#include <chrono>
 
 class Chrono : public QObject {
   Q_OBJECT;
   Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged);
   Q_PROPERTY(Chrono::Precision precision READ precision WRITE setPrecision NOTIFY precisionChanged);
-  Q_PROPERTY(QString format READ format WRITE setFormat NOTIFY formatChanged);
-  Q_PROPERTY(QString date READ date NOTIFY dateChanged);
+  Q_PROPERTY(QDateTime date READ date NOTIFY dateChanged)
   QML_ELEMENT;
 
 public:
@@ -30,15 +31,13 @@ public:
   Chrono::Precision precision() const;
   void setPrecision(Chrono::Precision precision);
 
-  QString format() const;
-  void setFormat (QString format);
+  Q_INVOKABLE QString format(const QString& fmt) const;
 
-  QString date() const;
+  QDateTime date() const;
 
 signals:
   void enabledChanged();
   void precisionChanged();
-  void formatChanged();
   void dateChanged();
 
 private slots:
@@ -47,7 +46,6 @@ private slots:
 private:
   bool mEnabled = true;
   Chrono::Precision mPrecision = Chrono::Seconds;
-  QString mFormat = "{:%c}";
   QTimer timer;
   std::chrono::time_point<std::chrono::system_clock> currentTime, targetTime;
 
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/FileSelector.cpp b/accounts/gkleen@sif/shell/quickshell-plugins/FileSelector.cpp
new file mode 100644
index 00000000..d7051d2a
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/FileSelector.cpp
@@ -0,0 +1,102 @@
+#include "FileSelector.hpp"
+
+#include <sstream>
+#include <vector>
+#include <random>
+#include <algorithm>
+
+#include <iostream>
+#include <format>
+
+namespace fs = std::filesystem;
+
+FileSelector::FileSelector(QObject* parent): QObject(parent) {
+  QObject::connect(&this->timer, &QTimer::timeout, this, &FileSelector::onTimeout);
+  this->timer.setTimerType(Qt::PreciseTimer);
+}
+
+QString FileSelector::directory() const {
+  return QString::fromStdString(this->mDirectory->string());
+}
+void FileSelector::setDirectory(QString directory) {
+  this->mDirectory = directory.toStdString();
+  if (this->mDirectory && this->mEpoch)
+    this->update();
+  emit this->directoryChanged();
+}
+
+unsigned int FileSelector::epoch() const {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(*this->mEpoch).count();
+}
+void FileSelector::setEpoch(unsigned int epoch) {
+  this->mEpoch = std::chrono::milliseconds{epoch};
+  if (this->mDirectory && this->mEpoch)
+    this->update();
+  emit this->epochChanged();
+}
+
+QString FileSelector::seed() const {
+  return this->mSeed;
+}
+void FileSelector::setSeed(QString seed) {
+  this->mSeed = seed;
+  emit this->seedChanged();
+  if (this->mDirectory && this->mEpoch)
+    emit this->selectedChanged();
+}
+
+QString FileSelector::selected() const {
+  if (!this->mDirectory || !this->mEpoch)
+    return QString();
+
+  std::vector<fs::path> shuffled(this->mFiles.begin(), this->mFiles.end());
+  std::sort(shuffled.begin(), shuffled.end());
+
+  auto currentTime = std::chrono::system_clock::now();
+  uint64_t currentEpoch = currentTime.time_since_epoch() / *this->mEpoch;
+  std::chrono::milliseconds timeInEpoch = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime.time_since_epoch()) % *this->mEpoch;
+
+  std::ostringstream seed;
+  seed << this->mSeed.size() << ";" << this->mSeed.toStdString() << ";";
+  seed << *this->mEpoch << ";";
+  seed << currentEpoch << ";";
+  seed << this->mDirectory->string().size() << ";" << *this->mDirectory << ";";
+  seed << this->mFiles.size() << ";";
+  for (const fs::path& p: this->mFiles)
+    seed << p.string().size() << ";" << p << ";";
+
+  std::vector<std::seed_seq::result_type> v;
+  v.reserve(seed.str().size());
+  for (const char& c: seed.str())
+    v.push_back(c);
+
+  std::seed_seq engine_seed(v.begin(), v.end());
+  std::mt19937 g(engine_seed);
+  std::shuffle(shuffled.begin(), shuffled.end(), g);
+
+  std::vector<fs::path>::size_type ix = shuffled.size() * timeInEpoch / *this->mEpoch;
+  return QString::fromStdString((*this->mDirectory / shuffled[ix]).string());
+}
+
+void FileSelector::onTimeout() {
+  if (!this->mFiles.size())
+    return;
+
+  auto currentTime = std::chrono::system_clock::now();
+  uint64_t currentMinorEpoch = currentTime.time_since_epoch() / (*this->mEpoch / this->mFiles.size());
+  auto nextTime = std::chrono::time_point<std::chrono::system_clock>((currentMinorEpoch + 1) * (*this->mEpoch / this->mFiles.size()));
+  this->timer.start(std::chrono::duration_cast<std::chrono::milliseconds>(nextTime - currentTime));
+
+  emit this->selectedChanged();
+}
+
+void FileSelector::update() {
+  this->mFiles = std::set<fs::path>{};
+  for (const fs::directory_entry& entry:
+         fs::recursive_directory_iterator(*this->mDirectory, fs::directory_options::follow_directory_symlink))
+    {
+      this->mFiles.insert(fs::relative(entry, *this->mDirectory));
+    }
+
+  this->onTimeout();
+}
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/FileSelector.hpp b/accounts/gkleen@sif/shell/quickshell-plugins/FileSelector.hpp
new file mode 100644
index 00000000..72c4f2a7
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/FileSelector.hpp
@@ -0,0 +1,52 @@
+#pragma once
+
+#include <filesystem>
+#include <chrono>
+#include <set>
+#include <optional>
+
+#include <QObject>
+#include <QTimer>
+
+#include <qqmlintegration.h>
+
+class FileSelector : public QObject {
+  Q_OBJECT;
+  Q_PROPERTY(QString directory READ directory WRITE setDirectory NOTIFY directoryChanged REQUIRED);
+  Q_PROPERTY(unsigned int epoch READ epoch WRITE setEpoch NOTIFY epochChanged REQUIRED);
+  Q_PROPERTY(QString seed READ seed WRITE setSeed NOTIFY seedChanged);
+  Q_PROPERTY(QString selected READ selected NOTIFY selectedChanged);
+  QML_ELEMENT;
+
+public:
+  explicit FileSelector(QObject* parent = nullptr);
+
+  QString directory() const;
+  void setDirectory(QString directory);
+
+  unsigned int epoch() const;
+  void setEpoch(unsigned int epoch);
+
+  QString seed() const;
+  void setSeed(QString seed);
+
+  QString selected() const;
+
+signals:
+  void directoryChanged();
+  void epochChanged();
+  void seedChanged();
+  void selectedChanged();
+
+private slots:
+  void onTimeout();
+
+private:
+  std::optional<std::filesystem::path> mDirectory;
+  std::optional<std::chrono::milliseconds> mEpoch;
+  std::set<std::filesystem::path> mFiles;
+  QString mSeed;
+  QTimer timer;
+
+  void update();
+};
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/KeePassXC.cpp b/accounts/gkleen@sif/shell/quickshell-plugins/KeePassXC.cpp
new file mode 100644
index 00000000..f6e4dd6e
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/KeePassXC.cpp
@@ -0,0 +1,18 @@
+#include "KeePassXC.hpp"
+
+#include <QDBusConnection>
+
+KeePassXC::KeePassXC() {
+  this->service = new DBusKeePassXC(DBusKeePassXC::staticInterfaceName(), "/keepassxc", QDBusConnection::sessionBus(), this);
+}
+KeePassXC::~KeePassXC() {
+  if (this->service)
+    delete this->service;
+}
+
+void KeePassXC::lockAllDatabases() {
+  if (!this->service)
+    return;
+
+  this->service->lockAllDatabases();
+}
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/KeePassXC.hpp b/accounts/gkleen@sif/shell/quickshell-plugins/KeePassXC.hpp
new file mode 100644
index 00000000..c4cd71e0
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/KeePassXC.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "dbus_keepassxc.h"
+
+#include <QObject>
+#include <QtQmlIntegration/qqmlintegration.h>
+
+class KeePassXC : public QObject {
+  Q_OBJECT;
+  QML_SINGLETON;
+  QML_ELEMENT;
+
+public:
+  explicit KeePassXC();
+  ~KeePassXC();
+
+  Q_INVOKABLE void lockAllDatabases();
+
+private:
+  DBusKeePassXC* service = nullptr;
+};
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/Systemd.cpp b/accounts/gkleen@sif/shell/quickshell-plugins/Systemd.cpp
new file mode 100644
index 00000000..9ccd8ba0
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/Systemd.cpp
@@ -0,0 +1,16 @@
+#include "Systemd.hpp"
+
+#include <QDBusConnection>
+#include <QDBusMessage>
+
+void Systemd::stopUserUnit(const QString& unit, const QString& mode) {
+  QDBusMessage m = QDBusMessage::createMethodCall(
+    "org.freedesktop.systemd1",
+    "/org/freedesktop/systemd1",
+    "org.freedesktop.systemd1.Manager",
+    "StopUnit"
+  );
+  m << unit;
+  m << mode;
+  QDBusConnection::sessionBus().send(m);
+}
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/Systemd.hpp b/accounts/gkleen@sif/shell/quickshell-plugins/Systemd.hpp
new file mode 100644
index 00000000..883a96f3
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/Systemd.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <QObject>
+#include <QtQmlIntegration/qqmlintegration.h>
+
+class Systemd : public QObject {
+  Q_OBJECT;
+  QML_SINGLETON;
+  QML_ELEMENT;
+
+public:
+  Q_INVOKABLE void stopUserUnit(const QString& unit, const QString& mode);
+};
diff --git a/accounts/gkleen@sif/shell/quickshell-plugins/default.nix b/accounts/gkleen@sif/shell/quickshell-plugins/default.nix
index fafea90e..33b76f61 100644
--- a/accounts/gkleen@sif/shell/quickshell-plugins/default.nix
+++ b/accounts/gkleen@sif/shell/quickshell-plugins/default.nix
@@ -3,11 +3,19 @@
 , cmake
 , qt6
 , fmt
+, keepassxc
+, systemd
 }:
+
 stdenv.mkDerivation rec {
   name = "quickshell-custom";
 
   src = ./.;
+
+  prePatch = ''
+    cp ${keepassxc.src}/src/gui/org.keepassxc.KeePassXC.MainWindow.xml .
+  '';
+
   nativeBuildInputs = [ cmake qt6.wrapQtAppsHook ];
   buildInputs = [
     qt6.qtbase
diff --git a/accounts/gkleen@sif/shell/quickshell/Bar.qml b/accounts/gkleen@sif/shell/quickshell/Bar.qml
index aab1607f..3652af54 100644
--- a/accounts/gkleen@sif/shell/quickshell/Bar.qml
+++ b/accounts/gkleen@sif/shell/quickshell/Bar.qml
@@ -7,8 +7,6 @@ PanelWindow {
 
   required property var screen
 
-  property var calendarMouseArea: clock.calendarMouseArea
-
   anchors {
     top: true
     left: true
@@ -66,6 +64,13 @@ PanelWindow {
     anchors.verticalCenter: parent.verticalCenter
     spacing: 0
 
+    PipewireWidget {}
+
+    Item {
+      height: parent.height
+      width: 4
+    }
+
     SystemTray {}
 
     Item {
@@ -80,8 +85,6 @@ PanelWindow {
       width: 4
     }
 
-    Clock {
-      id: clock
-    }
+    Clock {}
   }
 }
\ No newline at end of file
diff --git a/accounts/gkleen@sif/shell/quickshell/Clock.qml b/accounts/gkleen@sif/shell/quickshell/Clock.qml
index 58600adb..4644d5e7 100644
--- a/accounts/gkleen@sif/shell/quickshell/Clock.qml
+++ b/accounts/gkleen@sif/shell/quickshell/Clock.qml
@@ -7,240 +7,271 @@ import QtQuick.Layouts
 import Quickshell.Widgets
 
 Item {
+  id: clockItem
+
+  property bool calendarPopup: true
+
   width: clock.contentWidth
   height: parent.height
   anchors.verticalCenter: parent.verticalCenter
 
-  MouseArea {
+  WrapperMouseArea {
     id: clockMouseArea
 
     anchors.fill: parent
     hoverEnabled: true
-    enabled: true
+    enabled: clockItem.calendarPopup
 
-    property real angleRem: 0
-    property real sensitivity: 1 / 120
+    Item {
+      anchors.fill: parent
 
-    function scrollYear(event) {
-      angleRem += event.angleDelta.y;
-      const d = Math.round(angleRem * sensitivity);
-      yearCalendar.year += d;
-      angleRem -= d / sensitivity;
-    }
+      Text {
+        id: clock
+        color: "white"
 
-    onWheel: event => scrollYear(event)
-  }
+        anchors.verticalCenter: parent.verticalCenter
 
-  Text {
-    id: clock
-    color: "white"
+        Custom.Chrono {
+          id: chrono
 
-    anchors.verticalCenter: parent.verticalCenter
+          onDateChanged: clock.text = format("W{0:%V-%u} {0:%F} {0:%H:%M:%S%Ez}")
+        }
 
-    Custom.Chrono {
-      id: chrono
-      format: "W{0:%V-%u} {0:%F} {0:%H:%M:%S%Ez}"
+        font.pointSize: 10
+        font.family: "Fira Sans"
+        font.features: { "tnum": 1 }
+      }
     }
-
-    text: chrono.date
-
-    font.pointSize: 10
-    font.family: "Fira Sans"
-    font.features: { "tnum": 1 }
   }
 
-  PopupWindow {
-    id: tooltip
+  Loader {
+    id: tooltipLoader
 
-    property bool nextVisible: clockMouseArea.containsMouse || tooltipMouseArea.containsMouse
+    active: false
 
-    anchor {
-      item: clockMouseArea
-      edges: Edges.Bottom | Edges.Left
+    Connections {
+      target: clockMouseArea
+      function onContainsMouseChanged() {
+       if (clockMouseArea.containsMouse)
+         tooltipLoader.active = true;
+      }
     }
-    visible: false
 
-    onNextVisibleChanged: hangTimer.restart()
+    sourceComponent: PopupWindow {
+      id: tooltip
 
-    Timer {
-      id: hangTimer
-      interval: 100
-      onTriggered: tooltip.visible = tooltip.nextVisible
-    }
+      property bool nextVisible: clockMouseArea.containsMouse || tooltipMouseArea.containsMouse
 
-    implicitWidth: clockTooltipContent.width
-    implicitHeight: clockTooltipContent.height
-    color: "black"
+      anchor {
+        item: clockMouseArea
+        edges: Edges.Bottom | Edges.Left
+      }
+      visible: false
 
-    onVisibleChanged: {
-      const d = new Date();
-      yearCalendar.year = d.getFullYear();
-      clockMouseArea.angleRem = 0;
-    }
+      onNextVisibleChanged: hangTimer.restart()
 
-    WrapperMouseArea {
-      id: tooltipMouseArea
+      Timer {
+        id: hangTimer
+        interval: 100
+        onTriggered: tooltip.visible = tooltip.nextVisible
+      }
 
-      hoverEnabled: true
-      enabled: true
+      implicitWidth: clockTooltipContent.width
+      implicitHeight: clockTooltipContent.height
+      color: "black"
 
-      onWheel: event => clockMouseArea.scrollYear(event)
+      onVisibleChanged: {
+        yearCalendar.year = chrono.date.getFullYear();
+        yearCalendar.angleRem = 0;
+      }
 
-      anchors.fill: parent
+      WrapperMouseArea {
+        id: tooltipMouseArea
 
-      WrapperItem {
-        id: clockTooltipContent
+        hoverEnabled: true
+        enabled: true
 
-        margin: 8
-        leftMargin: 0
+        onWheel: event => yearCalendar.scrollYear(event)
 
-        ColumnLayout {
-          Text {
-            id: yearLabel
+        anchors.fill: parent
 
-            horizontalAlignment: Text.AlignHCenter
+        WrapperItem {
+          id: clockTooltipContent
 
-            font.pointSize: 14
-            font.family: "Fira Sans"
-            font.features: { "tnum": 1 }
-            color: "white"
+          margin: 8
 
-            text: yearCalendar.year
+          ColumnLayout {
+            anchors.centerIn: parent
 
-            Layout.fillWidth: true
-            Layout.bottomMargin: 8
-          }
+            Text {
+              id: yearLabel
+
+              horizontalAlignment: Text.AlignHCenter
 
-          GridLayout {
-            property int year: { const d = new Date(); return d.getFullYear(); }
+              font.pointSize: 14
+              font.family: "Fira Sans"
+              font.features: { "tnum": 1 }
+              color: "white"
 
-            id: yearCalendar
+              text: yearCalendar.year
 
-            columns: 3
-            columnSpacing: 16
-            rowSpacing: 16
+              Layout.fillWidth: true
+              Layout.bottomMargin: 8
+            }
 
-            Layout.alignment: Qt.AlignHCenter
-            Layout.fillWidth: false
+            GridLayout {
+              property int year: chrono.date.getFullYear()
 
-            Repeater {
-              model: 12
+              id: yearCalendar
 
-              GridLayout {
-                columns: 2
+              columns: 3
+              columnSpacing: 16
+              rowSpacing: 16
 
-                required property int index
-                property int month: index
+              Layout.alignment: Qt.AlignHCenter
+              Layout.fillWidth: false
 
-                id: monthCalendar
+              property real angleRem: 0
+              property real sensitivity: 1 / 120
 
-                Layout.alignment: Qt.AlignTop | Qt.AlignRight
-                Layout.fillWidth: false
+              function scrollYear(event) {
+                angleRem += event.angleDelta.y;
+                const d = Math.round(angleRem * sensitivity);
+                yearCalendar.year += d;
+                angleRem -= d / sensitivity;
+              }
 
-                Text {
-                  Layout.column: 1
-                  Layout.fillWidth: true
+              Connections {
+                target: clockMouseArea
+                function onWheel(event) { yearCalendar.scrollYear(event); }
+              }
 
-                  horizontalAlignment: Text.AlignHCenter
+              Repeater {
+                model: 12
 
-                  font.pointSize: 10
-                  font.family: "Fira Sans"
+                GridLayout {
+                  columns: 2
 
-                  text: {
-                    const date = Date.fromLocaleDateString(Qt.locale(), `${yearCalendar.year}-${monthCalendar.month + 1}-01`, "yyyy-M-dd");
-                    return date.toLocaleString(Qt.locale("en_DK"), "MMMM")
-                  }
+                  required property int index
+                  property int month: index
 
-                  color: "#ffead3"
-                }
+                  id: monthCalendar
 
-                DayOfWeekRow {
-                  locale: grid.locale
+                  Layout.alignment: Qt.AlignTop | Qt.AlignRight
+                  Layout.fillWidth: false
 
-                  Layout.row: 1
-                  Layout.column: 1
-                  Layout.fillWidth: true
+                  Text {
+                    Layout.column: 1
+                    Layout.fillWidth: true
 
-                  delegate: Text {
-                    required property string shortName
+                    horizontalAlignment: Text.AlignHCenter
 
                     font.pointSize: 10
-                    font.family: "Fira Mono"
+                    font.family: "Fira Sans"
 
-                    text: shortName
-                    color: "#ffcc66"
+                    text: new Date(yearCalendar.year, monthCalendar.month, 1).toLocaleString(Qt.locale("en_DK"), "MMMM")
 
-                    horizontalAlignment: Text.AlignRight
-                    verticalAlignment: Text.AlignVCenter
+                    color: "#ffead3"
                   }
-                }
 
-                WeekNumberColumn {
-                  month: grid.month
-                  year: grid.year
-                  locale: grid.locale
+                  DayOfWeekRow {
+                    locale: grid.locale
 
-                  Layout.fillHeight: true
+                    Layout.row: 1
+                    Layout.column: 1
+                    Layout.fillWidth: true
 
-                  delegate: Text {
-                    required property int weekNumber
+                    delegate: WrapperItem {
+                      required property string shortName
 
-                    opacity: {
-                      const simple = new Date(weekNumber == 1 && monthCalendar.month == 12 ? yearCalendar.year + 1 : yearCalendar.year, 0, 1 + (weekNumber - 1) * 7);
-                      const dayOfWeek = simple.getDay();
-                      const isoWeekStart = simple;
+                      width: dowLabel.contentWidth + 6
 
-                      isoWeekStart.setDate(simple.getDate() - dayOfWeek + 1);
-                      if (dayOfWeek > 4) {
-                          isoWeekStart.setDate(isoWeekStart.getDate() + 7);
-                      }
-
-                      for (let i = 0; i < 7; i++) {
-                        const dayInWeek = new Date(isoWeekStart);
-                        dayInWeek.setDate(dayInWeek.getDate() + i);
-                        if (dayInWeek.getMonth() == monthCalendar.month)
-                          return 1;
-                      }
+                      Text {
+                        id: dowLabel
 
-                      return 0;
-                    }
+                        anchors.fill: parent
 
-                    font.pointSize: 10
-                    font.family: "Fira Sans"
-                    font.features: { "tnum": 1 }
+                        font.pointSize: 10
+                        font.family: "Fira Sans"
 
-                    text: weekNumber
-                    color: "#99ffdd"
+                        text: parent.shortName
+                        color: "#ffcc66"
 
-                    horizontalAlignment: Text.AlignRight
-                    verticalAlignment: Text.AlignVCenter
+                        horizontalAlignment: Text.AlignHCenter
+                        verticalAlignment: Text.AlignVCenter
+                      }
+                    }
                   }
-                }
 
-                MonthGrid {
-                  id: grid
+                  WeekNumberColumn {
+                    month: grid.month
+                    year: grid.year
+                    locale: grid.locale
 
-                  year: yearCalendar.year
-                  month: monthCalendar.month
-                  locale: Qt.locale("en_DK")
+                    Layout.fillHeight: true
 
-                  Layout.fillWidth: true
-                  Layout.fillHeight: true
+                    delegate: Text {
+                      required property int weekNumber
 
-                  delegate: Text {
-                      required property var model
+                      opacity: {
+                        const simple = new Date(weekNumber == 1 && monthCalendar.month == 12 ? yearCalendar.year + 1 : yearCalendar.year, 0, 1 + (weekNumber - 1) * 7);
+                        const dayOfWeek = simple.getDay();
+                        const isoWeekStart = simple;
 
-                      opacity: model.month === monthCalendar.month ? 1 : 0
+                        isoWeekStart.setDate(simple.getDate() - dayOfWeek + 1);
+                        if (dayOfWeek > 4) {
+                            isoWeekStart.setDate(isoWeekStart.getDate() + 7);
+                        }
+
+                        for (let i = 0; i < 7; i++) {
+                          const dayInWeek = new Date(isoWeekStart);
+                          dayInWeek.setDate(dayInWeek.getDate() + i);
+                          if (dayInWeek.getMonth() == monthCalendar.month)
+                            return 1;
+                        }
+
+                        return 0;
+                      }
 
                       font.pointSize: 10
                       font.family: "Fira Sans"
                       font.features: { "tnum": 1 }
 
-                      text: model.day
-                      color: model.today ? "#ff6699" : "white"
+                      text: weekNumber
+                      color: "#99ffdd"
 
                       horizontalAlignment: Text.AlignRight
                       verticalAlignment: Text.AlignVCenter
+                    }
+                  }
+
+                  MonthGrid {
+                    id: grid
+
+                    year: yearCalendar.year
+                    month: monthCalendar.month
+                    locale: Qt.locale("en_DK")
+
+                    Layout.fillWidth: true
+                    Layout.fillHeight: true
+
+                    delegate: Text {
+                        required property var model
+
+                        opacity: model.month === monthCalendar.month ? 1 : 0
+
+                        font.pointSize: 10
+                        font.family: "Fira Sans"
+                        font.features: { "tnum": 1 }
+
+                        property bool today: chrono.date.getFullYear() == model.year && chrono.date.getMonth() == model.month && chrono.date.getDate() == model.day
+
+                        text: model.day
+                        color: today ? "#ff6699" : "white"
+
+                        horizontalAlignment: Text.AlignRight
+                        verticalAlignment: Text.AlignVCenter
+                    }
                   }
                 }
               }
@@ -250,4 +281,4 @@ Item {
       }
     }
   }
-}
\ No newline at end of file
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/KeyboardLayout.qml b/accounts/gkleen@sif/shell/quickshell/KeyboardLayout.qml
index b9f91580..bc3750f9 100644
--- a/accounts/gkleen@sif/shell/quickshell/KeyboardLayout.qml
+++ b/accounts/gkleen@sif/shell/quickshell/KeyboardLayout.qml
@@ -3,25 +3,16 @@ import QtQuick
 import qs.Services
 import Quickshell.Widgets
 
-Rectangle {
-  id: kbdWidget
-
-  property var keyboardAbbrev: { "English (programmer Dvorak)": "dvp", "English (US)": "us" }
-
+Item {
   width: kbdLabel.contentWidth + 8
-  color: {
-    if (kbdMouseArea.containsMouse) {
-      return "#33808080";
-    }
-    return "transparent";
-  }
   height: parent.height
   anchors.verticalCenter: parent.verticalCenter
 
-  MouseArea {
+  WrapperMouseArea {
     id: kbdMouseArea
 
     anchors.fill: parent
+
     hoverEnabled: true
     cursorShape: Qt.PointingHandCursor
     enabled: true
@@ -31,25 +22,39 @@ Rectangle {
     onWheel: event => {
       NiriService.sendCommand({ "Action": { "SwitchLayout": { "layout": event.angleDelta > 0 ? "Next" : "Prev" } } }, _ => {})
     }
-  }
 
-  Text {
-    id: kbdLabel
+    Rectangle {
+      id: kbdWidget
 
-    font.pointSize: 10
-    font.family: "Fira Sans"
-    color: {
-      if (NiriService.keyboardLayouts?.current_idx === 0)
-        return "#555";
-      return "white";
-    }
-    anchors.centerIn: parent
+      property var keyboardAbbrev: { "English (programmer Dvorak)": "dvp", "English (US)": "us" }
+
+      anchors.fill: parent
+      color: {
+        if (kbdMouseArea.containsMouse) {
+          return "#33808080";
+        }
+        return "transparent";
+      }
 
-    text: {
-      const currentLayout = NiriService.keyboardLayouts?.names?.[NiriService.keyboardLayouts.current_idx];
-      if (!currentLayout)
-        return "";
-      return kbdWidget.keyboardAbbrev[currentLayout] ? kbdWidget.keyboardAbbrev[currentLayout] : currentLayout;
+      Text {
+        id: kbdLabel
+
+        font.pointSize: 10
+        font.family: "Fira Sans"
+        color: {
+          if (NiriService.keyboardLayouts?.current_idx === 0)
+            return "#555";
+          return "white";
+        }
+        anchors.centerIn: parent
+
+        text: {
+          const currentLayout = NiriService.keyboardLayouts?.names?.[NiriService.keyboardLayouts.current_idx];
+          if (!currentLayout)
+            return "";
+          return kbdWidget.keyboardAbbrev[currentLayout] ? kbdWidget.keyboardAbbrev[currentLayout] : currentLayout;
+        }
+      }
     }
   }
 
diff --git a/accounts/gkleen@sif/shell/quickshell/LockSurface.qml b/accounts/gkleen@sif/shell/quickshell/LockSurface.qml
new file mode 100644
index 00000000..18698725
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/LockSurface.qml
@@ -0,0 +1,223 @@
+import Quickshell.Widgets
+import QtQuick.Effects
+import QtQuick.Layouts
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Controls.Fusion
+import qs.Services
+import QtQml
+
+Item {
+  id: lockSurface
+
+  property var screen
+  property list<var> messages: []
+  property bool responseRequired: false
+  property bool responseVisible: false
+  property string currentText: ""
+  property bool authRunning: false
+
+  signal response(string responseText)
+
+  anchors.fill: parent
+
+  Item {
+    id: background
+
+    anchors.fill: parent
+
+    property Img current: one
+    property string source: selector.selected
+
+    WallpaperSelector {
+      id: selector
+      seed: lockSurface.screen?.name || ""
+    }
+
+    onSourceChanged: {
+      if (!source)
+        current = null;
+      else if (current === one)
+        two.update()
+      else
+        one.update()
+    }
+
+    Img { id: one }
+    Img { id: two }
+
+    component Img: Item {
+      id: img
+
+      property string source
+
+      function update() {
+        source = background.source || ""
+      }
+
+      anchors.fill: parent
+
+      Image {
+        id: imageSource
+
+        source: img.source
+        sourceSize: Qt.size(parent.width, parent.height)
+        fillMode: Image.PreserveAspectCrop
+        smooth: true
+        visible: false
+        asynchronous: true
+        cache: false
+
+        onStatusChanged: {
+          if (status === Image.Ready) {
+            background.current = img
+          }
+        }
+      }
+
+      MultiEffect {
+        id: imageEffect
+
+        source: imageSource
+        anchors.fill: parent
+        blurEnabled: true
+        blur: 1
+        blurMax: 64
+        blurMultiplier: 2
+
+        opacity: 0
+
+        states: State {
+          name: "visible"
+          when: background.current === img
+
+          PropertyChanges {
+            imageEffect.opacity: 1
+          }
+          StateChangeScript {
+            name: "unloadOther"
+            script: {
+              if (img === one)
+                two.source = ""
+              if (img === two)
+                one.source = ""
+            }
+          }
+        }
+
+        transitions: Transition {
+          SequentialAnimation {
+            NumberAnimation {
+              target: imageEffect
+              properties: "opacity"
+              duration: 5000
+              easing.type: Easing.OutCubic
+            }
+            ScriptAction {
+              scriptName: "unloadOther"
+            }
+          }
+        }
+      }
+    }
+  }
+
+  Item {
+    anchors {
+      top: lockSurface.top
+      left: lockSurface.left
+      right: lockSurface.right
+    }
+
+    implicitWidth: lockSurface.width
+    implicitHeight: 21
+
+    Rectangle {
+      anchors.fill: parent
+      color: Qt.rgba(0, 0, 0, 0.75)
+    }
+
+    Clock {
+      anchors.centerIn: parent
+      calendarPopup: false
+    }
+  }
+
+  WrapperRectangle {
+    id: unlockUi
+
+    Keys.onPressed: event => {
+      if (!lockSurface.authRunning) {
+        event.accepted = true;
+        lockSurface.authRunning = true;
+      }
+    }
+    focus: !passwordBox.visible
+
+    visible: lockSurface.authRunning
+
+    color: Qt.rgba(0, 0, 0, 0.75)
+    margin: 8
+
+    anchors.centerIn: parent
+
+    ColumnLayout {
+      spacing: 4
+
+      BusyIndicator {
+        visible: running
+        running: !Array.from(lockSurface.messages).length && !lockSurface.responseRequired
+      }
+
+      Repeater {
+        model: lockSurface.messages
+
+        Text {
+          required property var modelData
+
+          font.pointSize: 10
+          font.family: "Fira Sans"
+          color: modelData.error ? "#f28a21" : "#ffffff"
+
+          text: String(modelData.text).trim()
+
+          Layout.fillWidth: true
+          horizontalAlignment: Text.AlignHCenter
+        }
+      }
+
+      TextField {
+        id: passwordBox
+
+        visible: lockSurface.responseRequired
+        echoMode: lockSurface.responseVisible ? TextInput.Normal : TextInput.Password
+        inputMethodHints: Qt.ImhSensitiveData
+
+        onTextChanged: lockSurface.currentText = passwordBox.text
+        onAccepted: {
+          passwordBox.readOnly = true;
+          lockSurface.response(lockSurface.currentText);
+        }
+
+        Connections {
+          target: lockSurface
+          function onCurrentTextChanged() {
+            passwordBox.text = lockSurface.currentText
+          }
+        }
+        Connections {
+          target: lockSurface
+          function onResponseRequiredChanged() {
+            if (lockSurface.responseRequired)
+              passwordBox.readOnly = false;
+              passwordBox.focus = true;
+              passwordBox.selectAll();
+          }
+        }
+
+        Layout.topMargin: 4
+        Layout.fillWidth: true
+      }
+    }
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/Lockscreen.qml b/accounts/gkleen@sif/shell/quickshell/Lockscreen.qml
new file mode 100644
index 00000000..8e739359
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/Lockscreen.qml
@@ -0,0 +1,90 @@
+import Quickshell
+import Quickshell.Wayland
+import Quickshell.Io
+import Quickshell.Services.Pam
+import Quickshell.Services.Mpris
+import Custom as Custom
+import qs.Services
+import QtQml
+
+Scope {
+  id: lockscreen
+
+  property string currentText: ""
+
+  PamContext {
+    id: pam
+
+    property list<var> messages: []
+
+    config: "quickshell"
+    onCompleted: result => {
+      if (result === PamResult.Success) {
+        lock.locked = false;
+      }
+    }
+    onPamMessage: {
+      messages = Array.from(messages).concat([{ "text": pam.message, "error": pam.messageIsError }])
+    }
+    onActiveChanged: {
+      messages = [];
+    }
+  }
+
+  IpcHandler {
+    target: "Lockscreen"
+
+    function setLocked(locked: bool): void { lock.locked = locked; }
+    function getLocked(): bool { return lock.locked; }
+  }
+
+  WlSessionLock {
+    id: lock
+
+    onLockStateChanged: {
+      if (!locked && pam.active)
+        pam.abort();
+
+      if (locked) {
+        Custom.KeePassXC.lockAllDatabases();
+        Array.from(Mpris.players.values).forEach(player => {
+          if (player.canPause && player.isPlaying)
+            player.pause();
+        });
+        // Custom.Systemd.stopUserUnit("gpg-agent.service", "replace");
+        GpgAgent.reloadAgent();
+      }
+    }
+
+    WlSessionLockSurface {
+      id: lockSurface
+
+      color: "black"
+
+      LockSurface {
+        id: surfaceContent
+
+        onResponse: responseText => pam.respond(responseText)
+        onAuthRunningChanged: {
+          if (authRunning)
+            pam.start();
+        }
+        Connections {
+          target: pam
+          function onMessagesChanged() { surfaceContent.messages = pam.messages; }
+          function onResponseRequiredChanged() { surfaceContent.responseRequired = pam.responseRequired; }
+          function onActiveChanged() { surfaceContent.authRunning = pam.active; }
+        }
+        onCurrentTextChanged: lockscreen.currentText = currentText
+        Connections {
+          target: lockscreen
+          function onCurrentTextChanged() { surfaceContent.currentText = lockscreen.currentText; }
+        }
+        Connections {
+          target: lockSurface
+          function onScreenChanged() { surfaceContent.screen = lockSurface.screen; }
+        }
+      }
+    }
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/MaterialDesignIcon.qml b/accounts/gkleen@sif/shell/quickshell/MaterialDesignIcon.qml
new file mode 100644
index 00000000..387dcc8b
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/MaterialDesignIcon.qml
@@ -0,0 +1,24 @@
+import QtQuick
+import QtQuick.Effects
+
+Item {
+  id: icon
+
+  required property string icon
+  property color color: "white"
+
+  Image {
+    id: sourceImage
+    source: "file://" + @mdi@ + "/svg/" + icon.icon + ".svg"
+    anchors.fill: parent
+
+    layer.enabled: true
+    layer.effect: MultiEffect {
+      id: effect
+
+      brightness: 1
+      colorization: 1
+      colorizationColor: icon.color
+    }
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/PipewireWidget.qml b/accounts/gkleen@sif/shell/quickshell/PipewireWidget.qml
new file mode 100644
index 00000000..7fdb5006
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/PipewireWidget.qml
@@ -0,0 +1,354 @@
+import QtQuick
+import QtQuick.Layouts
+import QtQuick.Controls.Fusion
+import Quickshell
+import Quickshell.Services.Pipewire
+import Quickshell.Widgets
+
+Item {
+  height: parent.height
+  width: volumeIcon.width + 8
+  anchors.verticalCenter: parent.verticalCenter
+
+  PwObjectTracker {
+    objects: [Pipewire.defaultAudioSink]
+  }
+
+  WrapperMouseArea {
+    id: widgetMouseArea
+
+    anchors.fill: parent
+    hoverEnabled: true
+    cursorShape: Qt.PointingHandCursor
+
+    onClicked: {
+      if (!Pipewire.defaultAudioSink)
+        return;
+      Pipewire.defaultAudioSink.audio.muted = !Pipewire.defaultAudioSink.audio.muted;
+    }
+
+    property real sensitivity: (1 / 40) / 120
+    onWheel: event => {
+      if (!Pipewire.defaultAudioSink)
+        return;
+      Pipewire.defaultAudioSink.audio.volume += event.angleDelta.y * sensitivity;
+    }
+
+    Rectangle {
+      id: volumeWidget
+
+      anchors.fill: parent
+      color: {
+        if (widgetMouseArea.containsMouse)
+          return "#33808080";
+        return "transparent";
+      }
+
+      Item {
+        anchors.fill: parent
+
+        MaterialDesignIcon {
+          id: volumeIcon
+
+          width: 16
+          height: 16
+          anchors.centerIn: parent
+
+          icon: {
+            if (!Pipewire.defaultAudioSink || Pipewire.defaultAudioSink.audio.muted)
+              return "volume-off";
+            if (Pipewire.defaultAudioSink.audio.volume <= 0.33)
+              return "volume-low";
+            if (Pipewire.defaultAudioSink.audio.volume <= 0.67)
+              return "volume-medium";
+            return "volume-high";
+          }
+          color: "#555"
+        }
+      }
+    }
+  }
+
+  Loader {
+    id: tooltipLoader
+
+    active: false
+
+    Connections {
+      target: widgetMouseArea
+      function onContainsMouseChanged() {
+        if (widgetMouseArea.containsMouse)
+          tooltipLoader.active = true;
+      }
+    }
+
+    PwObjectTracker {
+      objects: Pipewire.devices
+    }
+    PwObjectTracker {
+      objects: Pipewire.nodes
+    }
+
+    sourceComponent: PopupWindow {
+      id: tooltip
+
+      property bool openPopup: false
+      property bool nextVisible: widgetMouseArea.containsMouse || tooltipMouseArea.containsMouse || openPopup
+
+      anchor {
+        item: widgetMouseArea
+        edges: Edges.Bottom | Edges.Left
+      }
+      visible: false
+
+      onNextVisibleChanged: hangTimer.restart()
+
+      Timer {
+        id: hangTimer
+        interval: 100
+        onTriggered: {
+          tooltip.visible = tooltip.nextVisible;
+          if (!tooltip.visible)
+            tooltipLoader.active = false;
+        }
+      }
+
+      implicitWidth: tooltipContent.width
+      implicitHeight: tooltipContent.height
+      color: "black"
+
+      WrapperMouseArea {
+        id: tooltipMouseArea
+
+        hoverEnabled: true
+        enabled: true
+
+        anchors.fill: parent
+
+        WrapperItem {
+          id: tooltipContent
+
+          margin: 8
+          bottomMargin: 8 + Math.max(0, 200 - tooltipLayout.implicitHeight)
+
+          GridLayout {
+            id: tooltipLayout
+
+            columns: 4
+
+            Repeater {
+              model: Array.from(Pipewire.devices.values).filter(dev => dev.type == "Audio/Device")
+
+              Item {
+                id: descItem
+
+                required property var modelData
+                required property int index
+
+                Layout.column: 0
+                Layout.row: index
+
+                implicitWidth: descText.contentWidth
+                implicitHeight: descText.contentHeight
+
+                Text {
+                  id: descText
+
+                  color: "white"
+                  font.pointSize: 10
+                  font.family: "Fira Sans"
+
+                  text: descItem.modelData.description
+                }
+              }
+            }
+
+            Repeater {
+              id: defaultSinkRepeater
+
+              model: {
+                Array.from(Pipewire.devices.values)
+                  .filter(dev => dev.type == "Audio/Device")
+                  .map(device => Array.from(Pipewire.nodes.values).find(node => node.type == PwNodeType.AudioSink && node.device?.id == device.id ));
+              }
+
+              Item {
+                id: defaultSinkItem
+
+                required property var modelData
+                required property int index
+
+                PwObjectTracker {
+                  objects: [defaultSinkItem.modelData]
+                }
+
+                Layout.column: 1
+                Layout.row: index
+
+                Layout.fillHeight: true
+
+                implicitWidth: 16 + 8
+
+                WrapperMouseArea {
+                  id: defaultSinkMouseArea
+
+                  anchors.fill: parent
+                  hoverEnabled: true
+                  cursorShape: Qt.PointingHandCursor
+
+                  onClicked: {
+                    Pipewire.preferredDefaultAudioSink = defaultSinkItem.modelData
+                  }
+
+                  Rectangle {
+                    id: defaultSinkWidget
+
+                    anchors.fill: parent
+                    color: {
+                      if (defaultSinkMouseArea.containsMouse)
+                        return "#33808080";
+                      return "transparent";
+                    }
+
+                    MaterialDesignIcon {
+                      width: 16
+                      height: 16
+                      anchors.centerIn: parent
+
+                      icon: {
+                        if (defaultSinkItem.modelData?.id == Pipewire.defaultAudioSink?.id)
+                          return "speaker";
+                        return "speaker-off";
+                      }
+                      color: icon == "speaker" ? "white" : "#555"
+                    }
+                  }
+                }
+              }
+            }
+
+            Repeater {
+              id: defaultSourceRepeater
+
+              model: {
+                Array.from(Pipewire.devices.values)
+                  .filter(dev => dev.type == "Audio/Device")
+                  .map(device => Array.from(Pipewire.nodes.values).find(node => node.type == PwNodeType.AudioSource && node.device?.id == device.id ));
+              }
+
+              Item {
+                id: defaultSourceItem
+
+                required property var modelData
+                required property int index
+
+                PwObjectTracker {
+                  objects: [defaultSourceItem.modelData]
+                }
+
+                Layout.column: 2
+                Layout.row: index
+
+                Layout.fillHeight: true
+
+                implicitWidth: 16 + 8
+
+                WrapperMouseArea {
+                  id: defaultSourceMouseArea
+
+                  anchors.fill: parent
+                  hoverEnabled: true
+                  cursorShape: Qt.PointingHandCursor
+
+                  onClicked: {
+                    Pipewire.preferredDefaultAudioSource = defaultSourceItem.modelData
+                  }
+
+                  Rectangle {
+                    id: defaultSourceWidget
+
+                    anchors.fill: parent
+                    color: {
+                      if (defaultSourceMouseArea.containsMouse)
+                        return "#33808080";
+                      return "transparent";
+                    }
+
+                    MaterialDesignIcon {
+                      width: 16
+                      height: 16
+                      anchors.centerIn: parent
+
+                      icon: {
+                        if (defaultSourceItem.modelData?.id == Pipewire.defaultAudioSource?.id)
+                          return "microphone";
+                        return "microphone-off";
+                      }
+                      color: icon == "microphone" ? "white" : "#555"
+                    }
+                  }
+                }
+              }
+            }
+
+            Repeater {
+              id: profileRepeater
+
+              model: Array.from(Pipewire.devices.values).filter(dev => dev.type == "Audio/Device")
+
+              Item {
+                id: profileItem
+
+                required property var modelData
+                required property int index
+
+                PwObjectTracker {
+                  objects: [profileItem.modelData]
+                }
+
+                Layout.column: 3
+                Layout.row: index
+
+                Layout.fillWidth: true
+
+                implicitWidth: Math.max(profileBox.implicitWidth, 300)
+                implicitHeight: profileBox.height
+
+                ComboBox {
+                  id: profileBox
+
+                  model: profileItem.modelData.profiles
+
+                  textRole: "description"
+                  valueRole: "index"
+                  onActivated: profileItem.modelData.setProfile(currentValue)
+
+                  anchors.fill: parent
+
+                  implicitContentWidthPolicy: ComboBox.WidestText
+
+                  Connections {
+                    target: profileItem.modelData
+                    function onCurrentProfileChanged() {
+                      profileBox.currentIndex = Array.from(profileItem.modelData.profiles).findIndex(profile => profile.index == profileItem.modelData.currentProfile);
+                    }
+                  }
+                  Component.onCompleted: {
+                    profileBox.currentIndex = Array.from(profileItem.modelData.profiles).findIndex(profile => profile.index == profileItem.modelData.currentProfile);
+                  }
+
+                  Connections {
+                    target: profileBox.popup
+                    function onVisibleChanged() {
+                      tooltip.openPopup = profileBox.popup.visible
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/Services/GpgAgent.qml b/accounts/gkleen@sif/shell/quickshell/Services/GpgAgent.qml
new file mode 100644
index 00000000..3de69535
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/Services/GpgAgent.qml
@@ -0,0 +1,18 @@
+pragma Singleton
+
+import Quickshell
+import Quickshell.Io
+
+Singleton {
+  id: root
+
+  Socket {
+    id: agentSocket
+    connected: true
+    path: `${Quickshell.env("XDG_RUNTIME_DIR")}/gnupg/S.gpg-agent`
+  }
+
+  function reloadAgent() {
+    agentSocket.write("RELOADAGENT\n")
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/Services/NiriService.qml b/accounts/gkleen@sif/shell/quickshell/Services/NiriService.qml
index c82caaa6..af522ec4 100644
--- a/accounts/gkleen@sif/shell/quickshell/Services/NiriService.qml
+++ b/accounts/gkleen@sif/shell/quickshell/Services/NiriService.qml
@@ -28,9 +28,12 @@ Singleton {
     path: root.socketPath
     connected: true
 
+    property bool acked: false
+
     onConnectionStateChanged: {
       if (connected) {
-        write('"EventStream"\n')
+        acked = false;
+        write('"EventStream"\n');
       }
     }
 
@@ -66,6 +69,9 @@ Singleton {
             eventWindowUrgencyChanged(event.WindowUrgencyChanged);
           else if (event.WindowLayoutsChanged)
             eventWindowLayoutsChanged(event.WindowLayoutsChanged);
+          else if (event.Ok && !eventStreamSocket.acked) { eventStreamSocket.acked = true; }
+          else if (event.OverviewOpenedOrClosed) {}
+          else if (event.ConfigLoaded) {}
           else
             console.log(JSON.stringify(event));
         } catch (e) {
@@ -154,7 +160,11 @@ Singleton {
     });
   }
   function eventWindowOpenedOrChanged(data) {
-    root.windows = Array.from(root.windows).filter(win => win.id !== data.window.id).concat([data.window]);
+    root.windows = Array.from(root.windows).map(win => {
+      if (data.window.is_focused)
+        win.is_focused = false;
+      return win;
+    }).filter(win => win.id !== data.window.id).concat([data.window]);
   }
   function eventWindowClosed(data) {
     root.windows = Array.from(root.windows).filter(win => win.id !== data.id);
diff --git a/accounts/gkleen@sif/shell/quickshell/Services/WallpaperSelector.qml b/accounts/gkleen@sif/shell/quickshell/Services/WallpaperSelector.qml
new file mode 100644
index 00000000..3c524955
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/Services/WallpaperSelector.qml
@@ -0,0 +1,8 @@
+import Custom as Custom
+
+Custom.FileSelector {
+  id: root
+
+  directory: @wallpapers@
+  epoch: 72000000
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/SystemTray.qml b/accounts/gkleen@sif/shell/quickshell/SystemTray.qml
index ba678138..55b1690e 100644
--- a/accounts/gkleen@sif/shell/quickshell/SystemTray.qml
+++ b/accounts/gkleen@sif/shell/quickshell/SystemTray.qml
@@ -17,13 +17,17 @@ Item {
     spacing: 0
 
     Repeater {
-      model: {
-        var trayItems = Array.from(SystemTray.items.values).filter(item => item.status !== Status.Passive);
-        trayItems.sort((a, b) => a.category !== b.category ? b.category - a.category : a.id.localeCompare(b.id))
-        return trayItems;
+      model: ScriptModel {
+        values: {
+          var trayItems = Array.from(SystemTray.items.values).filter(item => item.status !== Status.Passive);
+          trayItems.sort((a, b) => a.category !== b.category ? b.category - a.category : a.id.localeCompare(b.id))
+          return trayItems;
+        }
       }
 
       delegate: Item {
+        id: trayItemWrapper
+
         property var trayItem: modelData
         property string iconSource: {
           let icon = trayItem && trayItem.icon
@@ -47,17 +51,7 @@ Item {
         height: parent.height
         anchors.verticalCenter: parent.verticalCenter
 
-        IconImage {
-          anchors.centerIn: parent
-          width: parent.width
-          height: parent.width
-          source: parent.iconSource
-          asynchronous: true
-          smooth: true
-          mipmap: true
-        }
-
-        MouseArea {
+        WrapperMouseArea {
           id: trayItemArea
 
           anchors.fill: parent
@@ -88,6 +82,16 @@ Item {
               menuAnchor.open()
             }
           }
+
+          IconImage {
+            anchors.centerIn: parent
+            width: parent.width
+            height: parent.width
+            source: trayItemWrapper.iconSource
+            asynchronous: true
+            smooth: true
+            mipmap: true
+          }
         }
 
         PopupWindow {
diff --git a/accounts/gkleen@sif/shell/quickshell/VolumeOSD.qml b/accounts/gkleen@sif/shell/quickshell/VolumeOSD.qml
new file mode 100644
index 00000000..02dcf227
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/VolumeOSD.qml
@@ -0,0 +1,134 @@
+import QtQuick
+import QtQuick.Layouts
+import Quickshell
+import Quickshell.Services.Pipewire
+import Quickshell.Widgets
+
+Scope {
+  id: root
+
+  property bool show: false
+  property bool inhibited: true
+
+  PwObjectTracker {
+    objects: [ Pipewire.defaultAudioSink ]
+  }
+
+  Connections {
+    enabled: Pipewire.defaultAudioSink
+    target: Pipewire.defaultAudioSink?.audio
+
+    function onVolumeChanged() {
+      root.show = true;
+      hideTimer.restart();
+    }
+    function onMutedChanged() {
+      root.show = true;
+      hideTimer.restart();
+    }
+  }
+
+  onShowChanged: {
+    if (show)
+      hideTimer.restart();
+  }
+
+  Timer {
+    id: hideTimer
+    interval: 1000
+    onTriggered: root.show = false
+  }
+
+  Timer {
+    id: startInhibit
+    interval: 100
+    running: true
+    onTriggered: {
+      root.show = false;
+      root.inhibited = false;
+    }
+  }
+
+  LazyLoader {
+    active: root.show && !root.inhibited
+
+    Variants {
+      model: Quickshell.screens
+
+      delegate: Scope {
+        id: screenScope
+
+        required property var modelData
+
+        PanelWindow {
+          id: window
+
+          screen: screenScope.modelData
+
+          anchors.top: true
+          margins.top: screen.height / 2 - 50 + 3.5
+          exclusiveZone: 0
+          exclusionMode: ExclusionMode.Ignore
+
+          implicitWidth: 400
+          implicitHeight: 50
+
+          mask: Region {}
+
+          color: "transparent"
+
+          Rectangle {
+            anchors.fill: parent
+            color: Qt.rgba(0, 0, 0, 0.75)
+          }
+
+          RowLayout {
+            id: layout
+
+            anchors.centerIn: parent
+
+            height: 50 - 8*2
+            width: 400 - 8*2
+
+            MaterialDesignIcon {
+              id: volumeIcon
+
+              implicitWidth: parent.height
+              implicitHeight: parent.height
+
+              icon: {
+                if (!Pipewire.defaultAudioSink || Pipewire.defaultAudioSink.audio.muted)
+                  return "volume-off";
+                if (Pipewire.defaultAudioSink.audio.volume <= 0.33)
+                  return "volume-low";
+                if (Pipewire.defaultAudioSink.audio.volume <= 0.67)
+                  return "volume-medium";
+                return "volume-high";
+              }
+            }
+
+            Rectangle {
+              Layout.fillWidth: true
+
+              implicitHeight: 10
+
+              color: "#50ffffff"
+
+              Rectangle {
+                anchors {
+                  left: parent.left
+                  top: parent.top
+                  bottom: parent.bottom
+                }
+
+                color: Pipewire.defaultAudioSink?.audio.muted ? "#70ffffff" : "white"
+
+                implicitWidth: parent.width * (Pipewire.defaultAudioSink?.audio.volume ?? 0)
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/WallpaperBackground.qml b/accounts/gkleen@sif/shell/quickshell/WallpaperBackground.qml
new file mode 100644
index 00000000..de31915f
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/WallpaperBackground.qml
@@ -0,0 +1,85 @@
+import QtQuick
+import Quickshell
+import qs.Services
+
+Item {
+  id: root
+
+  anchors.fill: parent
+
+  required property string screen
+
+  property Img current: one
+  property string source: selector.selected
+
+  WallpaperSelector {
+    id: selector
+    seed: screen
+  }
+
+  onSourceChanged: {
+    if (!source)
+      current = null;
+    else if (current === one)
+      two.update()
+    else
+      one.update()
+  }
+
+  Img { id: one }
+  Img { id: two }
+
+  component Img: Image {
+    id: img
+
+    function update() {
+      source = root.source || ""
+    }
+
+    anchors.fill: parent
+    fillMode: Image.PreserveAspectCrop
+    smooth: true
+    asynchronous: true
+    cache: false
+
+    opacity: 0
+
+    onStatusChanged: {
+      if (status === Image.Ready) {
+        root.current = this
+      }
+    }
+
+    states: State {
+      name: "visible"
+      when: root.current === img
+
+      PropertyChanges {
+        img.opacity: 1
+      }
+      StateChangeScript {
+        name: "unloadOther"
+        script: {
+          if (img === one)
+            two.source = ""
+          if (img === two)
+            one.source = ""
+        }
+      }
+    }
+
+    transitions: Transition {
+      SequentialAnimation {
+        NumberAnimation {
+          target: img
+          properties: "opacity"
+          duration: 5000
+          easing.type: Easing.OutCubic
+        }
+        ScriptAction {
+          scriptName: "unloadOther"
+        }
+      }
+    }
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/WorkspaceSwitcher.qml b/accounts/gkleen@sif/shell/quickshell/WorkspaceSwitcher.qml
index 153c56bb..c8c017c3 100644
--- a/accounts/gkleen@sif/shell/quickshell/WorkspaceSwitcher.qml
+++ b/accounts/gkleen@sif/shell/quickshell/WorkspaceSwitcher.qml
@@ -1,5 +1,8 @@
+import Quickshell
 import QtQuick
 import qs.Services
+import Quickshell.Widgets
+import QtQuick.Layouts
 
 Row {
   id: workspaces
@@ -11,61 +14,188 @@ Row {
   spacing: 0
 
   Repeater {
-    model: {
-      let currWorkspaces = NiriService.workspaces;
-      const ignoreWorkspaces = Array.from(workspaces.ignoreWorkspaces);
-      currWorkspaces = currWorkspaces.filter(ws => ws.is_active || ignoreWorkspaces.every(iws => iws !== ws.name));
-      currWorkspaces.sort((a, b) => {
-        if (NiriService.outputs?.[a.output]?.logical?.x !== NiriService.outputs?.[b.output]?.logical?.x)
-          return NiriService.outputs?.[a.output]?.logical?.x - NiriService.outputs?.[b.output]?.logical?.x
-        if (NiriService.outputs?.[a.output]?.logical?.y !== NiriService.outputs?.[b.output]?.logical?.y)
-          return NiriService.outputs?.[a.output]?.logical?.y - NiriService.outputs?.[b.output]?.logical?.y
-        return a.idx - b.idx;
-      });
-      return currWorkspaces;
+    model: ScriptModel {
+      values: {
+        let currWorkspaces = NiriService.workspaces;
+        const ignoreWorkspaces = Array.from(workspaces.ignoreWorkspaces);
+        currWorkspaces = currWorkspaces.filter(ws => ws.is_active || ignoreWorkspaces.every(iws => iws !== ws.name));
+        currWorkspaces.sort((a, b) => {
+          if (NiriService.outputs?.[a.output]?.logical?.x !== NiriService.outputs?.[b.output]?.logical?.x)
+            return NiriService.outputs?.[a.output]?.logical?.x - NiriService.outputs?.[b.output]?.logical?.x
+          if (NiriService.outputs?.[a.output]?.logical?.y !== NiriService.outputs?.[b.output]?.logical?.y)
+            return NiriService.outputs?.[a.output]?.logical?.y - NiriService.outputs?.[b.output]?.logical?.y
+          return a.idx - b.idx;
+        });
+        return currWorkspaces;
+      }
     }
 
-    Rectangle {
+    Item {
+      id: wsItem
+
       property var workspaceData: modelData
 
       width: wsLabel.contentWidth + 8
-      color: {
-        if (mouseArea.containsMouse) {
-          return "#33808080";
-        }
-        return "transparent";
-      }
       height: parent.height
       anchors.verticalCenter: parent.verticalCenter
 
-      MouseArea {
+      WrapperMouseArea {
         id: mouseArea
 
         anchors.fill: parent
+
         hoverEnabled: true
         cursorShape: Qt.PointingHandCursor
         enabled: true
         onClicked: {
           NiriService.sendCommand({ "Action": { "FocusWorkspace": { "reference": { "Id": workspaceData.id } } } }, _ => {})
         }
+
+        Rectangle {
+          anchors.fill: parent
+
+          color: {
+            if (mouseArea.containsMouse) {
+              return "#33808080";
+            }
+            return "transparent";
+          }
+
+          Text {
+            id: wsLabel
+
+            anchors.centerIn: parent
+
+            font.pointSize: 10
+            font.family: "Fira Sans"
+            color: {
+              if (workspaceData.is_active)
+                return "#23fd00";
+              if (workspaceData.active_window_id === null)
+                return "#555";
+              return "white";
+            }
+
+            text: workspaceData.name ? workspaceData.name : workspaceData.idx
+          }
+        }
       }
 
-      Text {
-        id: wsLabel
-
-        font.pointSize: 10
-        font.family: "Fira Sans"
-        color: {
-          if (workspaceData.is_active)
-            return "#23fd00";
-          if (workspaceData.active_window_id === null)
-            return "#555";
-          return "white";
+      PopupWindow {
+        id: tooltip
+
+        property bool nextVisible: (mouseArea.containsMouse || tooltipMouseArea.containsMouse) && [...windowsModel.values].length > 0
+
+        anchor {
+          item: mouseArea
+          edges: Edges.Bottom | Edges.Left
+        }
+        visible: false
+
+        onNextVisibleChanged: hangTimer.restart()
+
+        Timer {
+          id: hangTimer
+          interval: 100
+          onTriggered: tooltip.visible = tooltip.nextVisible
         }
-        anchors.centerIn: parent
 
-        text: workspaceData.name ? workspaceData.name : workspaceData.idx
+        implicitWidth: tooltipContent.implicitWidth
+        implicitHeight: tooltipContent.implicitHeight
+        color: "black"
+
+        WrapperMouseArea {
+          id: tooltipMouseArea
+
+          hoverEnabled: true
+          enabled: true
+
+          anchors.fill: parent
+
+          WrapperItem {
+            id: tooltipContent
+
+            margin: 0
+
+            ColumnLayout  {
+              spacing: 0
+
+              Repeater {
+                model: ScriptModel {
+                  id: windowsModel
+
+                  values: {
+                    let currWindows = Array.from(NiriService.windows).filter(win => win.workspace_id == wsItem.workspaceData.id);
+                    currWindows.sort((a, b) => {
+                      if (a.is_floating !== b.is_floating)
+                        return b.is_floating - a.is_floating;
+                      if (a.layout.tile_pos_in_workspace_view?.[0] !== b.layout.tile_pos_in_workspace_view?.[0])
+                        return a.layout.tile_pos_in_workspace_view?.[0] - b.layout.tile_pos_in_workspace_view?.[0]
+                      if (a.layout.tile_pos_in_workspace_view?.[1] !== b.layout.tile_pos_in_workspace_view?.[1])
+                        return a.layout.tile_pos_in_workspace_view?.[1] - b.layout.tile_pos_in_workspace_view?.[1]
+                      if (a.layout.pos_in_scrolling_layout?.[0] !== b.layout.pos_in_scrolling_layout?.[0])
+                        return a.layout.pos_in_scrolling_layout?.[0] - b.layout.pos_in_scrolling_layout?.[0]
+                      if (a.layout.pos_in_scrolling_layout?.[1] !== b.layout.pos_in_scrolling_layout?.[1])
+                        return a.layout.pos_in_scrolling_layout?.[1] - b.layout.pos_in_scrolling_layout?.[1]
+                      if (a.app_id !== b.app_id)
+                        return a.app_id.localeCompare(b.app_id);
+
+                      return a.title.localeCompare(b.title);
+                    });
+                    return currWindows;
+                  }
+                }
+
+                WrapperMouseArea {
+                  id: windowMouseArea
+
+                  property var windowData: modelData
+
+                  hoverEnabled: true
+                  cursorShape: Qt.PointingHandCursor
+                  enabled: true
+
+                  Layout.fillWidth: true
+
+                  onClicked: {
+                    NiriService.sendCommand({ "Action": { "FocusWindow": { "id": windowData.id } } }, _ => {})
+                  }
+
+                  WrapperRectangle {
+                    color: windowMouseArea.containsMouse ? "#33808080" : "transparent";
+
+                    anchors.fill: parent
+
+                    WrapperItem {
+                      anchors.fill: parent
+
+                      margin: 4
+
+                      Text {
+                        id: windowLabel
+
+                        font.pointSize: 10
+                        font.family: "Fira Sans"
+                        color: {
+                          if (windowData.is_focused)
+                            return "#23fd00";
+                          if (NiriService.workspaces.find(ws => ws.id == windowData.workspace_id)?.active_window_id == windowData.id)
+                            return "white";
+                          return "#555";
+                        }
+
+                        text: windowData.title
+
+                        horizontalAlignment: Text.AlignLeft
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
       }
     }
   }
-}
\ No newline at end of file
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/displaymanager.qml b/accounts/gkleen@sif/shell/quickshell/displaymanager.qml
new file mode 100644
index 00000000..b452c03d
--- /dev/null
+++ b/accounts/gkleen@sif/shell/quickshell/displaymanager.qml
@@ -0,0 +1,115 @@
+//@ pragma UseQApplication
+
+import Quickshell
+import Quickshell.Wayland
+import Quickshell.Io
+import Quickshell.Services.Greetd
+import QtQml
+
+
+ShellRoot {
+  id: displaymanager
+
+  settings.watchFiles: false
+
+  property string currentText: ""
+  property string username: @username@
+  property list<string> command: @niri_session@
+  property list<var> messages: []
+  property bool responseRequired: false
+  property bool responseVisible: false
+
+  signal startAuth()
+
+  onStartAuth: {
+    if (Greetd.state !== GreetdState.Inactive)
+      Greetd.cancelSession();
+    displaymanager.messages = [];
+    Greetd.createSession(displaymanager.username);
+  }
+
+  Connections {
+    target: Greetd
+    function onStateChanged() {
+      console.log("greetd state: ", GreetdState.toString(Greetd.state));
+      if (Greetd.state === GreetdState.ReadyToLaunch)
+        Greetd.launch(displaymanager.command);
+    }
+    function onAuthMessage(message: string, error: bool, responseRequired: bool, echoResponse: bool) {
+      displaymanager.responseVisible = echoResponse;
+      displaymanager.responseRequired = responseRequired;
+      displaymanager.messages = Array.from(displaymanager.messages).concat([{ "text": message, "error": error }]);
+    }
+    function onAuthFailure(message: string) {
+      displaymanager.responseRequired = false;
+      displaymanager.messages = Array.from(displaymanager.messages).concat([{ "text": message, "error": true }]);
+    }
+  }
+
+  Component.onCompleted: {
+    if (Greetd.state !== GreetdState.Inactive)
+      Greetd.cancelSession();
+  }
+
+  Variants {
+    model: Quickshell.screens
+
+    delegate: Scope {
+      id: screenScope
+
+      required property var modelData
+
+      PanelWindow {
+        color: "black"
+
+        screen: screenScope.modelData
+
+        WlrLayershell.keyboardFocus: WlrKeyboardFocus.Exclusive
+
+        anchors.top: true
+        anchors.bottom: true
+        anchors.left: true
+        anchors.right: true
+
+        LockSurface {
+          id: surfaceContent
+
+          screen: screenScope.modelData
+
+          onCurrentTextChanged: displaymanager.currentText = currentText
+          Connections {
+            target: displaymanager
+            function onCurrentTextChanged() { surfaceContent.currentText = displaymanager.currentText; }
+            function onMessagesChanged() { surfaceContent.messages = Array.from(displaymanager.messages); }
+            function onResponseRequiredChanged() { surfaceContent.responseRequired = displaymanager.responseRequired; }
+            function onResponseVisibleChanged() { surfaceContent.responseVisible = displaymanager.responseVisible; }
+          }
+
+          onResponse: responseText => Greetd.respond(responseText);
+          Connections {
+            target: Greetd
+            function onStateChanged() {
+              if (Greetd.state === GreetdState.Authenticating) {
+                surfaceContent.authRunning = true;
+              } else {
+                surfaceContent.authRunning = false;
+              }
+            }
+          }
+
+          onAuthRunningChanged: {
+            if (surfaceContent.authRunning && Greetd.state !== GreetdState.Authenticating)
+              displaymanager.startAuth();
+          }
+          Component.onCompleted: {
+            surfaceContent.authRunning = Greetd.state === GreetdState.Authenticating
+            surfaceContent.messages = Array.from(displaymanager.messages);
+            surfaceContent.responseVisible = displaymanager.responseVisible;
+            surfaceContent.responseRequired = displaymanager.responseRequired;
+            surfaceContent.currentText = displaymanager.currentText;
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/accounts/gkleen@sif/shell/quickshell/shell.qml b/accounts/gkleen@sif/shell/quickshell/shell.qml
index 4934cd4d..3657f77f 100644
--- a/accounts/gkleen@sif/shell/quickshell/shell.qml
+++ b/accounts/gkleen@sif/shell/quickshell/shell.qml
@@ -1,6 +1,7 @@
 //@ pragma UseQApplication
 
 import Quickshell
+import Quickshell.Wayland
 
 ShellRoot {
   settings.watchFiles: false
@@ -13,11 +14,33 @@ ShellRoot {
 
       required property var modelData
 
-      Bar {
-        id: bar
+      PanelWindow {
+        id: bgWindow
 
         screen: screenScope.modelData
+
+        WlrLayershell.layer: WlrLayer.Background
+        WlrLayershell.exclusionMode: ExclusionMode.Ignore
+
+        anchors.top: true
+        anchors.bottom: true
+        anchors.left: true
+        anchors.right: true
+
+        color: "black"
+
+        WallpaperBackground {
+          screen: bgWindow.screen.name
+        }
+      }
+
+      Bar {
+        screen: screenScope.modelData
       }
     }
   }
+
+  Lockscreen {}
+
+  VolumeOSD {}
 }
diff --git a/accounts/gkleen@sif/systemd.nix b/accounts/gkleen@sif/systemd.nix
index 1539126c..4543103f 100644
--- a/accounts/gkleen@sif/systemd.nix
+++ b/accounts/gkleen@sif/systemd.nix
@@ -351,8 +351,6 @@ in {
     xembed-sni-proxy = {
       Unit = {
         PartOf = lib.mkForce ["tray.target"];
-        BindsTo = ["xwayland-satellite.service"];
-        After = ["xwayland-satellite.service"];
       };
     };
     poweralertd = {
diff --git a/hosts/sif/default.nix b/hosts/sif/default.nix
index ed85ca17..952b95f9 100644
--- a/hosts/sif/default.nix
+++ b/hosts/sif/default.nix
@@ -655,7 +655,7 @@ in {
         "org.freedesktop.impl.portal.OpenFile" = ["gtk"];
         "org.freedesktop.impl.portal.Access" = ["gtk"];
         "org.freedesktop.impl.portal.Notification" = ["gtk"];
-        "org.freedesktop.impl.portal.Secret" = ["gnome-keyring"];
+        "org.freedesktop.impl.portal.Secret" = ["none"];
         "org.freedesktop.impl.portal.Inhibit" = ["none"];
       };
     };
@@ -684,7 +684,7 @@ in {
       timezone = true;
     };
 
-    security.pam.services.gtklock = {};
+    security.pam.services.quickshell = {};
 
     home-manager.sharedModules = [ flakeInputs.nixVirt.homeModules.default ];
 
diff --git a/hosts/sif/greetd/default.nix b/hosts/sif/greetd/default.nix
index 37ca13c5..081b6346 100644
--- a/hosts/sif/greetd/default.nix
+++ b/hosts/sif/greetd/default.nix
@@ -1,49 +1,92 @@
-{ pkgs, ... }:
-{
+{ config, pkgs, lib, flakeInputs, ... }:
+
+let
+  gkleenConfig = config.home-manager.users."gkleen";
+  toIni = lib.generators.toINI {
+    mkKeyValue =
+      key: value:
+      let
+        value' = if lib.isBool value then lib.boolToString value else toString value;
+      in
+      "${lib.escape [ "=" ] key}=${value'}";
+  };
+  toDconfIni = let
+    gvariant = import (flakeInputs.home-manager + "/modules/lib/gvariant.nix") { inherit lib; };
+    mkIniKeyValue = key: value: "${key}=${toString (gvariant.mkValue value)}";
+  in lib.generators.toINI { mkKeyValue = mkIniKeyValue; };
+in {
   config = {
     services.greetd = {
       enable = true;
-    #   settings.default_session.command = let
-    #     cfg = config.programs.regreet;
-    #   in pkgs.writeShellScript "greeter" ''
-    #       modprobe -r nvidia_drm
+      settings.default_session.command = lib.getExe (pkgs.writeShellApplication {
+        name = "sway";
+        runtimeInputs = [ pkgs.sway pkgs.fontconfig ];
+        runtimeEnv = {
+          XDG_DATA_DIRS = lib.makeSearchPath "share" [
+            pkgs.equilux-theme pkgs.paper-icon-theme pkgs.fira
+          ];
+          QT_PLUGIN_PATH = lib.makeSearchPath (pkgs.qt6.qtbase.qtPluginPrefix) [
+            pkgs.qt6Packages.qtbase
+          ];
+          QML2_IMPORT_PATH = lib.makeSearchPath (pkgs.qt6.qtbase.qtQmlPrefix) [
+            pkgs.qt6Packages.qtbase
+          ];
+          QT_QPA_PLATFORMTHEME = "gtk3";
+          XDG_CONFIG_DIR = pkgs.symlinkJoin {
+            name = "config";
+            paths = [
+              (pkgs.writeTextDir "gtk-3.0/settings.ini" (toIni {
+                Settings = {
+                  gtk-font-name = "Fira Sans 10";
+                  gtk-theme-name = "Equilux-compact";
+                  gtk-icon-theme-name = "Paper-Mono-Dark";
+                };
+              }))
+            ];
+          };
+          # XDG_CACHE_HOME = "/var/cache/greetd/greeter";
+          # XDG_CONFIG_HOME = "/var/cache/greetd/greeter/config";
+        };
+        text = ''
+          exec &>/tmp/sway-$$.log
+
+          unset MANAGERPID SYSTEMD_EXEC_PID
+
+          # ${lib.getExe' pkgs.coreutils "mkdir"} -p ''${XDG_CONFIG_HOME}/dconf
+          ${lib.getExe pkgs.dconf} load / < ${pkgs.writeText "dconf.ini" (toDconfIni {
+            "org/gnome/desktop/interface" = {
+              "color-scheme" = "prefer-dark";
+              "font-name" = "Fira Sans 10";
+              "gtk-theme" = "Equilux-compact";
+              "icon-theme" = "Paper-Mono-Dark";
+            };
+          })}
+
+          exec sway --unsupported-gpu --config ${pkgs.writeText "sway-config" ''
+            exec "${lib.getExe' config.systemd.package "systemctl"} --user import-environment {,WAYLAND_}DISPLAY SWAYSOCK; ${lib.getExe gkleenConfig.programs.quickshell.package} --path ${gkleenConfig.xdg.configFile."quickshell".source}/displaymanager.qml; swaymsg exit"
 
-    #       exec ${pkgs.dbus}/bin/dbus-run-session ${lib.getExe pkgs.cage} ${lib.escapeShellArgs cfg.cageArgs} -- ${lib.getExe cfg.package}
-    #     '';
+            input type:keyboard {
+              xkb_layout "us,us"
+              xkb_variant "dvp,"
+              xkb_options "compose:caps,grp:win_space_toggle"
+            }
+
+            output eDP-1 scale 1.5
+          ''}
+        '';
+      });
     };
-    systemd.services.greetd.environment = {
-      XKB_DEFAULT_LAYOUT = "us,us";
-      XKB_DEFAULT_VARIANT = "dvp,";
-      XKB_DEFAULT_OPTIONS = "compose:caps,grp:win_space_toggle";
+
+    # security.pam.services.greetd.fprintAuth = false;
+
+    systemd.services.greetd.serviceConfig = {
+      ExecStartPre = ''${lib.getExe' pkgs.coreutils "install"} -d -o greeter -g greeter -m 0700 ''${CACHE_DIRECTORY}/greeter'';
+      # CacheDirectory = "greetd";
     };
-    programs.regreet = {
-      enable = true;
-      theme = {
-        package = pkgs.equilux-theme;
-        name = "Equilux-compact";
-      };
-      iconTheme = {
-        package = pkgs.paper-icon-theme;
-        name = "Paper-Mono-Dark";
-      };
-      font = {
-        package = pkgs.fira;
-        name = "Fira Sans";
-        # size = 6;
-      };
-      cageArgs = [ "-s" "-m" "last" ];
-      settings = {
-        GTK.application_prefer_dark_theme = true;
-        widget.clock.format = "%F %H:%M:%S%:z";
-        background = {
-          path = pkgs.runCommand "wallpaper.png" {
-            buildInputs = with pkgs; [ imagemagick ];
-          } ''
-            magick ${./wallpaper.png} -filter Gaussian -resize 6.25% -define filter:sigma=2.5 -resize 1600% "$out"
-          '';
-          fit = "Cover";
-        };
-      };
+
+    users.users.greeter = {
+      home = "/var/lib/greeter";
+      createHome = true;
     };
   };
 }
diff --git a/hosts/sif/greetd/wallpaper.png b/hosts/sif/greetd/wallpaper.png
deleted file mode 100644
index 20fc761a..00000000
--- a/hosts/sif/greetd/wallpaper.png
+++ /dev/null
diff --git a/overlays/quickshell/default.nix b/overlays/quickshell/default.nix
new file mode 100644
index 00000000..622d69a3
--- /dev/null
+++ b/overlays/quickshell/default.nix
@@ -0,0 +1,10 @@
+{ final, prev, ... }:
+{
+  quickshell = prev.quickshell.overrideAttrs (oldAttrs: {
+    patches = (oldAttrs.patches or []) ++ [
+      ./greetd-response.patch
+      ./lock-state-changed.patch
+      ./pipewire.patch
+    ];
+  });
+}
diff --git a/overlays/quickshell/greetd-response.patch b/overlays/quickshell/greetd-response.patch
new file mode 100644
index 00000000..a0efb562
--- /dev/null
+++ b/overlays/quickshell/greetd-response.patch
@@ -0,0 +1,16 @@
+diff --git c/src/services/greetd/connection.cpp w/src/services/greetd/connection.cpp
+index bf0d1fd..a790ab7 100644
+--- c/src/services/greetd/connection.cpp
++++ w/src/services/greetd/connection.cpp
+@@ -225,6 +225,11 @@ void GreetdConnection::onSocketReady() {
+ 
+                this->mResponseRequired = responseRequired;
+                emit this->authMessage(message, error, responseRequired, echoResponse);
++
++               if (!responseRequired)
++                       this->sendRequest({
++                               {"type", "post_auth_message_response"}
++                       });
+        } else goto unexpected;
+ 
+        return;
diff --git a/overlays/quickshell/lock-state-changed.patch b/overlays/quickshell/lock-state-changed.patch
new file mode 100644
index 00000000..4be273fa
--- /dev/null
+++ b/overlays/quickshell/lock-state-changed.patch
@@ -0,0 +1,12 @@
+diff --git i/src/wayland/session_lock.cpp w/src/wayland/session_lock.cpp
+index 0ecf9ec..3dbd19b 100644
+--- i/src/wayland/session_lock.cpp
++++ w/src/wayland/session_lock.cpp
+@@ -127,6 +127,7 @@ void WlSessionLock::realizeLockTarget(WlSessionLock* old) {
+                this->updateSurfaces(false);
+ 
+                if (!this->manager->lock()) this->lockTarget = false;
++               emit this->lockStateChanged();
+ 
+                this->updateSurfaces(true, old);
+        } else {
diff --git a/overlays/quickshell/pipewire.patch b/overlays/quickshell/pipewire.patch
new file mode 100644
index 00000000..33025d8b
--- /dev/null
+++ b/overlays/quickshell/pipewire.patch
@@ -0,0 +1,460 @@
+diff --git i/src/services/pipewire/device.cpp w/src/services/pipewire/device.cpp
+index 616e7d0..0c55008 100644
+--- i/src/services/pipewire/device.cpp
++++ w/src/services/pipewire/device.cpp
+@@ -3,6 +3,7 @@
+ #include <cstdint>
+ #include <functional>
+ #include <utility>
++#include <algorithm>
+ 
+ #include <pipewire/device.h>
+ #include <qcontainerfwd.h>
+@@ -19,6 +20,8 @@
+ #include <spa/pod/pod.h>
+ #include <spa/pod/vararg.h>
+ #include <spa/utils/type.h>
++#include <spa/monitor/device.h>
++#include <spa/utils/keys.h>
+ 
+ #include "../../core/logcat.hpp"
+ #include "core.hpp"
+@@ -46,6 +49,25 @@ void PwDevice::unbindHooks() {
+        this->mWaitingForDevice = false;
+ }
+ 
++void PwDevice::initProps(const spa_dict* props) {
++       if (const auto* deviceName = spa_dict_lookup(props, SPA_KEY_DEVICE_NAME)) {
++               this->name = deviceName;
++       }
++
++       if (const auto* deviceDesc = spa_dict_lookup(props, SPA_KEY_DEVICE_DESCRIPTION)) {
++               this->description = deviceDesc;
++       }
++
++       if (const auto* deviceNick = spa_dict_lookup(props, SPA_KEY_DEVICE_NICK)) {
++               this->nick = deviceNick;
++       }
++
++       if (const auto* mediaClass = spa_dict_lookup(props, SPA_KEY_MEDIA_CLASS)) {
++               this->type = mediaClass;
++       }
++}
++
++
+ const pw_device_events PwDevice::EVENTS = {
+     .version = PW_VERSION_DEVICE_EVENTS,
+     .info = &PwDevice::onInfo,
+@@ -71,6 +93,11 @@ void PwDevice::onInfo(void* data, const pw_device_info* info) {
+                                }
+ 
+                                break;
++                       } else if (param.id == SPA_PARAM_EnumProfile && param.flags & SPA_PARAM_INFO_READ) {
++                               self->validProfiles.clear();
++                               pw_device_enum_params(self->proxy(), 0, param.id, 0, UINT32_MAX, nullptr);
++                       } else if (param.id == SPA_PARAM_Profile && param.flags & SPA_PARAM_INFO_READ) {
++                               pw_device_enum_params(self->proxy(), 0, param.id, 0, UINT32_MAX, nullptr);
+                        }
+                }
+        }
+@@ -97,6 +124,15 @@ void PwDevice::onParam(
+                }
+ 
+                self->addDeviceIndexPairs(param);
++       } else if (id == SPA_PARAM_EnumProfile) {
++               PwProfile profile = PwProfile::parseSpaPod(param);
++               self->profilesUpdated = true;
++               self->profiles.insertOrAssign(profile.index, profile);
++               self->validProfiles.insert(profile.index);
++       } else if (id == SPA_PARAM_Profile) {
++               PwProfile profile = PwProfile::parseSpaPod(param);
++               self->currentProfileUpdated = true;
++               self->currentProfile = profile;
+        }
+ }
+ 
+@@ -145,6 +181,21 @@ void PwDevice::polled() {
+                        return false;
+                });
+        }
++       if (this->profilesUpdated) {
++               this->profiles.removeIf([&](const std::pair<qint32, PwProfile>& entry) {
++                       return !this->validProfiles.contains(entry.first);
++               });
++               this->profilesUpdated = false;
++               QList<PwProfile> profiles = this->profiles.values();
++               std::sort(profiles.begin(), profiles.end(), [](const PwProfile& a, const PwProfile& b) { return a.index < b.index; });
++               emit this->profilesChanged(profiles);
++       }
++       if (this->currentProfileUpdated) {
++               this->currentProfileUpdated = false;
++               if (this->currentProfile) {
++                       emit this->currentProfileChanged(*this->currentProfile);
++               }
++       }
+ }
+ 
+ bool PwDevice::setVolumes(qint32 routeDevice, const QVector<float>& volumes) {
+@@ -182,6 +233,15 @@ bool PwDevice::setMuted(qint32 routeDevice, bool muted) {
+        });
+ }
+ 
++void PwDevice::setProfile(qint32 profileIndex) {
++       auto buffer = std::array<uint8_t, 1024>();
++       auto builder = SPA_POD_BUILDER_INIT(buffer.data(), buffer.size());
++       auto* pod = spa_pod_builder_add_object(&builder,
++               SPA_TYPE_OBJECT_ParamProfile, SPA_PARAM_Profile,
++               SPA_PARAM_PROFILE_index, SPA_POD_Int(profileIndex));
++       pw_device_set_param(this->proxy(), SPA_PARAM_Profile, 0, static_cast<spa_pod*>(pod));
++}
++
+ void PwDevice::waitForDevice() { this->mWaitingForDevice = true; }
+ bool PwDevice::waitingForDevice() const { return this->mWaitingForDevice; }
+ 
+@@ -222,4 +282,24 @@ bool PwDevice::setRouteProps(
+        return true;
+ }
+ 
++PwProfile PwProfile::parseSpaPod(const spa_pod* param) {
++       PwProfile profile;
++
++       const auto* indexProp = spa_pod_find_prop(param, nullptr, SPA_PARAM_PROFILE_index);
++       const auto* descProp = spa_pod_find_prop(param, nullptr, SPA_PARAM_PROFILE_description);
++       const auto* nameProp = spa_pod_find_prop(param, nullptr, SPA_PARAM_PROFILE_name);
++
++       spa_pod_get_int(&indexProp->value, &profile.index);
++
++       const char* desc_cstr = nullptr;
++       spa_pod_get_string(&descProp->value, &desc_cstr);
++       profile.description = QString(desc_cstr);
++
++       const char* name_cstr = nullptr;
++       spa_pod_get_string(&nameProp->value, &name_cstr);
++       profile.name = QString(name_cstr);
++
++       return profile;
++}
++
+ } // namespace qs::service::pipewire
+diff --git i/src/services/pipewire/device.hpp w/src/services/pipewire/device.hpp
+index 1a1f705..ee64858 100644
+--- i/src/services/pipewire/device.hpp
++++ w/src/services/pipewire/device.hpp
+@@ -1,6 +1,7 @@
+ #pragma once
+ 
+ #include <functional>
++#include <optional>
+ 
+ #include <pipewire/core.h>
+ #include <pipewire/device.h>
+@@ -17,6 +18,20 @@
+ 
+ namespace qs::service::pipewire {
+ 
++struct PwProfile {
++       Q_GADGET;
++       Q_PROPERTY(qint32 index MEMBER index)
++       Q_PROPERTY(QString description MEMBER description)
++       Q_PROPERTY(QString name MEMBER name)
++
++public:
++       qint32 index;
++       QString description;
++       QString name;
++
++       static PwProfile parseSpaPod(const spa_pod* param);
++};
++
+ class PwDevice;
+ 
+ class PwDevice: public PwBindable<pw_device, PW_TYPE_INTERFACE_Device, PW_VERSION_DEVICE> {
+@@ -25,6 +40,12 @@ class PwDevice: public PwBindable<pw_device, PW_TYPE_INTERFACE_Device, PW_VERSIO
+ public:
+        void bindHooks() override;
+        void unbindHooks() override;
++       void initProps(const spa_dict* props) override;
++
++       QString name;
++       QString description;
++       QString nick;
++       QString type;
+ 
+        bool setVolumes(qint32 routeDevice, const QVector<float>& volumes);
+        bool setMuted(qint32 routeDevice, bool muted);
+@@ -32,9 +53,16 @@ public:
+        void waitForDevice();
+        [[nodiscard]] bool waitingForDevice() const;
+ 
++       void setProfile(qint32 profileIndex);
++
++       QHash<qint32, PwProfile> profiles;
++       std::optional<PwProfile> currentProfile;
++
+ signals:
+        void deviceReady();
+        void routeVolumesChanged(qint32 routeDevice, const PwVolumeProps& volumeProps);
++       void profilesChanged(QList<PwProfile> profiles);
++        void currentProfileChanged(PwProfile profile);
+ 
+ private slots:
+        void polled();
+@@ -49,6 +77,11 @@ private:
+        QList<qint32> stagingIndexes;
+        void addDeviceIndexPairs(const spa_pod* param);
+ 
++       bool profilesUpdated = false;
++       QSet<qint32> validProfiles;
++
++       bool currentProfileUpdated = false;
++
+        bool
+        setRouteProps(qint32 routeDevice, const std::function<void*(spa_pod_builder*)>& propsCallback);
+ 
+diff --git i/src/services/pipewire/qml.cpp w/src/services/pipewire/qml.cpp
+index 9efb17e..921d12a 100644
+--- i/src/services/pipewire/qml.cpp
++++ w/src/services/pipewire/qml.cpp
+@@ -9,6 +9,9 @@
+ #include <qtypes.h>
+ #include <qvariant.h>
+ 
++#include <cstdint>
++#include <algorithm>
++
+ #include "../../core/model.hpp"
+ #include "connection.hpp"
+ #include "defaults.hpp"
+@@ -54,6 +57,12 @@ Pipewire::Pipewire(QObject* parent): QObject(parent) {
+ 
+        QObject::connect(&connection->registry, &PwRegistry::nodeAdded, this, &Pipewire::onNodeAdded);
+ 
++       for (auto* device: connection->registry.devices.values()) {
++               this->onDeviceAdded(device);
++       }
++
++       QObject::connect(&connection->registry, &PwRegistry::deviceAdded, this, &Pipewire::onDeviceAdded);
++
+        for (auto* link: connection->registry.links.values()) {
+                this->onLinkAdded(link);
+        }
+@@ -123,6 +132,19 @@ void Pipewire::onNodeRemoved(QObject* object) {
+        this->mNodes.removeObject(iface);
+ }
+ 
++ObjectModel<PwDeviceIface>* Pipewire::devices() { return &this->mDevices; }
++
++void Pipewire::onDeviceAdded(PwDevice* device) {
++       auto* iface = PwDeviceIface::instance(device);
++       QObject::connect(iface, &QObject::destroyed, this, &Pipewire::onDeviceRemoved);
++       this->mDevices.insertObject(iface);
++}
++
++void Pipewire::onDeviceRemoved(QObject* object) {
++       auto* iface = static_cast<PwDeviceIface*>(object); // NOLINT
++       this->mDevices.removeObject(iface);
++}
++
+ ObjectModel<PwLinkIface>* Pipewire::links() { return &this->mLinks; }
+ 
+ void Pipewire::onLinkAdded(PwLink* link) {
+@@ -357,6 +379,8 @@ QVariantMap PwNodeIface::properties() const {
+ 
+ PwNodeAudioIface* PwNodeIface::audio() const { return this->audioIface; }
+ 
++PwDeviceIface* PwNodeIface::device() const { return PwDeviceIface::instance(this->mNode->device); }
++
+ PwNodeIface* PwNodeIface::instance(PwNode* node) {
+        if (node == nullptr) return nullptr;
+ 
+@@ -481,4 +505,42 @@ void PwObjectTracker::objectDestroyed(QObject* object) {
+        emit this->objectsChanged();
+ }
+ 
++PwDeviceIface::PwDeviceIface(PwDevice* device): PwObjectIface(device), mDevice(device) {
++       QObject::connect(device, &PwDevice::profilesChanged, this, &PwDeviceIface::deviceProfilesChanged);
++       QObject::connect(device, &PwDevice::currentProfileChanged, this, &PwDeviceIface::deviceCurrentProfileChanged);
++}
++
++void PwDeviceIface::deviceProfilesChanged(QList<PwProfile>) { emit this->profilesChanged(); }
++void PwDeviceIface::deviceCurrentProfileChanged(PwProfile) { emit this->currentProfileChanged(); }
++
++quint32 PwDeviceIface::id() const { return this->mDevice->id; }
++QString PwDeviceIface::name() const { return this->mDevice->name; }
++QString PwDeviceIface::description() const { return this->mDevice->description; }
++QString PwDeviceIface::nickname() const { return this->mDevice->nick; }
++QString PwDeviceIface::type() const { return this->mDevice->type; }
++QList<PwProfile> PwDeviceIface::profiles() const {
++       QList<PwProfile> profiles = this->mDevice->profiles.values();
++       std::sort(profiles.begin(), profiles.end(), [](const PwProfile& a, const PwProfile& b) { return a.index < b.index; });
++       return profiles;
++}
++qint32 PwDeviceIface::currentProfile() const { return this->mDevice->currentProfile->index; }
++
++PwDeviceIface* PwDeviceIface::instance(PwDevice* device) {
++       if (device == nullptr) return nullptr;
++
++       auto v = device->property("iface");
++       if (v.canConvert<PwDeviceIface*>()) {
++               return v.value<PwDeviceIface*>();
++       }
++
++       auto* instance = new PwDeviceIface(device);
++       device->setProperty("iface", QVariant::fromValue(instance));
++
++       return instance;
++}
++
++void PwDeviceIface::setProfile(qint32 profileIndex) {
++       this->mDevice->setProfile(profileIndex);
++}
++
+ } // namespace qs::service::pipewire
+diff --git i/src/services/pipewire/qml.hpp w/src/services/pipewire/qml.hpp
+index e3489a1..e5e1891 100644
+--- i/src/services/pipewire/qml.hpp
++++ w/src/services/pipewire/qml.hpp
+@@ -12,11 +12,13 @@
+ #include "../../core/model.hpp"
+ #include "link.hpp"
+ #include "node.hpp"
++#include "device.hpp"
+ #include "registry.hpp"
+ 
+ namespace qs::service::pipewire {
+ 
+ class PwNodeIface;
++class PwDeviceIface;
+ class PwLinkIface;
+ class PwLinkGroupIface;
+ 
+@@ -65,6 +67,8 @@ class Pipewire: public QObject {
+        /// - @@PwNode.audio - if non null the node is an audio node.
+        QSDOC_TYPE_OVERRIDE(ObjectModel<qs::service::pipewire::PwNodeIface>*);
+        Q_PROPERTY(UntypedObjectModel* nodes READ nodes CONSTANT);
++       QSDOC_TYPE_OVERRIDE(ObjectModel<qs::service::pipewire::PwDeviceIface>*);
++       Q_PROPERTY(UntypedObjectModel* devices READ devices CONSTANT);
+        /// All links present in pipewire.
+        ///
+        /// Links connect pipewire nodes to each other, and can be used to determine
+@@ -134,6 +138,7 @@ public:
+        explicit Pipewire(QObject* parent = nullptr);
+ 
+        [[nodiscard]] ObjectModel<PwNodeIface>* nodes();
++       [[nodiscard]] ObjectModel<PwDeviceIface>* devices();
+        [[nodiscard]] ObjectModel<PwLinkIface>* links();
+        [[nodiscard]] ObjectModel<PwLinkGroupIface>* linkGroups();
+ 
+@@ -159,7 +164,9 @@ signals:
+ 
+ private slots:
+        void onNodeAdded(PwNode* node);
++       void onDeviceAdded(PwDevice* node);
+        void onNodeRemoved(QObject* object);
++       void onDeviceRemoved(QObject* object);
+        void onLinkAdded(PwLink* link);
+        void onLinkRemoved(QObject* object);
+        void onLinkGroupAdded(PwLinkGroup* group);
+@@ -167,6 +174,7 @@ private slots:
+ 
+ private:
+        ObjectModel<PwNodeIface> mNodes {this};
++       ObjectModel<PwDeviceIface> mDevices {this};
+        ObjectModel<PwLinkIface> mLinks {this};
+        ObjectModel<PwLinkGroupIface> mLinkGroups {this};
+ };
+@@ -315,6 +323,7 @@ class PwNodeIface: public PwObjectIface {
+        /// > [!NOTE] The node may be used before it is fully bound, but some data
+        /// > may be missing or incorrect.
+        Q_PROPERTY(bool ready READ isReady NOTIFY readyChanged);
++       Q_PROPERTY(qs::service::pipewire::PwDeviceIface* device READ device CONSTANT);
+        QML_NAMED_ELEMENT(PwNode);
+        QML_UNCREATABLE("PwNodes cannot be created directly");
+ 
+@@ -332,6 +341,7 @@ public:
+        [[nodiscard]] PwNodeType::Flags type() const;
+        [[nodiscard]] QVariantMap properties() const;
+        [[nodiscard]] PwNodeAudioIface* audio() const;
++       [[nodiscard]] PwDeviceIface* device() const;
+ 
+        static PwNodeIface* instance(PwNode* node);
+ 
+@@ -344,6 +354,44 @@ private:
+        PwNodeAudioIface* audioIface = nullptr;
+ };
+ 
++class PwDeviceIface: public PwObjectIface {
++       Q_OBJECT;
++       Q_PROPERTY(quint32 id READ id CONSTANT);
++       Q_PROPERTY(QString name READ name CONSTANT);
++       Q_PROPERTY(QString description READ description CONSTANT);
++       Q_PROPERTY(QString nickname READ nickname CONSTANT);
++       Q_PROPERTY(QString type READ type CONSTANT);
++       Q_PROPERTY(QList<PwProfile> profiles READ profiles NOTIFY profilesChanged);
++       Q_PROPERTY(qint32 currentProfile READ currentProfile NOTIFY currentProfileChanged);
++
++       QML_NAMED_ELEMENT(PwDevice);
++       QML_UNCREATABLE("PwDevices cannot be created directly");
++
++signals:
++       void profilesChanged();
++       void currentProfileChanged();
++
++public:
++       explicit PwDeviceIface(PwDevice* node);
++
++       [[nodiscard]] quint32 id() const;
++       [[nodiscard]] QString name() const;
++       [[nodiscard]] QString description() const;
++       [[nodiscard]] QString nickname() const;
++       [[nodiscard]] QString type() const;
++       QList<PwProfile> profiles() const;
++       qint32 currentProfile() const;
++
++       Q_INVOKABLE void setProfile(qint32 profileIndex);
++
++       static PwDeviceIface* instance(PwDevice* node);
++private:
++       PwDevice* mDevice;
++
++       void deviceProfilesChanged(QList<PwProfile> profiles);
++       void deviceCurrentProfileChanged(PwProfile profile);
++};
++
+ ///! A connection between pipewire nodes.
+ /// Note that there is one link per *channel* of a connection between nodes.
+ /// You usually want @@PwLinkGroup.
+diff --git i/src/services/pipewire/registry.cpp w/src/services/pipewire/registry.cpp
+index c08fc1d..50c6d7a 100644
+--- i/src/services/pipewire/registry.cpp
++++ w/src/services/pipewire/registry.cpp
+@@ -196,6 +196,7 @@ void PwRegistry::onGlobal(
+                device->initProps(props);
+ 
+                self->devices.emplace(id, device);
++               emit self->deviceAdded(device);
+        }
+ }
+ 
+@@ -211,6 +212,9 @@ void PwRegistry::onGlobalRemoved(void* data, quint32 id) {
+        } else if (auto* node = self->nodes.value(id)) {
+                self->nodes.remove(id);
+                node->safeDestroy();
++       } else if (auto* device = self->devices.value(id)) {
++               self->devices.remove(id);
++               device->safeDestroy();
+        }
+ }
+ 
+diff --git i/src/services/pipewire/registry.hpp w/src/services/pipewire/registry.hpp
+index 8473f04..87e0766 100644
+--- i/src/services/pipewire/registry.hpp
++++ w/src/services/pipewire/registry.hpp
+@@ -132,6 +132,7 @@ public:
+ 
+ signals:
+        void nodeAdded(PwNode* node);
++       void deviceAdded(PwDevice* node);
+        void linkAdded(PwLink* link);
+        void linkGroupAdded(PwLinkGroup* group);
+        void metadataAdded(PwMetadata* metadata);
diff --git a/user-profiles/mpv/default.nix b/user-profiles/mpv/default.nix
index 94f241c8..48893f49 100644
--- a/user-profiles/mpv/default.nix
+++ b/user-profiles/mpv/default.nix
@@ -105,6 +105,7 @@
       };
       config = {
         ytdl = true;
+        ytdl-format = "ytdl";
         ytdl-raw-options = "sub-langs=\"${config.programs.yt-dlp.settings.sub-langs}\"";
         subs-with-matching-audio = false;
         audio-display = false;
diff --git a/user-profiles/yt-dlp.nix b/user-profiles/yt-dlp.nix
index 5c9858a6..9e30bba8 100644
--- a/user-profiles/yt-dlp.nix
+++ b/user-profiles/yt-dlp.nix
@@ -7,6 +7,10 @@
         cookies-from-browser = "firefox::none";
         mark-watched = true;
         format = lib.concatStringsSep "/" [
+          "bestvideo*[width<=2560][height<=1440][fps<=60][vcodec!*=av01][vcodec!*=avc1]+bestaudio"
+          "best[width<=2560][height<=1440][fps<=60][vcodec!*=av01][vcodec!*=avc1]"
+          "bestvideo*[vcodec!*=av01][vcodec!*=avc1]+bestaudio"
+          "best[vcodec!*=av01][vcodec!*=avc1]"
           "bestvideo*[width<=2560][height<=1440][fps<=60]+bestaudio"
           "best[width<=2560][height<=1440][fps<=60]"
           "bestvideo*+bestaudio"