diff --git a/.clang-tidy b/.clang-tidy
index 6642fa76..002c444d 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -5,6 +5,9 @@ Checks: >
   -*,
   bugprone-*,
   -bugprone-easily-swappable-parameters,
+  -bugprone-forward-declararion-namespace,
+  -bugprone-forward-declararion-namespace,
+  -bugprone-return-const-ref-from-parameter,
   concurrency-*,
   cppcoreguidelines-*,
   -cppcoreguidelines-owning-memory,
@@ -12,8 +15,11 @@ Checks: >
   -cppcoreguidelines-pro-bounds-constant-array-index,
   -cppcoreguidelines-avoid-const-or-ref-data-members,
   -cppcoreguidelines-non-private-member-variables-in-classes,
-  google-build-using-namespace.
-  google-explicit-constructor,
+  -cppcoreguidelines-avoid-goto,
+  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -cppcoreguidelines-avoid-do-while,
+  -cppcoreguidelines-pro-type-reinterpret-cast,
+  -cppcoreguidelines-pro-type-vararg,
   google-global-names-in-headers,
   google-readability-casting,
   google-runtime-int,
@@ -25,6 +31,7 @@ Checks: >
   -modernize-return-braced-init-list,
   -modernize-use-trailing-return-type,
   performance-*,
+  -performance-avoid-endl,
   portability-std-allocator-const,
   readability-*,
   -readability-function-cognitive-complexity,
@@ -35,6 +42,10 @@ Checks: >
   -readability-braces-around-statements,
   -readability-redundant-access-specifiers,
   -readability-else-after-return,
+  -readability-container-data-pointer,
+  -readability-implicit-bool-conversion,
+  -readability-avoid-nested-conditional-operator,
+  -readability-math-missing-parentheses,
   tidyfox-*,
 CheckOptions:
   performance-for-range-copy.WarnOnAllAutoCopies: true
diff --git a/.editorconfig b/.editorconfig
index 6b1b58df..9de26e09 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -9,3 +9,10 @@ indent_style = tab
 [*.nix]
 indent_style = space
 indent_size = 2
+
+[*.{yml,yaml}]
+indent_style = space
+indent_size = 2
+
+[*.scm]
+indent_style = space
\ No newline at end of file
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 00000000..0086358d
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1 @@
+blank_issues_enabled: true
diff --git a/.github/ISSUE_TEMPLATE/crash.yml b/.github/ISSUE_TEMPLATE/crash.yml
new file mode 100644
index 00000000..c8b4804e
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/crash.yml
@@ -0,0 +1,82 @@
+name: Crash Report
+description: Quickshell has crashed
+labels: ["bug", "crash"]
+body:
+  - type: textarea
+    id: crashinfo
+    attributes:
+      label: General crash information
+      description: |
+        Paste the contents of the `info.txt` file in your crash folder here.
+      value: "<details> <summary>General information</summary>
+
+
+        ```
+
+        <Paste the contents of the file here inside of the triple backticks>
+
+        ```
+
+
+        </details>"
+    validations:
+        required: true
+  - type: textarea
+    id: userinfo
+    attributes:
+      label: What caused the crash
+      description: |
+        Any information likely to help debug the crash. What were you doing when the crash occurred,
+        what changes did you make, can you get it to happen again?
+  - type: textarea
+    id: dump
+    attributes:
+      label: Minidump
+      description: |
+        Attach `minidump.dmp.log` here. If it is too big to upload, compress it.
+
+        You may skip this step if quickshell crashed while processing a password
+        or other sensitive information. If you skipped it write why instead.
+    validations:
+        required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: Log file
+      description: |
+        Attach `log.qslog.log` here. If it is too big to upload, compress it.
+
+        You can preview the log if you'd like using `quickshell read-log <path-to-log>`.
+    validations:
+        required: true
+  - type: textarea
+    id: config
+    attributes:
+      label: Configuration
+      description: |
+        Attach your configuration here, preferrably in full (not just one file).
+        Compress it into a zip, tar, etc.
+
+        This will help us reproduce the crash ourselves.
+  - type: textarea
+    id: bt
+    attributes:
+      label: Backtrace
+      description: |
+        If you have gdb installed and use systemd, or otherwise know how to get a backtrace,
+        we would appreciate one. (You may have gdb installed without knowing it)
+
+        1. Run `coredumpctl debug <pid>` where `pid` is the number shown after "Crashed process ID"
+        in the crash reporter.
+        2. Once it loads, type `bt -full` (then enter)
+        3. Copy the output and attach it as a file or in a spoiler.
+  - type: textarea
+    id: exe
+    attributes:
+      label: Executable
+      description: |
+        If the crash folder contains a executable.txt file, upload it here. If not you can ignore this field.
+        If it is too big to upload, compress it.
+
+        Note: executable.txt is the quickshell binary. It has a .txt extension due to github's limitations on
+        filetypes.
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 00000000..93b84585
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,56 @@
+name: Build
+on: [push, pull_request, workflow_dispatch]
+
+jobs:
+  nix:
+    name: Nix
+    strategy:
+      matrix:
+        qtver: [qt6.9.0, qt6.8.3, qt6.8.2, qt6.8.1, qt6.8.0, qt6.7.3, qt6.7.2, qt6.7.1, qt6.7.0, qt6.6.3, qt6.6.2, qt6.6.1, qt6.6.0]
+        compiler: [clang, gcc]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      # Use cachix action over detsys for testing with act.
+      # - uses: cachix/install-nix-action@v27
+      - uses: DeterminateSystems/nix-installer-action@main
+
+      - name: Download Dependencies
+        run: nix-build --no-out-link --expr '((import ./ci/matrix.nix) { qtver = "${{ matrix.qtver }}"; compiler = "${{ matrix.compiler }}"; }).inputDerivation'
+
+      - name: Build
+        run: nix-build --no-out-link --expr '(import ./ci/matrix.nix) { qtver = "${{ matrix.qtver }}"; compiler = "${{ matrix.compiler }}"; }'
+
+  archlinux:
+    name: Archlinux
+    runs-on: ubuntu-latest
+    container: archlinux
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download Dependencies
+        run: |
+          pacman --noconfirm --noprogressbar -Syyu
+          pacman --noconfirm --noprogressbar -Sy \
+            base-devel \
+            cmake \
+            ninja \
+            pkgconf \
+            qt6-base \
+            qt6-declarative \
+            qt6-svg \
+            qt6-wayland \
+            qt6-shadertools \
+            wayland-protocols \
+            wayland \
+            libdrm \
+            libxcb \
+            libpipewire \
+            cli11 \
+            jemalloc
+
+      - name: Build
+        # breakpad is annoying to build in ci due to makepkg not running as root
+        run: |
+          cmake -GNinja -B build -DCRASH_REPORTER=OFF
+          cmake --build build
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
new file mode 100644
index 00000000..da329cc2
--- /dev/null
+++ b/.github/workflows/lint.yml
@@ -0,0 +1,25 @@
+name: Lint
+on: [push, pull_request, workflow_dispatch]
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      # Use cachix action over detsys for testing with act.
+      # - uses: cachix/install-nix-action@v27
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: nicknovitski/nix-develop@v1
+
+      - name: Check formatting
+        run: clang-format -Werror --dry-run src/**/*.{cpp,hpp}
+
+      # required for lint
+      - name: Build
+        run: |
+          just configure debug -DNO_PCH=ON -DBUILD_TESTING=ON
+          just build
+
+      - name: Run lints
+        run: LC_ALL=en_US.UTF-8 LC_CTYPE=en_US.UTF-8 just lint-ci
diff --git a/.gitignore b/.gitignore
index 1933837e..dcdefe39 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,7 @@
+# related repos
+/docs
+/examples
+
 # build files
 /result
 /build/
diff --git a/.gitmodules b/.gitmodules
deleted file mode 100644
index 74013769..00000000
--- a/.gitmodules
+++ /dev/null
@@ -1,6 +0,0 @@
-[submodule "docs"]
-	path = docs
-	url = https://git.outfoxxed.me/outfoxxed/quickshell-docs
-[submodule "examples"]
-	path = examples
-	url = https://git.outfoxxed.me/outfoxxed/quickshell-examples
diff --git a/BUILD.md b/BUILD.md
new file mode 100644
index 00000000..aa7c98ae
--- /dev/null
+++ b/BUILD.md
@@ -0,0 +1,251 @@
+# Build instructions
+Instructions for building from source and distro packagers. We highly recommend
+distro packagers read through this page fully.
+
+## Packaging
+If you are packaging quickshell for official or unofficial distribution channels,
+such as a distro package repository, user repository, or other shared build location,
+please set the following CMake flags.
+
+`-DDISTRIBUTOR="your distribution platform"`
+
+Please make this descriptive enough to identify your specific package, for example:
+- `Official Nix Flake`
+- `AUR (quickshell-git)`
+- `Nixpkgs`
+- `Fedora COPR (errornointernet/quickshell)`
+
+`-DDISTRIBUTOR_DEBUGINFO_AVAILABLE=YES/NO`
+
+If we can retrieve binaries and debug information for the package without actually running your
+distribution (e.g. from an website), and you would like to strip the binary, please set this to `YES`.
+
+If we cannot retrieve debug information, please set this to `NO` and
+**ensure you aren't distributing stripped (non debuggable) binaries**.
+
+In both cases you should build with `-DCMAKE_BUILD_TYPE=RelWithDebInfo` (then split or keep the debuginfo).
+
+### QML Module dir
+Currently all QML modules are statically linked to quickshell, but this is where
+tooling information will go.
+
+`-DINSTALL_QML_PREFIX="path/to/qml"`
+
+`-DINSTALL_QMLDIR="/full/path/to/qml"`
+
+`INSTALL_QML_PREFIX` works the same as `INSTALL_QMLDIR`, except it prepends `CMAKE_INSTALL_PREFIX`. You usually want this.
+
+## Dependencies
+Quickshell has a set of base dependencies you will always need, names vary by distro:
+
+- `cmake`
+- `qt6base`
+- `qt6declarative`
+- `qtshadertools` (build-time)
+- `spirv-tools` (build-time)
+- `pkg-config` (build-time)
+- `cli11` (static library)
+
+Build time dependencies and static libraries don't have to exist at runtime,
+however build time dependencies must be compiled for the architecture of
+the builder, while static libraries must be compiled for the architecture
+of the target.
+
+On some distros, private Qt headers are in separate packages which you may have to install.
+We currently require private headers for the following libraries:
+
+- `qt6declarative`
+- `qt6wayland`
+
+We recommend an implicit dependency on `qt6svg`. If it is not installed, svg images and
+svg icons will not work, including system ones.
+
+At least Qt 6.6 is required.
+
+All features are enabled by default and some have their own dependencies.
+
+### Crash Reporter
+The crash reporter catches crashes, restarts quickshell when it crashes,
+and collects useful crash information in one place. Leaving this enabled will
+enable us to fix bugs far more easily.
+
+To disable: `-DCRASH_REPORTER=OFF`
+
+Dependencies: `google-breakpad` (static library)
+
+### Jemalloc
+We recommend leaving Jemalloc enabled as it will mask memory fragmentation caused
+by the QML engine, which results in much lower memory usage. Without this you
+will get a perceived memory leak.
+
+To disable: `-DUSE_JEMALLOC=OFF`
+
+Dependencies: `jemalloc`
+
+### Unix Sockets
+This feature allows interaction with unix sockets and creating socket servers
+which is useful for IPC and has no additional dependencies.
+
+WARNING: Disabling unix sockets will NOT make it safe to run arbitrary code using quickshell.
+There are many vectors which mallicious code can use to escape into your system.
+
+To disable: `-DSOCKETS=OFF`
+
+### Wayland
+This feature enables wayland support. Subfeatures exist for each particular wayland integration.
+
+WARNING: Wayland integration relies on features that are not part of the public Qt API and which
+may break in minor releases. Updating quickshell's dependencies without ensuring without ensuring
+that the current Qt version is supported WILL result in quickshell failing to build or misbehaving
+at runtime.
+
+Currently supported Qt versions: `6.6`, `6.7`.
+
+To disable: `-DWAYLAND=OFF`
+
+Dependencies:
+ - `qt6wayland`
+ - `wayland` (libwayland-client)
+ - `wayland-scanner` (build time)
+ - `wayland-protocols` (static library)
+
+Note that one or both of `wayland-scanner` and `wayland-protocols` may be bundled
+with you distro's wayland package.
+
+#### Wlroots Layershell
+Enables wlroots layershell integration through the [zwlr-layer-shell-v1] protocol,
+enabling use cases such as bars overlays and backgrounds.
+This feature has no extra dependencies.
+
+To disable: `-DWAYLAND_WLR_LAYERSHELL=OFF`
+
+[zwlr-layer-shell-v1]: https://wayland.app/protocols/wlr-layer-shell-unstable-v1
+
+#### Session Lock
+Enables session lock support through the [ext-session-lock-v1] protocol,
+which allows quickshell to be used as a session lock under compatible wayland compositors.
+
+To disable: `-DWAYLAND_SESSION_LOCK=OFF`
+
+[ext-session-lock-v1]: https://wayland.app/protocols/ext-session-lock-v1
+
+
+#### Foreign Toplevel Management
+Enables management of windows of other clients through the [zwlr-foreign-toplevel-management-v1] protocol,
+which allows quickshell to be used as a session lock under compatible wayland compositors.
+
+[zwlr-foreign-toplevel-management-v1]: https://wayland.app/protocols/wlr-foreign-toplevel-management-unstable-v1
+
+To disable: `-DWAYLAND_TOPLEVEL_MANAGEMENT=OFF`
+
+#### Screencopy
+Enables streaming video from monitors and toplevel windows through various protocols.
+
+To disable: `-DSCREENCOPY=OFF`
+
+Dependencies:
+- `libdrm`
+- `libgbm`
+
+Specific protocols can also be disabled:
+- `DSCREENCOPY_ICC=OFF` - Disable screencopy via [ext-image-copy-capture-v1]
+- `DSCREENCOPY_WLR=OFF` - Disable screencopy via [zwlr-screencopy-v1]
+- `DSCREENCOPY_HYPRLAND_TOPLEVEL=OFF` - Disable screencopy via [hyprland-toplevel-export-v1]
+
+[ext-image-copy-capture-v1]:https://wayland.app/protocols/ext-image-copy-capture-v1
+[zwlr-screencopy-v1]: https://wayland.app/protocols/wlr-screencopy-unstable-v1
+[hyprland-toplevel-export-v1]: https://wayland.app/protocols/hyprland-toplevel-export-v1
+
+### X11
+This feature enables x11 support. Currently this implements panel windows for X11 similarly
+to the wlroots layershell above.
+
+To disable: `-DX11=OFF`
+
+Dependencies: `libxcb`
+
+### Pipewire
+This features enables viewing and management of pipewire nodes.
+
+To disable: `-DSERVICE_PIPEWIRE=OFF`
+
+Dependencies: `libpipewire`
+
+### StatusNotifier / System Tray
+This feature enables system tray support using the status notifier dbus protocol.
+
+To disable: `-DSERVICE_STATUS_NOTIFIER=OFF`
+
+Dependencies: `qt6dbus` (usually part of qt6base)
+
+### MPRIS
+This feature enables access to MPRIS compatible media players using its dbus protocol.
+
+To disable: `-DSERVICE_MPRIS=OFF`
+
+Dependencies: `qt6dbus` (usually part of qt6base)
+
+### PAM
+This feature enables PAM integration for user authentication.
+
+To disable: `-DSERVICE_PAM=OFF`
+
+Dependencies: `pam`
+
+### Hyprland
+This feature enables hyprland specific integrations. It requires wayland support
+but has no extra dependencies.
+
+To disable: `-DHYPRLAND=OFF`
+
+#### Hyprland Global Shortcuts
+Enables creation of global shortcuts under hyprland through the [hyprland-global-shortcuts-v1]
+protocol. Generally a much nicer alternative to using unix sockets to implement the same thing.
+This feature has no extra dependencies.
+
+To disable: `-DHYPRLAND_GLOBAL_SHORTCUTS=OFF`
+
+[hyprland-global-shortcuts-v1]: https://github.com/hyprwm/hyprland-protocols/blob/main/protocols/hyprland-global-shortcuts-v1.xml
+
+#### Hyprland Focus Grab
+Enables windows to grab focus similarly to a context menu under hyprland through the
+[hyprland-focus-grab-v1] protocol. This feature has no extra dependencies.
+
+To disable: `-DHYPRLAND_FOCUS_GRAB=OFF`
+
+[hyprland-focus-grab-v1]: https://github.com/hyprwm/hyprland-protocols/blob/main/protocols/hyprland-focus-grab-v1.xml
+
+### i3/Sway
+Enables i3 and Sway specific features, does not have any dependency on Wayland or x11.
+
+To disable: `-DI3=OFF`
+
+#### i3/Sway IPC
+Enables interfacing with i3 and Sway's IPC.
+
+To disable: `-DI3_IPC=OFF`
+
+## Building
+*For developers and prospective contributors: See [CONTRIBUTING.md](CONTRIBUTING.md).*
+
+Only `ninja` builds are tested, but makefiles may work.
+
+#### Configuring the build
+```sh
+$ cmake -GNinja -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo [additional disable flags from above here]
+```
+
+Note that features you do not supply dependencies for MUST be disabled with their associated flags
+or quickshell will fail to build.
+
+Additionally, note that clang builds much faster than gcc if you care.
+
+#### Building
+```sh
+$ cmake --build build
+```
+
+#### Installing
+```sh
+$ cmake --install build
+```
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 67f8a1fe..55b5e5d5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,35 +1,93 @@
 cmake_minimum_required(VERSION 3.20)
-project(quickshell VERSION "0.1.0")
+project(quickshell VERSION "0.2.0" LANGUAGES CXX C)
 
 set(QT_MIN_VERSION "6.6.0")
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-option(TESTS "Build tests" OFF)
+set(QS_BUILD_OPTIONS "")
 
-option(SOCKETS "Enable unix socket support" ON)
-option(WAYLAND "Enable wayland support" ON)
-option(WAYLAND_WLR_LAYERSHELL "Support the zwlr_layer_shell_v1 wayland protocol" ON)
-option(WAYLAND_SESSION_LOCK "Support the ext_session_lock_v1 wayland protocol" ON)
+function(boption VAR NAME DEFAULT)
+	cmake_parse_arguments(PARSE_ARGV 3 arg "" "REQUIRES" "")
+
+	option(${VAR} ${NAME} ${DEFAULT})
+
+	set(STATUS "${VAR}_status")
+	set(EFFECTIVE "${VAR}_effective")
+	set(${STATUS} ${${VAR}})
+	set(${EFFECTIVE} ${${VAR}})
+
+	if (${${VAR}} AND DEFINED arg_REQUIRES)
+		set(REQUIRED_EFFECTIVE "${arg_REQUIRES}_effective")
+		if (NOT ${${REQUIRED_EFFECTIVE}})
+			set(${STATUS} "OFF (Requires ${arg_REQUIRES})")
+			set(${EFFECTIVE} OFF)
+		endif()
+	endif()
+
+	set(${EFFECTIVE} "${${EFFECTIVE}}" PARENT_SCOPE)
+
+	message(STATUS "  ${NAME}: ${${STATUS}}")
+
+	string(APPEND QS_BUILD_OPTIONS "\\n  ${NAME}: ${${STATUS}}")
+	set(QS_BUILD_OPTIONS "${QS_BUILD_OPTIONS}" PARENT_SCOPE)
+endfunction()
+
+set(DISTRIBUTOR "Unset" CACHE STRING "Distributor")
+string(APPEND QS_BUILD_OPTIONS "  Distributor: ${DISTRIBUTOR}")
 
 message(STATUS "Quickshell configuration")
-message(STATUS "  Build tests: ${BUILD_TESTING}")
-message(STATUS "  Sockets: ${SOCKETS}")
-message(STATUS "  Wayland: ${WAYLAND}")
-if (WAYLAND)
-	message(STATUS "    Wlroots Layershell: ${WAYLAND_WLR_LAYERSHELL}")
-	message(STATUS "    Session Lock: ${WAYLAND_SESSION_LOCK}")
-endif ()
+message(STATUS "  Distributor: ${DISTRIBUTOR}")
+boption(DISTRIBUTOR_DEBUGINFO_AVAILABLE "Distributor provided debuginfo" NO)
+boption(NO_PCH "Disable precompild headers (dev)" OFF)
+boption(BUILD_TESTING "Build tests (dev)" OFF)
+boption(ASAN "ASAN (dev)" OFF) # note: better output with gcc than clang
+boption(FRAME_POINTERS "Keep Frame Pointers (dev)" ${ASAN})
 
-if (NOT DEFINED GIT_REVISION)
-	execute_process(
-		COMMAND git rev-parse HEAD
-		WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-		OUTPUT_VARIABLE GIT_REVISION
-	)
+boption(CRASH_REPORTER "Crash Handling" ON)
+boption(USE_JEMALLOC "Use jemalloc" ON)
+boption(SOCKETS "Unix Sockets" ON)
+boption(WAYLAND "Wayland" ON)
+boption(WAYLAND_WLR_LAYERSHELL "  Wlroots Layer-Shell" ON REQUIRES WAYLAND)
+boption(WAYLAND_SESSION_LOCK "  Session Lock" ON REQUIRES WAYLAND)
+boption(WAYLAND_TOPLEVEL_MANAGEMENT "  Foreign Toplevel Management" ON REQUIRES WAYLAND)
+boption(HYPRLAND "  Hyprland" ON REQUIRES WAYLAND)
+boption(HYPRLAND_IPC "    Hyprland IPC" ON REQUIRES HYPRLAND)
+boption(HYPRLAND_GLOBAL_SHORTCUTS "    Hyprland Global Shortcuts" ON REQUIRES HYPRLAND)
+boption(HYPRLAND_FOCUS_GRAB "    Hyprland Focus Grabbing" ON REQUIRES HYPRLAND)
+boption(HYPRLAND_SURFACE_EXTENSIONS "    Hyprland Surface Extensions" ON REQUIRES HYPRLAND)
+boption(SCREENCOPY "  Screencopy" ON REQUIRES WAYLAND)
+boption(SCREENCOPY_ICC "    Image Copy Capture" ON REQUIRES WAYLAND)
+boption(SCREENCOPY_WLR "    Wlroots Screencopy" ON REQUIRES WAYLAND)
+boption(SCREENCOPY_HYPRLAND_TOPLEVEL "    Hyprland Toplevel Export" ON REQUIRES WAYLAND)
+boption(X11 "X11" ON)
+boption(I3 "I3/Sway" ON)
+boption(I3_IPC "  I3/Sway IPC" ON REQUIRES I3)
+boption(SERVICE_STATUS_NOTIFIER "System Tray" ON)
+boption(SERVICE_PIPEWIRE "PipeWire" ON)
+boption(SERVICE_MPRIS "Mpris" ON)
+boption(SERVICE_PAM "Pam" ON)
+boption(SERVICE_GREETD "Greetd" ON)
+boption(SERVICE_UPOWER "UPower" ON)
+boption(SERVICE_NOTIFICATIONS "Notifications" ON)
+boption(BLUETOOTH "Bluetooth" ON)
+
+include(cmake/install-qml-module.cmake)
+include(cmake/util.cmake)
+
+add_compile_options(-Wall -Wextra -Wno-vla-cxx-extension)
+
+# pipewire defines this, breaking PCH
+add_compile_definitions(_REENTRANT)
+
+if (FRAME_POINTERS)
+	add_compile_options(-fno-omit-frame-pointer)
 endif()
 
-add_compile_options(-Wall -Wextra)
+if (ASAN)
+	add_compile_options(-fsanitize=address)
+	add_link_options(-fsanitize=address)
+endif()
 
 # nix workaround
 if (CMAKE_EXPORT_COMPILE_COMMANDS)
@@ -41,34 +99,61 @@ if (NOT CMAKE_BUILD_TYPE)
 	set(CMAKE_BUILD_TYPE Debug)
 endif()
 
-set(QT_DEPS Qt6::Gui Qt6::Qml Qt6::Quick Qt6::QuickControls2)
-set(QT_FPDEPS Gui Qml Quick QuickControls2)
+set(QT_FPDEPS Gui Qml Quick QuickControls2 Widgets ShaderTools)
+
+include(cmake/pch.cmake)
 
 if (BUILD_TESTING)
 	enable_testing()
+	add_definitions(-DQS_TEST)
 	list(APPEND QT_FPDEPS Test)
 endif()
 
 if (SOCKETS)
-	list(APPEND QT_DEPS Qt6::Network)
 	list(APPEND QT_FPDEPS Network)
 endif()
 
 if (WAYLAND)
-	list(APPEND QT_DEPS Qt6::WaylandClient Qt6::WaylandClientPrivate)
 	list(APPEND QT_FPDEPS WaylandClient)
 endif()
 
+if (SERVICE_STATUS_NOTIFIER OR SERVICE_MPRIS OR SERVICE_UPOWER OR SERVICE_NOTIFICATIONS OR BLUETOOTH)
+	set(DBUS ON)
+endif()
+
+if (DBUS)
+	list(APPEND QT_FPDEPS DBus)
+endif()
+
 find_package(Qt6 REQUIRED COMPONENTS ${QT_FPDEPS})
 
+set(CMAKE_AUTOUIC OFF)
 qt_standard_project_setup(REQUIRES 6.6)
 set(QT_QML_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/qml_modules)
 
-add_subdirectory(src/core)
-add_subdirectory(src/io)
+add_subdirectory(src)
 
-if (WAYLAND)
-	add_subdirectory(src/wayland)
-endif ()
+if (USE_JEMALLOC)
+	find_package(PkgConfig REQUIRED)
+	# IMPORTED_TARGET not working for some reason
+	pkg_check_modules(JEMALLOC REQUIRED jemalloc)
+	target_link_libraries(quickshell PRIVATE ${JEMALLOC_LIBRARIES})
+endif()
 
-install(TARGETS quickshell RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(CODE "
+	execute_process(
+		COMMAND ${CMAKE_COMMAND} -E create_symlink \
+		${CMAKE_INSTALL_FULL_BINDIR}/quickshell \$ENV{DESTDIR}${CMAKE_INSTALL_FULL_BINDIR}/qs
+	)
+")
+
+install(
+	FILES ${CMAKE_SOURCE_DIR}/assets/org.quickshell.desktop
+	DESTINATION ${CMAKE_INSTALL_DATADIR}/applications
+)
+
+install(
+	FILES ${CMAKE_SOURCE_DIR}/assets/quickshell.svg
+	DESTINATION ${CMAKE_INSTALL_DATADIR}/icons/hicolor/scalable/apps
+	RENAME org.quickshell.svg
+)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 00000000..39fab13e
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,235 @@
+# Contributing / Development
+Instructions for development setup and upstreaming patches.
+
+If you just want to build or package quickshell see [BUILD.md](BUILD.md).
+
+## Development
+
+Install the dependencies listed in [BUILD.md](BUILD.md).
+You probably want all of them even if you don't use all of them
+to ensure tests work correctly and avoid passing a bunch of configure
+flags when you need to wipe the build directory.
+
+Quickshell also uses `just` for common development command aliases.
+
+The dependencies are also available as a nix shell or nix flake which we recommend
+using with nix-direnv.
+
+Common aliases:
+- `just configure [<debug|release> [extra cmake args]]` (note that you must specify debug/release to specify extra args)
+- `just build` - runs the build, configuring if not configured already.
+- `just run [args]` - runs quickshell with the given arguments
+- `just clean` - clean up build artifacts. `just clean build` is somewhat common.
+
+### Formatting
+All contributions should be formatted similarly to what already exists.
+Group related functionality together.
+
+Run the formatter using `just fmt`.
+If the results look stupid, fix the clang-format file if possible,
+or disable clang-format in the affected area
+using `// clang-format off` and `// clang-format on`.
+
+#### Style preferences not caught by clang-format
+These are flexible. You can ignore them if it looks or works better to
+for one reason or another.
+
+Use `auto` if the type of a variable can be deduced automatically, instead of
+redeclaring the returned value's type. Additionally, auto should be used when a
+constructor takes arguments.
+
+```cpp
+auto x = <expr>; // ok
+auto x = QString::number(3); // ok
+QString x; // ok
+QString x = "foo"; // ok
+auto x = QString("foo"); // ok
+
+auto x = QString(); // avoid
+QString x(); // avoid
+QString x("foo"); // avoid
+```
+
+Put newlines around logical units of code, and after closing braces. If the
+most reasonable logical unit of code takes only a single line, it should be
+merged into the next single line logical unit if applicable.
+```cpp
+// multiple units
+auto x = <expr>; // unit 1
+auto y = <expr>; // unit 2
+
+auto x = <expr>; // unit 1
+emit this->y(); // unit 2
+
+auto x1 = <expr>; // unit 1
+auto x2 = <expr>; // unit 1
+auto x3 = <expr>; // unit 1
+
+auto y1 = <expr>; // unit 2
+auto y2 = <expr>; // unit 2
+auto y3 = <expr>; // unit 2
+
+// one unit
+auto x = <expr>;
+if (x...) {
+  // ...
+}
+
+// if more than one variable needs to be used then add a newline
+auto x = <expr>;
+auto y = <expr>;
+
+if (x && y) {
+  // ...
+}
+```
+
+Class formatting:
+```cpp
+//! Doc comment summary
+/// Doc comment body
+class Foo: public QObject {
+  // The Q_OBJECT macro comes first. Macros are ; terminated.
+  Q_OBJECT;
+  QML_ELEMENT;
+  QML_CLASSINFO(...);
+  // Properties must stay on a single line or the doc generator won't be able to pick them up
+  Q_PROPERTY(...);
+  /// Doc comment
+  Q_PROPERTY(...);
+  /// Doc comment
+  Q_PROPERTY(...);
+
+public:
+  // Classes should have explicit constructors if they aren't intended to
+  // implicitly cast. The constructor can be inline in the header if it has no body.
+  explicit Foo(QObject* parent = nullptr): QObject(parent) {}
+
+  // Instance functions if applicable.
+  static Foo* instance();
+
+  // Member functions unrelated to properties come next
+  void function();
+  void function();
+  void function();
+
+  // Then Q_INVOKABLEs
+  Q_INVOKABLE function();
+  /// Doc comment
+  Q_INVOKABLE function();
+  /// Doc comment
+  Q_INVOKABLE function();
+
+  // Then property related functions, in the order (bindable, getter, setter).
+  // Related functions may be included here as well. Function bodies may be inline
+  // if they are a single expression. There should be a newline between each
+  // property's methods.
+  [[nodiscard]] QBindable<T> bindableFoo() { return &this->bFoo; }
+  [[nodiscard]] T foo() const { return this->foo; }
+  void setFoo();
+
+  [[nodiscard]] T bar() const { return this->foo; }
+  void setBar();
+
+signals:
+  // Signals that are not property change related go first.
+  // Property change signals go in property definition order.
+  void asd();
+  void asd2();
+  void fooChanged();
+  void barChanged();
+
+public slots:
+  // generally Q_INVOKABLEs are preferred to public slots.
+  void slot();
+
+private slots:
+  // ...
+
+private:
+  // statics, then functions, then fields
+  static const foo BAR;
+  static void foo();
+
+  void foo();
+  void bar();
+
+  // property related members are prefixed with `m`.
+  QString mFoo;
+  QString bar;
+
+  // Bindables go last and should be prefixed with `b`.
+  Q_OBJECT_BINDABLE_PROPERTY(Foo, QString, bFoo, &Foo::fooChanged);
+};
+```
+
+### Linter
+All contributions should pass the linter.
+
+Note that running the linter requires disabling precompiled
+headers and including the test codepaths:
+```sh
+$ just configure debug -DNO_PCH=ON -DBUILD_TESTING=ON
+$ just lint-changed
+```
+
+If the linter is complaining about something that you think it should not,
+please disable the lint in your MR and explain your reasoning if it isn't obvious.
+
+### Tests
+If you feel like the feature you are working on is very complex or likely to break,
+please write some tests. We will ask you to directly if you send in an MR for an
+overly complex or breakable feature.
+
+At least all tests that passed before your changes should still be passing
+by the time your contribution is ready.
+
+You can run the tests using `just test` but you must enable them first
+using `-DBUILD_TESTING=ON`.
+
+### Documentation
+Most of quickshell's documentation is automatically generated from the source code.
+You should annotate `Q_PROPERTY`s and `Q_INVOKABLE`s with doc comments. Note that the parser
+cannot handle random line breaks and will usually require you to disable clang-format if the
+lines are too long.
+
+Before submitting an MR, if adding new features please make sure the documentation is generated
+reasonably using the `quickshell-docs` repo. We recommend checking it out at `/docs` in this repo.
+
+Doc comments take the form `///` or `///!` (summary) and work with markdown.
+You can reference other types using the `@@[Module.][Type.][member]` shorthand
+where all parts are optional. If module or type are not specified they will
+be inferred as the current module. Member can be a `property`, `function()` or `signal(s)`.
+Look at existing code for how it works.
+
+Quickshell modules additionally have a `module.md` file which contains a summary, description,
+and list of headers to scan for documentation.
+
+## Contributing
+
+### Commits
+Please structure your commit messages as `scope[!]: commit` where
+the scope is something like `core` or `service/mpris`. (pick what has been
+used historically or what makes sense if new). Add `!` for changes that break
+existing APIs or functionality.
+
+Commit descriptions should contain a summary of the changes if they are not
+sufficiently addressed in the commit message.
+
+Please squash/rebase additions or edits to previous changes and follow the
+commit style to keep the history easily searchable at a glance.
+Depending on the change, it is often reasonable to squash it into just
+a single commit. (If you do not follow this we will squash your changes
+for you.)
+
+### Sending patches
+You may contribute by submitting a pull request on github, asking for
+an account on our git server, or emailing patches / git bundles
+directly to `outfoxxed@outfoxxed.me`.
+
+### Getting help
+If you're getting stuck, you can come talk to us in the
+[quickshell-development matrix room](https://matrix.to/#/#quickshell-development:outfoxxed.me)
+for help on implementation, conventions, etc.
+Feel free to ask for advice early in your implementation if you are
+unsure.
diff --git a/Justfile b/Justfile
index 314bcdd5..f60771aa 100644
--- a/Justfile
+++ b/Justfile
@@ -4,7 +4,13 @@ fmt:
     find src -type f \( -name "*.cpp" -o -name "*.hpp" \) -print0 | xargs -0 clang-format -i
 
 lint:
-	find src -type f -name "*.cpp" -print0 | parallel -q0 --eta clang-tidy --load={{ env_var("TIDYFOX") }}
+	find src -type f -name "*.cpp" -print0 | parallel -j$(nproc) -q0 --no-notice --will-cite --tty --bar clang-tidy --load={{ env_var("TIDYFOX") }}
+
+lint-ci:
+	find src -type f -name "*.cpp" -print0 | parallel -j$(nproc) -q0 --no-notice --will-cite --tty clang-tidy --load={{ env_var("TIDYFOX") }}
+
+lint-changed:
+	git diff --name-only HEAD | grep "^.*\.cpp\$" |  parallel -j$(nproc) --no-notice --will-cite --tty --bar clang-tidy --load={{ env_var("TIDYFOX") }}
 
 configure target='debug' *FLAGS='':
 	cmake -GNinja -B {{builddir}} \
@@ -26,7 +32,7 @@ clean:
 	rm -rf {{builddir}}
 
 run *ARGS='': build
-	{{builddir}}/src/core/quickshell {{ARGS}}
+	{{builddir}}/src/quickshell {{ARGS}}
 
 test *ARGS='': build
 	ctest --test-dir {{builddir}} --output-on-failure {{ARGS}}
diff --git a/README.md b/README.md
index e075a322..4491d24b 100644
--- a/README.md
+++ b/README.md
@@ -1,107 +1,13 @@
-# quickshell
+# Quickshell
+See the [website](https://quickshell.outfoxxed.me) for more information
+and installation instructions.
 
-Simple and flexbile QtQuick based desktop shell toolkit.
+This repo is hosted at:
+- https://git.outfoxxed.me/quickshell/quickshell
+- https://github.com/quickshell-mirror/quickshell
 
-Hosts: [outfoxxed's gitea], [github]
-
-[outfoxxed's gitea]: https://git.outfoxxed.me/outfoxxed/quickshell
-[github]: https://github.com/outfoxxed/quickshell
-
-Documentation can be built from the [quickshell-docs](https://git.outfoxxed.me/outfoxxed/quickshell-docs) repo,
-though is currently pretty lacking.
-
-Some fully working examples can be found in the [quickshell-examples](https://git.outfoxxed.me/outfoxxed/quickshell-examples) 
-repo.
-
-Both the documentation and examples are included as submodules with revisions that work with the current
-version of quickshell.
-
-You can clone everything with
-```
-$ git clone --recursive https://git.outfoxxed.me/outfoxxed/quickshell.git
-```
-
-Or clone missing submodules later with
-```
-$ git submodule update --init --recursive
-```
-
-# Installation
-
-## Nix
-This repo has a nix flake you can use to install the package directly:
-
-```nix
-{
-  inputs = {
-    nixpkgs.url = "nixpkgs/nixos-unstable";
-
-    quickshell = {
-      url = "git+https://git.outfoxxed.me/outfoxxed/quickshell";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
-  };
-}
-```
-
-Quickshell's binary is available at `quickshell.packages.<system>.default` to be added to
-lists such as `environment.systemPackages` or `home.packages`.
-
-## Manual
-
-If not using nix, you'll have to build from source.
-
-### Dependencies
-To build quickshell at all, you will need the following packages (names may vary by distro)
-
-- just
-- cmake
-- pkg-config
-- ninja
-- Qt6 [ QtBase, QtDeclarative ]
-
-To build with wayland support you will additionally need:
-- wayland
-- wayland-scanner (may be part of wayland on some distros)
-- wayland-protocols
-- Qt6 [ QtWayland ]
-
-### Building
-
-To make a release build of quickshell run:
-```sh
-$ just release
-```
-
-If you have all the dependencies installed and they are in expected
-locations this will build correctly.
-
-To install to /usr/local/bin run as root (usually `sudo`) in the same folder:
-```
-$ just install
-```
-
-### Building (Nix)
-
-You can build directly using the provided nix flake or nix package.
-```
-nix build
-nix build -f package.nix # calls default.nix with a basic callPackage expression
-```
-
-# Development
-
-For nix there is a devshell available from `shell.nix` and as a devShell
-output from the flake.
-
-The Justfile contains various useful aliases:
-- `just configure [<debug|release> [extra cmake args]]`
-- `just build` (runs configure for debug mode)
-- `just run [args]`
-- `just clean`
-- `just test [args]` (configure with `-DBUILD_TESTING=ON` first)
-- `just fmt`
-- `just lint`
+# Contributing / Development
+See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
 
 #### License
 
diff --git a/assets/org.quickshell.desktop b/assets/org.quickshell.desktop
new file mode 100644
index 00000000..63f65fd9
--- /dev/null
+++ b/assets/org.quickshell.desktop
@@ -0,0 +1,7 @@
+[Desktop Entry]
+Version=1.5
+Type=Application
+NoDisplay=true
+
+Name=Quickshell
+Icon=org.quickshell
diff --git a/assets/quickshell.svg b/assets/quickshell.svg
new file mode 100644
index 00000000..7d0f9481
--- /dev/null
+++ b/assets/quickshell.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="724.635" height="724.635"><path fill="#359757" stroke="#359757" stroke-linecap="square" stroke-linejoin="round" stroke-width="74.755" d="m37.378 160.237 122.859-122.86h527.02v527.02l-122.86 122.86H37.378Z"/><path fill="#fff" stroke="#fff" stroke-linecap="round" stroke-linejoin="round" stroke-width="12.201" d="M323.051 96.412a268.74 268.74 0 0 0-3.51.542c-4.052 14.481-7.815 29.941-14.904 42.692a230.02 230.02 0 0 0-59.406 24.679c-14.036-3.974-27.647-12.214-40.766-19.562a268.788 268.788 0 0 0-60.035 60.16c7.376 13.105 15.645 26.698 19.648 40.726a230.02 230.02 0 0 0-24.554 59.458c-12.735 7.115-28.186 10.913-42.66 14.994a268.789 268.789 0 0 0 .09 84.992c14.48 4.05 29.941 7.814 42.691 14.903a230.02 230.02 0 0 0 24.68 59.406c-3.974 14.037-12.215 27.647-19.563 40.766a268.788 268.788 0 0 0 60.161 60.035c13.104-7.376 26.696-15.645 40.725-19.648a230.02 230.02 0 0 0 59.457 24.555c7.116 12.735 10.913 28.186 14.995 42.659a268.788 268.788 0 0 0 84.99-.09c4.052-14.482 7.817-29.941 14.906-42.691a230.02 230.02 0 0 0 59.405-24.68c14.037 3.974 33.069 17.638 46.188 24.986a268.788 268.788 0 0 0 60.035-60.161c-7.376-13.105-21.068-32.12-25.071-46.149a230.02 230.02 0 0 0 24.555-59.457c12.735-7.116 28.186-10.912 42.659-14.993a268.788 268.788 0 0 0-.089-84.993c-14.482-4.051-29.942-7.814-42.692-14.904a230.02 230.02 0 0 0-24.68-59.405c3.974-14.037 12.216-27.647 19.565-40.767a268.788 268.788 0 0 0-60.161-60.035c-13.105 7.376-26.698 15.645-40.726 19.649a230.02 230.02 0 0 0-59.458-24.555c-7.115-12.735-10.913-28.187-14.994-42.66a268.788 268.788 0 0 0-81.481-.452zm15.778 106.85c58.282-8.328 116.455 15.865 151.643 63.065 35.19 47.2 41.766 109.86 17.144 163.337l-41.728-22.688s-38.558 31.44-57.344 63.012l23.893 36.326a160.78 160.78 0 0 1-46.633 15.058c-87.854 12.99-169.6-47.708-182.573-135.564-12.974-87.855 47.74-169.59 135.598-182.546Z"/></svg>
diff --git a/changelog/v0.1.0.md b/changelog/v0.1.0.md
new file mode 100644
index 00000000..f8a032f2
--- /dev/null
+++ b/changelog/v0.1.0.md
@@ -0,0 +1 @@
+Initial release
diff --git a/changelog/v0.2.0.md b/changelog/v0.2.0.md
new file mode 100644
index 00000000..2fbf74d7
--- /dev/null
+++ b/changelog/v0.2.0.md
@@ -0,0 +1,84 @@
+## Breaking Changes
+
+- Files outside of the shell directory can no longer be referenced with relative paths, e.g. '../../foo.png'.
+- PanelWindow's Automatic exclusion mode now adds an exclusion zone for panels with a single anchor.
+- `QT_QUICK_CONTROLS_STYLE` and `QT_STYLE_OVERRIDE` are ignored unless `//@ pragma RespectSystemStyle` is set.
+
+## New Features
+
+### Root-Relative Imports
+
+Quickshell 0.2 comes with a new method to import QML modules which is supported by QMLLS.
+This replaces "root:/" imports for QML modules.
+
+The new syntax is `import qs.path.to.module`, where `path/to/module` is the path to
+a module/subdirectory relative to the config root (`qs`).
+
+### Better LSP support
+
+LSP support for Singletons and Root-Relative imports can be enabled by creating a file named
+`.qmlls.ini` in the shell root directory. Quickshell will detect this file and automatically
+populate it with an LSP configuration. This file should be gitignored in your configuration,
+as it is system dependent.
+
+The generated configuration also includes QML import paths available to Quickshell, meaning
+QMLLS no longer requires the `-E` flag.
+
+### Bluetooth Module
+
+Quickshell can now manage your bluetooth devices through BlueZ. While authenticated pairing
+has not landed in 0.2, support for connecting and disconnecting devices, basic device information,
+and non-authenticated pairing are now supported.
+
+### Other Features
+
+- Added `HyprlandToplevel` and related toplevel/window management APIs in the Hyprland module.
+- Added `Quickshell.execDetached()`, which spawns a detached process without a `Process` object.
+- Added `Process.exec()` for easier reconfiguration of process commands when starting them.
+- Added `FloatingWindow.title`, which allows changing the title of a floating window.
+- Added `signal QsWindow.closed()`, fired when a window is closed externally.
+- Added support for inline replies in notifications, when supported by applications.
+- Added `DesktopEntry.startupWmClass` and `DesktopEntry.heuristicLookup()` to better identify toplevels.
+- Added `DesktopEntry.command` which can be run as an alternative to `DesktopEntry.execute()`.
+- Added `//@ pragma Internal`, which makes a QML component impossible to import outside of its module.
+- Added dead instance selection for some subcommands, such as `qs log` and `qs list`.
+
+## Other Changes
+
+- `Quickshell.shellRoot` has been renamed to `Quickshell.shellDir`.
+- PanelWindow margins opposite the window's anchorpoint are now added to exclusion zone.
+- stdout/stderr or detached processes and executed desktop entries are now hidden by default.
+- Various warnings caused by other applications Quickshell communicates with over D-BUS have been hidden in logs.
+- Quickshell's new logo is now shown in any floating windows.
+
+## Bug Fixes
+
+- Fixed pipewire device volume and mute states not updating before the device has been used.
+- Fixed a crash when changing the volume of any pipewire device on a sound card another removed device was using.
+- Fixed a crash when accessing a removed previous default pipewire node from the default sink/source changed signals.
+- Fixed session locks crashing if all monitors are disconnected.
+- Fixed session locks crashing if unsupported by the compositor.
+- Fixed a crash when creating a session lock and destroying it before acknowledged by the compositor.
+- Fixed window input masks not updating after a reload.
+- Fixed PanelWindows being unconfigurable unless `screen` was set under X11.
+- Fixed a crash when anchoring a popup to a zero sized `Item`.
+- Fixed `FileView` crashing if `watchChanges` was used.
+- Fixed `SocketServer` sockets disappearing after a reload.
+- Fixed `ScreencopyView` having incorrect rotation when displaying a rotated monitor.
+- Fixed `MarginWrapperManager` breaking pixel alignment of child items when centering.
+- Fixed `IpcHandler`, `NotificationServer` and `GlobalShortcut` not activating with certain QML structures.
+- Fixed tracking of QML incubator destruction and deregistration, which occasionally caused crashes.
+- Fixed FloatingWindows being constrained to the smallest window manager supported size unless max size was set.
+- Fixed `MprisPlayer.lengthSupported` not updating reactively.
+- Fixed normal tray icon being ignored when status is `NeedsAttention` and no attention icon is provided.
+- Fixed `HyprlandWorkspace.activate()` sending invalid commands to Hyprland for named or special workspaces.
+- Fixed file watcher occasionally breaking when using VSCode to edit QML files.
+- Fixed crashes when screencopy buffer creation fails.
+- Fixed a crash when wayland layer surfaces are recreated for the same window.
+- Fixed the `QsWindow` attached object not working when using `WlrLayershell` directly.
+- Fixed a crash when attempting to create a window without available VRAM.
+- Fixed OOM crash when failing to write to detailed log file.
+- Prevented distro logging configurations for Qt from interfering with Quickshell commands.
+- Removed the "QProcess destroyed for running process" warning when destroying `Process` objects.
+- Fixed `ColorQuantizer` printing a pointer to an error message instead of an error message.
+- Fixed notification pixmap rowstride warning showing for correct rowstrides.
diff --git a/ci/matrix.nix b/ci/matrix.nix
new file mode 100644
index 00000000..be2da616
--- /dev/null
+++ b/ci/matrix.nix
@@ -0,0 +1,8 @@
+{
+  qtver,
+  compiler,
+}: let
+  nixpkgs = (import ./nix-checkouts.nix).${builtins.replaceStrings ["."] ["_"] qtver};
+  compilerOverride = (nixpkgs.callPackage ./variations.nix {}).${compiler};
+  pkg = (nixpkgs.callPackage ../default.nix {}).override compilerOverride;
+in pkg
diff --git a/ci/nix-checkouts.nix b/ci/nix-checkouts.nix
new file mode 100644
index 00000000..73c24156
--- /dev/null
+++ b/ci/nix-checkouts.nix
@@ -0,0 +1,78 @@
+let
+  byCommit = {
+    commit,
+    sha256,
+  }: import (builtins.fetchTarball {
+    name = "nixpkgs-${commit}";
+    url = "https://github.com/nixos/nixpkgs/archive/${commit}.tar.gz";
+    inherit sha256;
+  }) {};
+in {
+  # For old qt versions, grab the commit before the version bump that has all the patches
+  # instead of the bumped version.
+
+  qt6_9_0 = byCommit {
+    commit = "546c545bd0594809a28ab7e869b5f80dd7243ef6";
+    sha256 = "0562lbi67a9brfwzpqs4n3l0i8zvgla368aakcy5mghr7ps80567";
+  };
+
+  qt6_8_3 = byCommit {
+    commit = "374e6bcc403e02a35e07b650463c01a52b13a7c8";
+    sha256 = "1ck2d7q1f6k58qg47bc07036h9gmc2mqmqlgrv67k3frgplfhfga";
+  };
+
+  qt6_8_2 = byCommit {
+    commit = "97be9fbfc7a8a794bb51bd5dfcbfad5fad860512";
+    sha256 = "1sqh6kb8yg9yw6brkkb3n4y3vpbx8fnx45skyikqdqj2xs76v559";
+  };
+
+  qt6_8_1 = byCommit {
+    commit = "4a66c00fcb3f85ddad658b8cfa2e870063ce60b5";
+    sha256 = "1fcvr67s7366bk8czzwhr12zsq60izl5iq4znqbm44pzyq9pf8rq";
+  };
+
+  qt6_8_0 = byCommit {
+    commit = "352f462ad9d2aa2cde75fdd8f1734e86402a3ff6";
+    sha256 = "02zfgkr9fpd6iwfh6dcr3m6fnx61jppm3v081f3brvkqwmmz7zq1";
+  };
+
+  qt6_7_3 = byCommit {
+    commit = "273673e839189c26130d48993d849a84199523e6";
+    sha256 = "0aca369hdxb8j0vx9791anyzy4m65zckx0lriicqhp95kv9q6m7z";
+  };
+
+  qt6_7_2 = byCommit {
+    commit = "841f166ff96fc2f3ecd1c0cc08072633033d41bf";
+    sha256 = "0d7p0cp7zjiadhpa6sdafxvrpw4lnmb1h673w17q615vm1yaasvy";
+  };
+
+  qt6_7_1 = byCommit {
+    commit = "69bee9866a4e2708b3153fdb61c1425e7857d6b8";
+    sha256 = "1an4sha4jsa29dvc4n9mqxbq8jjwg7frl0rhy085g73m7l1yx0lj";
+  };
+
+  qt6_7_0 = byCommit {
+    commit = "4fbbc17ccf11bc80002b19b31387c9c80276f076";
+    sha256 = "09lhgdqlx8j9a7vpdcf8sddlhbzjq0s208spfmxfjdn14fvx8k0j";
+  };
+
+  qt6_6_3 = byCommit {
+    commit = "8f1a3fbaa92f1d59b09f2d24af6a607b5a280071";
+    sha256 = "0322zwxvmg8v2wkm03xpk6mqmmbfjgrhc9prcx0zd36vjl6jmi18";
+  };
+
+  qt6_6_2 = byCommit {
+    commit = "0bb9cfbd69459488576a0ef3c0e0477bedc3a29e";
+    sha256 = "172ww486jm1mczk9id78s32p7ps9m9qgisml286flc8jffb6yad8";
+  };
+
+  qt6_6_1 = byCommit {
+    commit = "8eecc3342103c38eea666309a7c0d90d403a039a";
+    sha256 = "1lakc0immsgrpz3basaysdvd0sx01r0mcbyymx6id12fk0404z5r";
+  };
+
+  qt6_6_0 = byCommit {
+    commit = "1ded005f95a43953112ffc54b39593ea2f16409f";
+    sha256 = "1xvyd3lj81hak9j53mrhdsqx78x5v2ppv8m2s54qa2099anqgm0f";
+  };
+}
diff --git a/ci/variations.nix b/ci/variations.nix
new file mode 100644
index 00000000..b0889be6
--- /dev/null
+++ b/ci/variations.nix
@@ -0,0 +1,7 @@
+{
+  clangStdenv,
+  gccStdenv,
+}: {
+  clang = { buildStdenv = clangStdenv; };
+  gcc = { buildStdenv = gccStdenv; };
+}
diff --git a/cmake/install-qml-module.cmake b/cmake/install-qml-module.cmake
new file mode 100644
index 00000000..5c95531c
--- /dev/null
+++ b/cmake/install-qml-module.cmake
@@ -0,0 +1,89 @@
+set(INSTALL_QMLDIR "" CACHE STRING "QML install dir")
+set(INSTALL_QML_PREFIX "" CACHE STRING "QML install prefix")
+
+# There doesn't seem to be a standard cross-distro qml install path.
+if ("${INSTALL_QMLDIR}" STREQUAL "" AND "${INSTALL_QML_PREFIX}" STREQUAL "")
+	message(WARNING "Neither INSTALL_QMLDIR nor INSTALL_QML_PREFIX is set. QML modules will not be installed.")
+else()
+	if ("${INSTALL_QMLDIR}" STREQUAL "")
+		set(QML_FULL_INSTALLDIR "${CMAKE_INSTALL_PREFIX}/${INSTALL_QML_PREFIX}")
+	else()
+		set(QML_FULL_INSTALLDIR "${INSTALL_QMLDIR}")
+	endif()
+
+	message(STATUS "QML install dir: ${QML_FULL_INSTALLDIR}")
+endif()
+
+# Install a given target as a QML module. This is mostly pulled from ECM, as there does not seem
+# to be an official way to do it.
+# see https://github.com/KDE/extra-cmake-modules/blob/fe0f606bf7f222e36f7560fd7a2c33ef993e23bb/modules/ECMQmlModule6.cmake#L160
+function(install_qml_module arg_TARGET)
+	if (NOT DEFINED QML_FULL_INSTALLDIR)
+		return()
+	endif()
+
+	qt_query_qml_module(${arg_TARGET}
+		URI module_uri
+		VERSION module_version
+		PLUGIN_TARGET module_plugin_target
+		TARGET_PATH module_target_path
+		QMLDIR module_qmldir
+		TYPEINFO module_typeinfo
+		QML_FILES module_qml_files
+		RESOURCES module_resources
+	)
+
+  set(module_dir "${QML_FULL_INSTALLDIR}/${module_target_path}")
+
+  if (NOT TARGET "${module_plugin_target}")
+    message(FATAL_ERROR "install_qml_modules called for a target without a plugin")
+  endif()
+
+	get_target_property(target_type "${arg_TARGET}" TYPE)
+	if (NOT "${target_type}" STREQUAL "STATIC_LIBRARY")
+		install(
+			TARGETS "${arg_TARGET}"
+			LIBRARY DESTINATION "${module_dir}"
+			RUNTIME DESTINATION "${module_dir}"
+		)
+
+		install(
+			TARGETS "${module_plugin_target}"
+			LIBRARY DESTINATION "${module_dir}"
+			RUNTIME DESTINATION "${module_dir}"
+		)
+	endif()
+
+  install(FILES "${module_qmldir}" DESTINATION "${module_dir}")
+  install(FILES "${module_typeinfo}" DESTINATION "${module_dir}")
+
+  # Install QML files
+  list(LENGTH module_qml_files num_files)
+  if (NOT "${module_qml_files}" MATCHES "NOTFOUND" AND ${num_files} GREATER 0)
+    qt_query_qml_module(${arg_TARGET} QML_FILES_DEPLOY_PATHS qml_files_deploy_paths)
+
+    math(EXPR last_index "${num_files} - 1")
+    foreach(i RANGE 0 ${last_index})
+      list(GET module_qml_files       ${i} src_file)
+      list(GET qml_files_deploy_paths ${i} deploy_path)
+      get_filename_component(dst_name "${deploy_path}" NAME)
+      get_filename_component(dest_dir "${deploy_path}" DIRECTORY)
+      install(FILES "${src_file}" DESTINATION "${module_dir}/${dest_dir}" RENAME "${dst_name}")
+    endforeach()
+  endif()
+
+  # Install resources
+  list(LENGTH module_resources num_files)
+  if (NOT "${module_resources}" MATCHES "NOTFOUND" AND ${num_files} GREATER 0)
+    qt_query_qml_module(${arg_TARGET} RESOURCES_DEPLOY_PATHS resources_deploy_paths)
+
+    math(EXPR last_index "${num_files} - 1")
+    foreach(i RANGE 0 ${last_index})
+      list(GET module_resources       ${i} src_file)
+      list(GET resources_deploy_paths ${i} deploy_path)
+      get_filename_component(dst_name "${deploy_path}" NAME)
+      get_filename_component(dest_dir "${deploy_path}" DIRECTORY)
+      install(FILES "${src_file}" DESTINATION "${module_dir}/${dest_dir}" RENAME "${dst_name}")
+    endforeach()
+  endif()
+endfunction()
diff --git a/cmake/pch.cmake b/cmake/pch.cmake
new file mode 100644
index 00000000..e136015e
--- /dev/null
+++ b/cmake/pch.cmake
@@ -0,0 +1,85 @@
+# pch breaks clang-tidy..... somehow
+if (NOT NO_PCH)
+	file(GENERATE
+		OUTPUT ${CMAKE_BINARY_DIR}/pchstub.cpp
+		CONTENT "// intentionally empty"
+	)
+endif()
+
+function (qs_pch target)
+	if (NO_PCH)
+		return()
+	endif()
+
+	cmake_parse_arguments(PARSE_ARGV 1 arg "" "SET" "")
+
+	if ("${arg_SET}" STREQUAL "")
+		set(arg_SET "common")
+	endif()
+
+	target_precompile_headers(${target} REUSE_FROM "qs-pchset-${arg_SET}")
+endfunction()
+
+function (qs_module_pch target)
+	qs_pch(${target} ${ARGN})
+	qs_pch("${target}plugin" SET plugin)
+	qs_pch("${target}plugin_init" SET plugin)
+endfunction()
+
+function (qs_add_pchset SETNAME)
+	if (NO_PCH)
+		return()
+	endif()
+
+	cmake_parse_arguments(PARSE_ARGV 1 arg "" "" "HEADERS;DEPENDENCIES")
+
+	set(LIBNAME "qs-pchset-${SETNAME}")
+
+	add_library(${LIBNAME} ${CMAKE_BINARY_DIR}/pchstub.cpp)
+	target_link_libraries(${LIBNAME} ${arg_DEPENDENCIES})
+	target_precompile_headers(${LIBNAME} PUBLIC ${arg_HEADERS})
+endfunction()
+
+set(COMMON_PCH_SET
+	<chrono>
+	<memory>
+	<vector>
+	<qdebug.h>
+	<qobject.h>
+	<qmetatype.h>
+	<qstring.h>
+	<qchar.h>
+	<qlist.h>
+	<qabstractitemmodel.h>
+)
+
+qs_add_pchset(common
+	DEPENDENCIES Qt::Quick
+	HEADERS ${COMMON_PCH_SET}
+)
+
+qs_add_pchset(large
+	DEPENDENCIES Qt::Quick
+	HEADERS
+		${COMMON_PCH_SET}
+		<qiodevice.h>
+		<qevent.h>
+		<qcoreapplication.h>
+		<qqmlengine.h>
+		<qquickitem.h>
+		<qquickwindow.h>
+		<qcolor.h>
+		<qdir.h>
+		<qtimer.h>
+		<qabstractitemmodel.h>
+)
+
+
+# including qplugin.h directly will cause required symbols to disappear
+qs_add_pchset(plugin
+	DEPENDENCIES Qt::Qml
+	HEADERS
+		<qobject.h>
+		<qjsonobject.h>
+		<qpointer.h>
+)
diff --git a/cmake/util.cmake b/cmake/util.cmake
new file mode 100644
index 00000000..14fa7c2d
--- /dev/null
+++ b/cmake/util.cmake
@@ -0,0 +1,29 @@
+# Adds a dependency hint to the link order, but does not block build on the dependency.
+function (qs_add_link_dependencies target)
+	set_property(
+		TARGET ${target}
+		APPEND PROPERTY INTERFACE_LINK_LIBRARIES
+		${ARGN}
+	)
+endfunction()
+
+function (qs_append_qmldir target text)
+	get_property(qmldir_content TARGET ${target} PROPERTY _qt_internal_qmldir_content)
+
+	if ("${qmldir_content}" STREQUAL "")
+		message(WARNING "qs_append_qmldir depends on private Qt cmake code, which has broken.")
+		return()
+	endif()
+
+	set_property(TARGET ${target} APPEND_STRING PROPERTY _qt_internal_qmldir_content ${text})
+endfunction()
+
+# DEPENDENCIES introduces a cmake dependency which we don't need with static modules.
+# This greatly improves comp speed by not introducing those dependencies.
+function (qs_add_module_deps_light target)
+	foreach (dep IN LISTS ARGN)
+		string(APPEND qmldir_extra "depends ${dep}\n")
+	endforeach()
+
+	qs_append_qmldir(${target} "${qmldir_extra}")
+endfunction()
diff --git a/default.nix b/default.nix
index 4fa9326f..71c949e3 100644
--- a/default.nix
+++ b/default.nix
@@ -3,13 +3,24 @@
   nix-gitignore,
   pkgs,
   keepDebugInfo,
-  stdenv ? (keepDebugInfo pkgs.stdenv),
+  buildStdenv ? pkgs.clangStdenv,
 
+  pkg-config,
   cmake,
   ninja,
+  spirv-tools,
   qt6,
+  breakpad,
+  jemalloc,
+  cli11,
   wayland,
   wayland-protocols,
+  wayland-scanner,
+  xorg,
+  libdrm,
+  libgbm ? null,
+  pipewire,
+  pam,
 
   gitRev ? (let
     headExists = builtins.pathExists ./.git/HEAD;
@@ -21,51 +32,101 @@
         then builtins.readFile ./.git/refs/heads/${builtins.elemAt matches 0}
         else headContent)
      else "unknown"),
+
   debug ? false,
-  enableWayland ? true,
-}: stdenv.mkDerivation {
-  pname = "quickshell${lib.optionalString debug "-debug"}";
-  version = "0.1.0";
-  src = nix-gitignore.gitignoreSource [] ./.;
+  withCrashReporter ? true,
+  withJemalloc ? true, # masks heap fragmentation
+  withQtSvg ? true,
+  withWayland ? true,
+  withX11 ? true,
+  withPipewire ? true,
+  withPam ? true,
+  withHyprland ? true,
+  withI3 ? true,
+}: let
+  unwrapped = buildStdenv.mkDerivation {
+    pname = "quickshell${lib.optionalString debug "-debug"}";
+    version = "0.2.0";
+    src = nix-gitignore.gitignoreSource "/default.nix\n" ./.;
 
-  nativeBuildInputs = with pkgs; [
-    cmake
-    ninja
-    qt6.wrapQtAppsHook
-  ] ++ (lib.optionals enableWayland [
-    pkg-config
-    wayland-protocols
-    wayland-scanner
-  ]);
+    dontWrapQtApps = true; # see wrappers
 
-  buildInputs = with pkgs; [
-    qt6.qtbase
-    qt6.qtdeclarative
-  ] ++ (lib.optionals enableWayland [ qt6.qtwayland wayland ]);
+    nativeBuildInputs = [
+      cmake
+      ninja
+      qt6.qtshadertools
+      spirv-tools
+      pkg-config
+    ]
+    ++ lib.optional withWayland wayland-scanner;
 
-  QTWAYLANDSCANNER = lib.optionalString enableWayland "${qt6.qtwayland}/libexec/qtwaylandscanner";
+    buildInputs = [
+      qt6.qtbase
+      qt6.qtdeclarative
+      cli11
+    ]
+    ++ lib.optional withQtSvg qt6.qtsvg
+    ++ lib.optional withCrashReporter breakpad
+    ++ lib.optional withJemalloc jemalloc
+    ++ lib.optionals withWayland [ qt6.qtwayland wayland wayland-protocols ]
+    ++ lib.optionals (withWayland && libgbm != null) [ libdrm libgbm ]
+    ++ lib.optional withX11 xorg.libxcb
+    ++ lib.optional withPam pam
+    ++ lib.optional withPipewire pipewire;
 
-  configurePhase = let
-    cmakeBuildType = if debug
-                     then "Debug"
-                     else "RelWithDebInfo";
-  in ''
-    cmakeBuildType=${cmakeBuildType} # qt6 setup hook resets this for some godforsaken reason
-    cmakeConfigurePhase
-  '';
+    cmakeBuildType = if debug then "Debug" else "RelWithDebInfo";
 
-  cmakeFlags = [
-    "-DGIT_REVISION=${gitRev}"
-  ] ++ lib.optional (!enableWayland) "-DWAYLAND=OFF";
+    cmakeFlags = [
+      (lib.cmakeFeature "DISTRIBUTOR" "Official-Nix-Flake")
+      (lib.cmakeFeature "INSTALL_QML_PREFIX" qt6.qtbase.qtQmlPrefix)
+      (lib.cmakeBool "DISTRIBUTOR_DEBUGINFO_AVAILABLE" true)
+      (lib.cmakeFeature "GIT_REVISION" gitRev)
+      (lib.cmakeBool "CRASH_REPORTER" withCrashReporter)
+      (lib.cmakeBool "USE_JEMALLOC" withJemalloc)
+      (lib.cmakeBool "WAYLAND" withWayland)
+      (lib.cmakeBool "SCREENCOPY" (libgbm != null))
+      (lib.cmakeBool "SERVICE_PIPEWIRE" withPipewire)
+      (lib.cmakeBool "SERVICE_PAM" withPam)
+      (lib.cmakeBool "HYPRLAND" withHyprland)
+      (lib.cmakeBool "I3" withI3)
+    ];
 
-  buildPhase = "ninjaBuildPhase";
-  enableParallelBuilding = true;
-  dontStrip = true;
+    # How to get debuginfo in gdb from a release build:
+    # 1. build `quickshell.debug`
+    # 2. set NIX_DEBUG_INFO_DIRS="<quickshell.debug store path>/lib/debug"
+    # 3. launch gdb / coredumpctl and debuginfo will work
+    separateDebugInfo = !debug;
+    dontStrip = debug;
 
-  meta = with lib; {
-    homepage = "https://git.outfoxxed.me/outfoxxed/quickshell";
-    description = "Simple and flexbile QtQuick based desktop shell toolkit";
-    license = licenses.lgpl3Only;
-    platforms = platforms.linux;
+    meta = with lib; {
+      homepage = "https://quickshell.org";
+      description = "Flexbile QtQuick based desktop shell toolkit";
+      license = licenses.lgpl3Only;
+      platforms = platforms.linux;
+      mainProgram = "quickshell";
+    };
   };
-}
+
+  wrapper = unwrapped.stdenv.mkDerivation {
+    inherit (unwrapped) version meta buildInputs;
+    pname = "${unwrapped.pname}-wrapped";
+
+    nativeBuildInputs = unwrapped.nativeBuildInputs ++ [ qt6.wrapQtAppsHook ];
+
+    dontUnpack = true;
+    dontConfigure = true;
+    dontBuild = true;
+
+    installPhase = ''
+      mkdir -p $out
+      cp -r ${unwrapped}/* $out
+    '';
+
+    passthru = {
+      unwrapped = unwrapped;
+      withModules = modules: wrapper.overrideAttrs (prev: {
+        buildInputs = prev.buildInputs ++ modules;
+      });
+    };
+  };
+in wrapper
diff --git a/docs b/docs
deleted file mode 160000
index 70989dc6..00000000
--- a/docs
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 70989dc619bcdc29dc4880b4ff5257d6ad188a18
diff --git a/examples b/examples
deleted file mode 160000
index 9c83cc24..00000000
--- a/examples
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 9c83cc248c968b18a827b4fa4c616a8d362176e1
diff --git a/flake.lock b/flake.lock
index 1527f635..7c25aa23 100644
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1709237383,
-        "narHash": "sha256-cy6ArO4k5qTx+l5o+0mL9f5fa86tYUX3ozE1S+Txlds=",
+        "lastModified": 1749285348,
+        "narHash": "sha256-frdhQvPbmDYaScPFiCnfdh3B/Vh81Uuoo0w5TkWmmjU=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "1536926ef5621b09bba54035ae2bb6d806d72ac8",
+        "rev": "3e3afe5174c561dee0df6f2c2b2236990146329f",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index b9ba8d1f..5de9c96a 100644
--- a/flake.nix
+++ b/flake.nix
@@ -4,12 +4,16 @@
   };
 
   outputs = { self, nixpkgs }: let
-    forEachSystem = fn: nixpkgs.lib.genAttrs
-      [ "x86_64-linux" "aarch64-linux" ]
-      (system: fn system nixpkgs.legacyPackages.${system});
+    forEachSystem = fn:
+      nixpkgs.lib.genAttrs
+        nixpkgs.lib.platforms.linux
+        (system: fn system nixpkgs.legacyPackages.${system});
   in {
     packages = forEachSystem (system: pkgs: rec {
-      quickshell = import ./package.nix { inherit pkgs; };
+      quickshell = pkgs.callPackage ./default.nix {
+        gitRev = self.rev or self.dirtyRev;
+      };
+
       default = quickshell;
     });
 
diff --git a/package.nix b/package.nix
deleted file mode 100644
index a3e6249e..00000000
--- a/package.nix
+++ /dev/null
@@ -1 +0,0 @@
-{ pkgs ? import <nixpkgs> {}, ... }: pkgs.callPackage ./default.nix {}
diff --git a/quickshell.scm b/quickshell.scm
new file mode 100644
index 00000000..26abdc0b
--- /dev/null
+++ b/quickshell.scm
@@ -0,0 +1,77 @@
+(define-module (quickshell)
+  #:use-module ((guix licenses) #:prefix license:)
+  #:use-module (gnu packages cpp)
+  #:use-module (gnu packages freedesktop)
+  #:use-module (gnu packages gcc)
+  #:use-module (gnu packages gl)
+  #:use-module (gnu packages jemalloc)
+  #:use-module (gnu packages linux)
+  #:use-module (gnu packages ninja)
+  #:use-module (gnu packages pkg-config)
+  #:use-module (gnu packages qt)
+  #:use-module (gnu packages vulkan)
+  #:use-module (gnu packages xdisorg)
+  #:use-module (gnu packages xorg)
+  #:use-module (guix build-system cmake)
+  #:use-module (guix download)
+  #:use-module (guix gexp)
+  #:use-module (guix git-download)
+  #:use-module (guix packages)
+  #:use-module (guix packages)
+  #:use-module (guix utils))
+
+(define-public quickshell-git
+  (package
+    (name "quickshell")
+    (version "git")
+    (source (local-file "." "quickshell-checkout"
+                        #:recursive? #t
+                        #:select? (or (git-predicate (current-source-directory))
+                                      (const #t))))
+    (build-system cmake-build-system)
+    (propagated-inputs (list qtbase qtdeclarative qtsvg))
+    (native-inputs (list ninja
+                         gcc-14
+                         pkg-config
+                         qtshadertools
+                         spirv-tools
+                         wayland-protocols
+                         cli11))
+    (inputs (list jemalloc
+                  libdrm
+                  libxcb
+                  libxkbcommon
+                  linux-pam
+                  mesa
+                  pipewire
+                  qtbase
+                  qtdeclarative
+                  qtwayland
+                  vulkan-headers
+                  wayland))
+    (arguments
+     (list #:tests? #f
+           #:configure-flags
+           #~(list "-GNinja"
+                   "-DDISTRIBUTOR=\"In-tree Guix channel\""
+                   "-DDISTRIBUTOR_DEBUGINFO_AVAILABLE=NO"
+                   ;; Breakpad is not currently packaged for Guix.
+                   "-DCRASH_REPORTER=OFF")
+           #:phases
+           #~(modify-phases %standard-phases
+               (replace 'build (lambda _ (invoke "cmake" "--build" ".")))
+               (replace 'install (lambda _ (invoke "cmake" "--install" ".")))
+               (add-after 'install 'wrap-program
+                 (lambda* (#:key inputs #:allow-other-keys)
+                   (wrap-program (string-append #$output "/bin/quickshell")
+                     `("QML_IMPORT_PATH" ":"
+                       = (,(getenv "QML_IMPORT_PATH")))))))))
+    (home-page "https://quickshell.outfoxxed.me")
+    (synopsis "QtQuick-based desktop shell toolkit")
+    (description
+     "Quickshell is a flexible QtQuick-based toolkit for creating and
+customizing toolbars, notification centers, and other desktop
+environment tools in a live programming environment.")
+    (license license:lgpl3)))
+
+quickshell-git
diff --git a/shell.nix b/shell.nix
index 484bf70a..82382f90 100644
--- a/shell.nix
+++ b/shell.nix
@@ -10,18 +10,17 @@
     rev = "1f062cc198d1112d13e5128fa1f2ee3dbffe613b";
     sha256 = "kbt0Zc1qHE5fhqBkKz8iue+B+ZANjF1AR/RdgmX1r0I=";
   }) { inherit pkgs; };
-in pkgs.mkShell {
+in pkgs.mkShell.override { stdenv = quickshell.stdenv; } {
   inputsFrom = [ quickshell ];
 
   nativeBuildInputs = with pkgs; [
     just
-    clang-tools_17
+    clang-tools
     parallel
     makeWrapper
   ];
 
   TIDYFOX = "${tidyfox}/lib/libtidyfox.so";
-  QTWAYLANDSCANNER = quickshell.QTWAYLANDSCANNER;
 
   shellHook = ''
     export CMAKE_BUILD_PARALLEL_LEVEL=$(nproc)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
new file mode 100644
index 00000000..52db00a5
--- /dev/null
+++ b/src/CMakeLists.txt
@@ -0,0 +1,35 @@
+qt_add_executable(quickshell main.cpp)
+
+install(TARGETS quickshell RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+add_subdirectory(build)
+add_subdirectory(launch)
+add_subdirectory(core)
+add_subdirectory(debug)
+add_subdirectory(ipc)
+add_subdirectory(window)
+add_subdirectory(io)
+add_subdirectory(widgets)
+add_subdirectory(ui)
+
+if (CRASH_REPORTER)
+	add_subdirectory(crash)
+endif()
+
+if (DBUS)
+	add_subdirectory(dbus)
+endif()
+
+if (WAYLAND)
+	add_subdirectory(wayland)
+endif()
+
+if (X11)
+	add_subdirectory(x11)
+endif()
+
+add_subdirectory(services)
+
+if (BLUETOOTH)
+	add_subdirectory(bluetooth)
+endif()
diff --git a/src/bluetooth/CMakeLists.txt b/src/bluetooth/CMakeLists.txt
new file mode 100644
index 00000000..806ff04d
--- /dev/null
+++ b/src/bluetooth/CMakeLists.txt
@@ -0,0 +1,42 @@
+set_source_files_properties(org.bluez.Adapter.xml PROPERTIES
+	CLASSNAME DBusBluezAdapterInterface
+)
+
+set_source_files_properties(org.bluez.Device.xml PROPERTIES
+	CLASSNAME DBusBluezDeviceInterface
+)
+
+qt_add_dbus_interface(DBUS_INTERFACES
+	org.bluez.Adapter.xml
+	dbus_adapter
+)
+
+qt_add_dbus_interface(DBUS_INTERFACES
+	org.bluez.Device.xml
+	dbus_device
+)
+
+qt_add_library(quickshell-bluetooth STATIC
+	adapter.cpp
+	bluez.cpp
+	device.cpp
+	${DBUS_INTERFACES}
+)
+
+qt_add_qml_module(quickshell-bluetooth
+	URI Quickshell.Bluetooth
+	VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+install_qml_module(quickshell-bluetooth)
+
+# dbus headers
+target_include_directories(quickshell-bluetooth PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+
+target_link_libraries(quickshell-bluetooth PRIVATE Qt::Qml Qt::DBus)
+qs_add_link_dependencies(quickshell-bluetooth quickshell-dbus)
+
+qs_module_pch(quickshell-bluetooth SET dbus)
+
+target_link_libraries(quickshell PRIVATE quickshell-bluetoothplugin)
diff --git a/src/bluetooth/adapter.cpp b/src/bluetooth/adapter.cpp
new file mode 100644
index 00000000..0d8a3192
--- /dev/null
+++ b/src/bluetooth/adapter.cpp
@@ -0,0 +1,224 @@
+#include "adapter.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdbusconnection.h>
+#include <qdbusextratypes.h>
+#include <qdbuspendingcall.h>
+#include <qdbuspendingreply.h>
+#include <qdebug.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qstring.h>
+#include <qstringliteral.h>
+#include <qtypes.h>
+
+#include "../core/logcat.hpp"
+#include "../dbus/properties.hpp"
+#include "dbus_adapter.h"
+
+namespace qs::bluetooth {
+
+namespace {
+QS_LOGGING_CATEGORY(logAdapter, "quickshell.bluetooth.adapter", QtWarningMsg);
+}
+
+QString BluetoothAdapterState::toString(BluetoothAdapterState::Enum state) {
+	switch (state) {
+	case BluetoothAdapterState::Disabled: return QStringLiteral("Disabled");
+	case BluetoothAdapterState::Enabled: return QStringLiteral("Enabled");
+	case BluetoothAdapterState::Enabling: return QStringLiteral("Enabling");
+	case BluetoothAdapterState::Disabling: return QStringLiteral("Disabling");
+	case BluetoothAdapterState::Blocked: return QStringLiteral("Blocked");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+BluetoothAdapter::BluetoothAdapter(const QString& path, QObject* parent): QObject(parent) {
+	this->mInterface =
+	    new DBusBluezAdapterInterface("org.bluez", path, QDBusConnection::systemBus(), this);
+
+	if (!this->mInterface->isValid()) {
+		qCWarning(logAdapter) << "Could not create DBus interface for adapter at" << path;
+		this->mInterface = nullptr;
+		return;
+	}
+
+	this->properties.setInterface(this->mInterface);
+}
+
+QString BluetoothAdapter::adapterId() const {
+	auto path = this->path();
+	return path.sliced(path.lastIndexOf('/') + 1);
+}
+
+void BluetoothAdapter::setEnabled(bool enabled) {
+	if (enabled == this->bEnabled) return;
+
+	if (enabled && this->bState == BluetoothAdapterState::Blocked) {
+		qCCritical(logAdapter) << "Cannot enable adapter because it is blocked by rfkill.";
+		return;
+	}
+
+	this->bEnabled = enabled;
+	this->pEnabled.write();
+}
+
+void BluetoothAdapter::setDiscoverable(bool discoverable) {
+	if (discoverable == this->bDiscoverable) return;
+	this->bDiscoverable = discoverable;
+	this->pDiscoverable.write();
+}
+
+void BluetoothAdapter::setDiscovering(bool discovering) {
+	if (discovering) {
+		this->startDiscovery();
+	} else {
+		this->stopDiscovery();
+	}
+}
+
+void BluetoothAdapter::setDiscoverableTimeout(quint32 timeout) {
+	if (timeout == this->bDiscoverableTimeout) return;
+	this->bDiscoverableTimeout = timeout;
+	this->pDiscoverableTimeout.write();
+}
+
+void BluetoothAdapter::setPairable(bool pairable) {
+	if (pairable == this->bPairable) return;
+	this->bPairable = pairable;
+	this->pPairable.write();
+}
+
+void BluetoothAdapter::setPairableTimeout(quint32 timeout) {
+	if (timeout == this->bPairableTimeout) return;
+	this->bPairableTimeout = timeout;
+	this->pPairableTimeout.write();
+}
+
+void BluetoothAdapter::addInterface(const QString& interface, const QVariantMap& properties) {
+	if (interface == "org.bluez.Adapter1") {
+		this->properties.updatePropertySet(properties, false);
+		qCDebug(logAdapter) << "Updated Adapter properties for" << this;
+	}
+}
+
+void BluetoothAdapter::removeDevice(const QString& devicePath) {
+	qCDebug(logAdapter) << "Removing device" << devicePath << "from adapter" << this;
+
+	auto reply = this->mInterface->RemoveDevice(QDBusObjectPath(devicePath));
+
+	auto* watcher = new QDBusPendingCallWatcher(reply, this);
+
+	QObject::connect(
+	    watcher,
+	    &QDBusPendingCallWatcher::finished,
+	    this,
+	    [this, devicePath](QDBusPendingCallWatcher* watcher) {
+		    const QDBusPendingReply<> reply = *watcher;
+
+		    if (reply.isError()) {
+			    qCWarning(logAdapter).nospace()
+			        << "Failed to remove device " << devicePath << " from adapter" << this << ": "
+			        << reply.error().message();
+		    } else {
+			    qCDebug(logAdapter) << "Successfully removed device" << devicePath << "from adapter"
+			                        << this;
+		    }
+
+		    delete watcher;
+	    }
+	);
+}
+
+void BluetoothAdapter::startDiscovery() {
+	if (this->bDiscovering) return;
+	qCDebug(logAdapter) << "Starting discovery for adapter" << this;
+
+	auto reply = this->mInterface->StartDiscovery();
+	auto* watcher = new QDBusPendingCallWatcher(reply, this);
+
+	QObject::connect(
+	    watcher,
+	    &QDBusPendingCallWatcher::finished,
+	    this,
+	    [this](QDBusPendingCallWatcher* watcher) {
+		    const QDBusPendingReply<> reply = *watcher;
+
+		    if (reply.isError()) {
+			    qCWarning(logAdapter).nospace()
+			        << "Failed to start discovery on adapter" << this << ": " << reply.error().message();
+		    } else {
+			    qCDebug(logAdapter) << "Successfully started discovery on adapter" << this;
+		    }
+
+		    delete watcher;
+	    }
+	);
+}
+
+void BluetoothAdapter::stopDiscovery() {
+	if (!this->bDiscovering) return;
+	qCDebug(logAdapter) << "Stopping discovery for adapter" << this;
+
+	auto reply = this->mInterface->StopDiscovery();
+	auto* watcher = new QDBusPendingCallWatcher(reply, this);
+
+	QObject::connect(
+	    watcher,
+	    &QDBusPendingCallWatcher::finished,
+	    this,
+	    [this](QDBusPendingCallWatcher* watcher) {
+		    const QDBusPendingReply<> reply = *watcher;
+
+		    if (reply.isError()) {
+			    qCWarning(logAdapter).nospace()
+			        << "Failed to stop discovery on adapter " << this << ": " << reply.error().message();
+		    } else {
+			    qCDebug(logAdapter) << "Successfully stopped discovery on adapter" << this;
+		    }
+
+		    delete watcher;
+	    }
+	);
+}
+
+} // namespace qs::bluetooth
+
+namespace qs::dbus {
+
+using namespace qs::bluetooth;
+
+DBusResult<BluetoothAdapterState::Enum>
+DBusDataTransform<BluetoothAdapterState::Enum>::fromWire(const Wire& wire) {
+	if (wire == QStringLiteral("off")) {
+		return BluetoothAdapterState::Disabled;
+	} else if (wire == QStringLiteral("on")) {
+		return BluetoothAdapterState::Enabled;
+	} else if (wire == QStringLiteral("off-enabling")) {
+		return BluetoothAdapterState::Enabling;
+	} else if (wire == QStringLiteral("on-disabling")) {
+		return BluetoothAdapterState::Disabling;
+	} else if (wire == QStringLiteral("off-blocked")) {
+		return BluetoothAdapterState::Blocked;
+	} else {
+		return QDBusError(
+		    QDBusError::InvalidArgs,
+		    QString("Invalid BluetoothAdapterState: %1").arg(wire)
+		);
+	}
+}
+
+} // namespace qs::dbus
+
+QDebug operator<<(QDebug debug, const qs::bluetooth::BluetoothAdapter* adapter) {
+	auto saver = QDebugStateSaver(debug);
+
+	if (adapter) {
+		debug.nospace() << "BluetoothAdapter(" << static_cast<const void*>(adapter)
+		                << ", path=" << adapter->path() << ")";
+	} else {
+		debug << "BluetoothAdapter(nullptr)";
+	}
+
+	return debug;
+}
diff --git a/src/bluetooth/adapter.hpp b/src/bluetooth/adapter.hpp
new file mode 100644
index 00000000..d7f21d7e
--- /dev/null
+++ b/src/bluetooth/adapter.hpp
@@ -0,0 +1,173 @@
+#pragma once
+
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+
+#include "../core/doc.hpp"
+#include "../core/model.hpp"
+#include "../dbus/properties.hpp"
+#include "dbus_adapter.h"
+
+namespace qs::bluetooth {
+
+///! Power state of a Bluetooth adapter.
+class BluetoothAdapterState: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		/// The adapter is powered off.
+		Disabled = 0,
+		/// The adapter is powered on.
+		Enabled = 1,
+		/// The adapter is transitioning from off to on.
+		Enabling = 2,
+		/// The adapter is transitioning from on to off.
+		Disabling = 3,
+		/// The adapter is blocked by rfkill.
+		Blocked = 4,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(BluetoothAdapterState::Enum state);
+};
+
+} // namespace qs::bluetooth
+
+namespace qs::dbus {
+
+template <>
+struct DBusDataTransform<qs::bluetooth::BluetoothAdapterState::Enum> {
+	using Wire = QString;
+	using Data = qs::bluetooth::BluetoothAdapterState::Enum;
+	static DBusResult<Data> fromWire(const Wire& wire);
+};
+
+} // namespace qs::dbus
+
+namespace qs::bluetooth {
+
+class BluetoothAdapter;
+class BluetoothDevice;
+
+///! A Bluetooth adapter
+class BluetoothAdapter: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_UNCREATABLE("");
+	// clang-format off
+	/// System provided name of the adapter. See @@adapterId for the internal identifier.
+	Q_PROPERTY(QString name READ default NOTIFY nameChanged BINDABLE bindableName);
+	/// True if the adapter is currently enabled. More detailed state is available from @@state.
+	Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged);
+	/// Detailed power state of the adapter.
+	Q_PROPERTY(BluetoothAdapterState::Enum state READ default NOTIFY stateChanged BINDABLE bindableState);
+	/// True if the adapter can be discovered by other bluetooth devices.
+	Q_PROPERTY(bool discoverable READ discoverable WRITE setDiscoverable NOTIFY discoverableChanged);
+	/// Timeout in seconds for how long the adapter stays discoverable after @@discoverable is set to true.
+	/// A value of 0 means the adapter stays discoverable forever.
+	Q_PROPERTY(quint32 discoverableTimeout READ discoverableTimeout WRITE setDiscoverableTimeout NOTIFY discoverableTimeoutChanged);
+	/// True if the adapter is scanning for new devices.
+	Q_PROPERTY(bool discovering READ discovering WRITE setDiscovering NOTIFY discoveringChanged);
+	/// True if the adapter is accepting incoming pairing requests.
+	///
+	/// This only affects incoming pairing requests and should typically only be changed
+	/// by system settings applications. Defaults to true.
+	Q_PROPERTY(bool pairable READ pairable WRITE setPairable NOTIFY pairableChanged);
+	/// Timeout in seconds for how long the adapter stays pairable after @@pairable is set to true.
+	/// A value of 0 means the adapter stays pairable forever. Defaults to 0.
+	Q_PROPERTY(quint32 pairableTimeout READ pairableTimeout WRITE setPairableTimeout NOTIFY pairableTimeoutChanged);
+	/// Bluetooth devices connected to this adapter.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::bluetooth::BluetoothDevice>*);
+	Q_PROPERTY(UntypedObjectModel* devices READ devices CONSTANT);
+	/// The internal ID of the adapter (e.g., "hci0").
+	Q_PROPERTY(QString adapterId READ adapterId CONSTANT);
+	/// DBus path of the adapter under the `org.bluez` system service.
+	Q_PROPERTY(QString dbusPath READ path CONSTANT);
+	// clang-format on
+
+public:
+	explicit BluetoothAdapter(const QString& path, QObject* parent = nullptr);
+
+	[[nodiscard]] bool isValid() const { return this->mInterface->isValid(); }
+	[[nodiscard]] QString path() const { return this->mInterface->path(); }
+	[[nodiscard]] QString adapterId() const;
+
+	[[nodiscard]] bool enabled() const { return this->bEnabled; }
+	void setEnabled(bool enabled);
+
+	[[nodiscard]] bool discoverable() const { return this->bDiscoverable; }
+	void setDiscoverable(bool discoverable);
+
+	[[nodiscard]] bool discovering() const { return this->bDiscovering; }
+	void setDiscovering(bool discovering);
+
+	[[nodiscard]] quint32 discoverableTimeout() const { return this->bDiscoverableTimeout; }
+	void setDiscoverableTimeout(quint32 timeout);
+
+	[[nodiscard]] bool pairable() const { return this->bPairable; }
+	void setPairable(bool pairable);
+
+	[[nodiscard]] quint32 pairableTimeout() const { return this->bPairableTimeout; }
+	void setPairableTimeout(quint32 timeout);
+
+	[[nodiscard]] QBindable<QString> bindableName() { return &this->bName; }
+	[[nodiscard]] QBindable<bool> bindableEnabled() { return &this->bEnabled; }
+	[[nodiscard]] QBindable<BluetoothAdapterState::Enum> bindableState() { return &this->bState; }
+	[[nodiscard]] QBindable<bool> bindableDiscoverable() { return &this->bDiscoverable; }
+	[[nodiscard]] QBindable<quint32> bindableDiscoverableTimeout() {
+		return &this->bDiscoverableTimeout;
+	}
+	[[nodiscard]] QBindable<bool> bindableDiscovering() { return &this->bDiscovering; }
+	[[nodiscard]] QBindable<bool> bindablePairable() { return &this->bPairable; }
+	[[nodiscard]] QBindable<quint32> bindablePairableTimeout() { return &this->bPairableTimeout; }
+	[[nodiscard]] ObjectModel<BluetoothDevice>* devices() { return &this->mDevices; }
+
+	void addInterface(const QString& interface, const QVariantMap& properties);
+	void removeDevice(const QString& devicePath);
+
+	void startDiscovery();
+	void stopDiscovery();
+
+signals:
+	void nameChanged();
+	void enabledChanged();
+	void stateChanged();
+	void discoverableChanged();
+	void discoverableTimeoutChanged();
+	void discoveringChanged();
+	void pairableChanged();
+	void pairableTimeoutChanged();
+
+private:
+	DBusBluezAdapterInterface* mInterface = nullptr;
+	ObjectModel<BluetoothDevice> mDevices {this};
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothAdapter, QString, bName, &BluetoothAdapter::nameChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothAdapter, bool, bEnabled, &BluetoothAdapter::enabledChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothAdapter, BluetoothAdapterState::Enum, bState, &BluetoothAdapter::stateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothAdapter, bool, bDiscoverable, &BluetoothAdapter::discoverableChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothAdapter, quint32, bDiscoverableTimeout, &BluetoothAdapter::discoverableTimeoutChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothAdapter, bool, bDiscovering, &BluetoothAdapter::discoveringChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothAdapter, bool, bPairable, &BluetoothAdapter::pairableChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothAdapter, quint32, bPairableTimeout, &BluetoothAdapter::pairableTimeoutChanged);
+	
+	QS_DBUS_BINDABLE_PROPERTY_GROUP(BluetoothAdapter, properties);
+	QS_DBUS_PROPERTY_BINDING(BluetoothAdapter, pName, bName, properties, "Alias");
+	QS_DBUS_PROPERTY_BINDING(BluetoothAdapter, pEnabled, bEnabled, properties, "Powered");
+	QS_DBUS_PROPERTY_BINDING(BluetoothAdapter, pState, bState, properties, "PowerState");
+	QS_DBUS_PROPERTY_BINDING(BluetoothAdapter, pDiscoverable, bDiscoverable, properties, "Discoverable");
+	QS_DBUS_PROPERTY_BINDING(BluetoothAdapter, pDiscoverableTimeout, bDiscoverableTimeout, properties, "DiscoverableTimeout");
+	QS_DBUS_PROPERTY_BINDING(BluetoothAdapter, pDiscovering, bDiscovering, properties, "Discovering");
+	QS_DBUS_PROPERTY_BINDING(BluetoothAdapter, pPairable, bPairable, properties, "Pairable");
+	QS_DBUS_PROPERTY_BINDING(BluetoothAdapter, pPairableTimeout, bPairableTimeout, properties, "PairableTimeout");
+	// clang-format on
+};
+
+} // namespace qs::bluetooth
+
+QDebug operator<<(QDebug debug, const qs::bluetooth::BluetoothAdapter* adapter);
diff --git a/src/bluetooth/bluez.cpp b/src/bluetooth/bluez.cpp
new file mode 100644
index 00000000..f2c4300d
--- /dev/null
+++ b/src/bluetooth/bluez.cpp
@@ -0,0 +1,168 @@
+#include "bluez.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdbusconnection.h>
+#include <qdbusextratypes.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+#include "../core/logcat.hpp"
+#include "../dbus/dbus_objectmanager_types.hpp"
+#include "../dbus/objectmanager.hpp"
+#include "adapter.hpp"
+#include "device.hpp"
+
+namespace qs::bluetooth {
+
+namespace {
+QS_LOGGING_CATEGORY(logBluetooth, "quickshell.bluetooth", QtWarningMsg);
+}
+
+Bluez* Bluez::instance() {
+	static auto* instance = new Bluez();
+	return instance;
+}
+
+Bluez::Bluez() { this->init(); }
+
+void Bluez::updateDefaultAdapter() {
+	const auto& adapters = this->mAdapters.valueList();
+	this->bDefaultAdapter = adapters.empty() ? nullptr : adapters.first();
+}
+
+void Bluez::init() {
+	qCDebug(logBluetooth) << "Connecting to BlueZ";
+
+	auto bus = QDBusConnection::systemBus();
+
+	if (!bus.isConnected()) {
+		qCWarning(logBluetooth) << "Could not connect to DBus. Bluetooth integration is not available.";
+		return;
+	}
+
+	this->objectManager = new qs::dbus::DBusObjectManager(this);
+
+	QObject::connect(
+	    this->objectManager,
+	    &qs::dbus::DBusObjectManager::interfacesAdded,
+	    this,
+	    &Bluez::onInterfacesAdded
+	);
+
+	QObject::connect(
+	    this->objectManager,
+	    &qs::dbus::DBusObjectManager::interfacesRemoved,
+	    this,
+	    &Bluez::onInterfacesRemoved
+	);
+
+	if (!this->objectManager->setInterface("org.bluez", "/", bus)) {
+		qCDebug(logBluetooth) << "BlueZ is not running. Bluetooth integration will not work.";
+		return;
+	}
+}
+
+void Bluez::onInterfacesAdded(
+    const QDBusObjectPath& path,
+    const DBusObjectManagerInterfaces& interfaces
+) {
+	if (auto* adapter = this->mAdapterMap.value(path.path())) {
+		for (const auto& [interface, properties]: interfaces.asKeyValueRange()) {
+			adapter->addInterface(interface, properties);
+		}
+	} else if (auto* device = this->mDeviceMap.value(path.path())) {
+		for (const auto& [interface, properties]: interfaces.asKeyValueRange()) {
+			device->addInterface(interface, properties);
+		}
+	} else if (interfaces.contains("org.bluez.Adapter1")) {
+		auto* adapter = new BluetoothAdapter(path.path(), this);
+
+		if (!adapter->isValid()) {
+			qCWarning(logBluetooth) << "Adapter path is not valid, cannot track: " << device;
+			delete adapter;
+			return;
+		}
+
+		qCDebug(logBluetooth) << "Tracked new adapter" << adapter;
+
+		for (const auto& [interface, properties]: interfaces.asKeyValueRange()) {
+			adapter->addInterface(interface, properties);
+		}
+
+		for (auto* device: this->mDevices.valueList()) {
+			if (device->adapterPath() == path) {
+				adapter->devices()->insertObject(device);
+				qCDebug(logBluetooth) << "Added tracked device" << device << "to new adapter" << adapter;
+				emit device->adapterChanged();
+			}
+		}
+
+		this->mAdapterMap.insert(path.path(), adapter);
+		this->mAdapters.insertObject(adapter);
+		this->updateDefaultAdapter();
+	} else if (interfaces.contains("org.bluez.Device1")) {
+		auto* device = new BluetoothDevice(path.path(), this);
+
+		if (!device->isValid()) {
+			qCWarning(logBluetooth) << "Device path is not valid, cannot track: " << device;
+			delete device;
+			return;
+		}
+
+		qCDebug(logBluetooth) << "Tracked new device" << device;
+
+		for (const auto& [interface, properties]: interfaces.asKeyValueRange()) {
+			device->addInterface(interface, properties);
+		}
+
+		if (auto* adapter = device->adapter()) {
+			adapter->devices()->insertObject(device);
+			qCDebug(logBluetooth) << "Added device" << device << "to adapter" << adapter;
+		}
+
+		this->mDeviceMap.insert(path.path(), device);
+		this->mDevices.insertObject(device);
+	}
+}
+
+void Bluez::onInterfacesRemoved(const QDBusObjectPath& path, const QStringList& interfaces) {
+	if (auto* adapter = this->mAdapterMap.value(path.path())) {
+		if (interfaces.contains("org.bluez.Adapter1")) {
+			qCDebug(logBluetooth) << "Adapter removed:" << adapter;
+
+			this->mAdapterMap.remove(path.path());
+			this->mAdapters.removeObject(adapter);
+			this->updateDefaultAdapter();
+			delete adapter;
+		}
+	} else if (auto* device = this->mDeviceMap.value(path.path())) {
+		if (interfaces.contains("org.bluez.Device1")) {
+			qCDebug(logBluetooth) << "Device removed:" << device;
+
+			if (auto* adapter = device->adapter()) {
+				adapter->devices()->removeObject(device);
+			}
+
+			this->mDeviceMap.remove(path.path());
+			this->mDevices.removeObject(device);
+			delete device;
+		} else {
+			for (const auto& interface: interfaces) {
+				device->removeInterface(interface);
+			}
+		}
+	}
+}
+
+BluezQml::BluezQml() {
+	QObject::connect(
+	    Bluez::instance(),
+	    &Bluez::defaultAdapterChanged,
+	    this,
+	    &BluezQml::defaultAdapterChanged
+	);
+}
+
+} // namespace qs::bluetooth
diff --git a/src/bluetooth/bluez.hpp b/src/bluetooth/bluez.hpp
new file mode 100644
index 00000000..9d7c93ca
--- /dev/null
+++ b/src/bluetooth/bluez.hpp
@@ -0,0 +1,98 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qhash.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+
+#include "../core/doc.hpp"
+#include "../core/model.hpp"
+#include "../dbus/dbus_objectmanager_types.hpp"
+#include "../dbus/objectmanager.hpp"
+
+namespace qs::bluetooth {
+
+class BluetoothAdapter;
+class BluetoothDevice;
+
+class Bluez: public QObject {
+	Q_OBJECT;
+
+public:
+	[[nodiscard]] ObjectModel<BluetoothAdapter>* adapters() { return &this->mAdapters; }
+	[[nodiscard]] ObjectModel<BluetoothDevice>* devices() { return &this->mDevices; }
+
+	[[nodiscard]] BluetoothAdapter* adapter(const QString& path) {
+		return this->mAdapterMap.value(path);
+	}
+
+	static Bluez* instance();
+
+signals:
+	void defaultAdapterChanged();
+
+private slots:
+	void
+	onInterfacesAdded(const QDBusObjectPath& path, const DBusObjectManagerInterfaces& interfaces);
+	void onInterfacesRemoved(const QDBusObjectPath& path, const QStringList& interfaces);
+	void updateDefaultAdapter();
+
+private:
+	explicit Bluez();
+	void init();
+
+	qs::dbus::DBusObjectManager* objectManager = nullptr;
+	QHash<QString, BluetoothAdapter*> mAdapterMap;
+	QHash<QString, BluetoothDevice*> mDeviceMap;
+	ObjectModel<BluetoothAdapter> mAdapters {this};
+	ObjectModel<BluetoothDevice> mDevices {this};
+
+public:
+	Q_OBJECT_BINDABLE_PROPERTY(
+	    Bluez,
+	    BluetoothAdapter*,
+	    bDefaultAdapter,
+	    &Bluez::defaultAdapterChanged
+	);
+};
+
+///! Bluetooth manager
+/// Provides access to bluetooth devices and adapters.
+class BluezQml: public QObject {
+	Q_OBJECT;
+	QML_NAMED_ELEMENT(Bluetooth);
+	QML_SINGLETON;
+	// clang-format off
+	/// The default bluetooth adapter. Usually there is only one.
+	Q_PROPERTY(BluetoothAdapter* defaultAdapter READ default NOTIFY defaultAdapterChanged BINDABLE bindableDefaultAdapter);
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::bluetooth::BluetoothAdapter>*);
+	/// A list of all bluetooth adapters. See @@defaultAdapter for the default.
+	Q_PROPERTY(UntypedObjectModel* adapters READ adapters CONSTANT);
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::bluetooth::BluetoothDevice>*);
+	/// A list of all connected bluetooth devices across all adapters.
+	/// See @@BluetoothAdapter.devices for the devices connected to a single adapter.
+	Q_PROPERTY(UntypedObjectModel* devices READ devices CONSTANT);
+	// clang-format on
+
+signals:
+	void defaultAdapterChanged();
+
+public:
+	explicit BluezQml();
+
+	[[nodiscard]] static ObjectModel<BluetoothAdapter>* adapters() {
+		return Bluez::instance()->adapters();
+	}
+
+	[[nodiscard]] static ObjectModel<BluetoothDevice>* devices() {
+		return Bluez::instance()->devices();
+	}
+
+	[[nodiscard]] static QBindable<BluetoothAdapter*> bindableDefaultAdapter() {
+		return &Bluez::instance()->bDefaultAdapter;
+	}
+};
+
+} // namespace qs::bluetooth
diff --git a/src/bluetooth/device.cpp b/src/bluetooth/device.cpp
new file mode 100644
index 00000000..7265b241
--- /dev/null
+++ b/src/bluetooth/device.cpp
@@ -0,0 +1,319 @@
+#include "device.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdbusconnection.h>
+#include <qdbuspendingcall.h>
+#include <qdbuspendingreply.h>
+#include <qdebug.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qstring.h>
+#include <qstringliteral.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../core/logcat.hpp"
+#include "../dbus/properties.hpp"
+#include "adapter.hpp"
+#include "bluez.hpp"
+#include "dbus_device.h"
+
+namespace qs::bluetooth {
+
+namespace {
+QS_LOGGING_CATEGORY(logDevice, "quickshell.bluetooth.device", QtWarningMsg);
+}
+
+QString BluetoothDeviceState::toString(BluetoothDeviceState::Enum state) {
+	switch (state) {
+	case BluetoothDeviceState::Disconnected: return QStringLiteral("Disconnected");
+	case BluetoothDeviceState::Connected: return QStringLiteral("Connected");
+	case BluetoothDeviceState::Disconnecting: return QStringLiteral("Disconnecting");
+	case BluetoothDeviceState::Connecting: return QStringLiteral("Connecting");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+BluetoothDevice::BluetoothDevice(const QString& path, QObject* parent): QObject(parent) {
+	this->mInterface =
+	    new DBusBluezDeviceInterface("org.bluez", path, QDBusConnection::systemBus(), this);
+
+	if (!this->mInterface->isValid()) {
+		qCWarning(logDevice) << "Could not create DBus interface for device at" << path;
+		delete this->mInterface;
+		this->mInterface = nullptr;
+		return;
+	}
+
+	this->properties.setInterface(this->mInterface);
+}
+
+BluetoothAdapter* BluetoothDevice::adapter() const {
+	return Bluez::instance()->adapter(this->bAdapterPath.value().path());
+}
+
+void BluetoothDevice::setConnected(bool connected) {
+	if (connected == this->bConnected) return;
+
+	if (connected) {
+		this->connect();
+	} else {
+		this->disconnect();
+	}
+}
+
+void BluetoothDevice::setTrusted(bool trusted) {
+	if (trusted == this->bTrusted) return;
+	this->bTrusted = trusted;
+	this->pTrusted.write();
+}
+
+void BluetoothDevice::setBlocked(bool blocked) {
+	if (blocked == this->bBlocked) return;
+	this->bBlocked = blocked;
+	this->pBlocked.write();
+}
+
+void BluetoothDevice::setName(const QString& name) {
+	if (name == this->bName) return;
+	this->bName = name;
+	this->pName.write();
+}
+
+void BluetoothDevice::setWakeAllowed(bool wakeAllowed) {
+	if (wakeAllowed == this->bWakeAllowed) return;
+	this->bWakeAllowed = wakeAllowed;
+	this->pWakeAllowed.write();
+}
+
+void BluetoothDevice::connect() {
+	if (this->bConnected) {
+		qCCritical(logDevice) << "Device" << this << "is already connected";
+		return;
+	}
+
+	if (this->bState == BluetoothDeviceState::Connecting) {
+		qCCritical(logDevice) << "Device" << this << "is already connecting";
+		return;
+	}
+
+	qCDebug(logDevice) << "Connecting to device" << this;
+	this->bState = BluetoothDeviceState::Connecting;
+
+	auto reply = this->mInterface->Connect();
+	auto* watcher = new QDBusPendingCallWatcher(reply, this);
+
+	QObject::connect(
+	    watcher,
+	    &QDBusPendingCallWatcher::finished,
+	    this,
+	    [this](QDBusPendingCallWatcher* watcher) {
+		    const QDBusPendingReply<> reply = *watcher;
+
+		    if (reply.isError()) {
+			    qCWarning(logDevice).nospace()
+			        << "Failed to connect to device " << this << ": " << reply.error().message();
+
+			    this->bState = this->bConnected ? BluetoothDeviceState::Connected
+			                                    : BluetoothDeviceState::Disconnected;
+		    } else {
+			    qCDebug(logDevice) << "Successfully connected to to device" << this;
+		    }
+
+		    delete watcher;
+	    }
+	);
+}
+
+void BluetoothDevice::disconnect() {
+	if (!this->bConnected) {
+		qCCritical(logDevice) << "Device" << this << "is already disconnected";
+		return;
+	}
+
+	if (this->bState == BluetoothDeviceState::Disconnecting) {
+		qCCritical(logDevice) << "Device" << this << "is already disconnecting";
+		return;
+	}
+
+	qCDebug(logDevice) << "Disconnecting from device" << this;
+	this->bState = BluetoothDeviceState::Disconnecting;
+
+	auto reply = this->mInterface->Disconnect();
+	auto* watcher = new QDBusPendingCallWatcher(reply, this);
+
+	QObject::connect(
+	    watcher,
+	    &QDBusPendingCallWatcher::finished,
+	    this,
+	    [this](QDBusPendingCallWatcher* watcher) {
+		    const QDBusPendingReply<> reply = *watcher;
+
+		    if (reply.isError()) {
+			    qCWarning(logDevice).nospace()
+			        << "Failed to disconnect from device " << this << ": " << reply.error().message();
+
+			    this->bState = this->bConnected ? BluetoothDeviceState::Connected
+			                                    : BluetoothDeviceState::Disconnected;
+		    } else {
+			    qCDebug(logDevice) << "Successfully disconnected from from device" << this;
+		    }
+
+		    delete watcher;
+	    }
+	);
+}
+
+void BluetoothDevice::pair() {
+	if (this->bPaired) {
+		qCCritical(logDevice) << "Device" << this << "is already paired";
+		return;
+	}
+
+	if (this->bPairing) {
+		qCCritical(logDevice) << "Device" << this << "is already pairing";
+		return;
+	}
+
+	qCDebug(logDevice) << "Pairing with device" << this;
+	this->bPairing = true;
+
+	auto reply = this->mInterface->Pair();
+	auto* watcher = new QDBusPendingCallWatcher(reply, this);
+
+	QObject::connect(
+	    watcher,
+	    &QDBusPendingCallWatcher::finished,
+	    this,
+	    [this](QDBusPendingCallWatcher* watcher) {
+		    const QDBusPendingReply<> reply = *watcher;
+		    if (reply.isError()) {
+			    qCWarning(logDevice).nospace()
+			        << "Failed to pair with device " << this << ": " << reply.error().message();
+		    } else {
+			    qCDebug(logDevice) << "Successfully initiated pairing with device" << this;
+		    }
+
+		    this->bPairing = false;
+		    delete watcher;
+	    }
+	);
+}
+
+void BluetoothDevice::cancelPair() {
+	if (!this->bPairing) {
+		qCCritical(logDevice) << "Device" << this << "is not currently pairing";
+		return;
+	}
+
+	qCDebug(logDevice) << "Cancelling pairing with device" << this;
+
+	auto reply = this->mInterface->CancelPairing();
+	auto* watcher = new QDBusPendingCallWatcher(reply, this);
+
+	QObject::connect(
+	    watcher,
+	    &QDBusPendingCallWatcher::finished,
+	    this,
+	    [this](QDBusPendingCallWatcher* watcher) {
+		    const QDBusPendingReply<> reply = *watcher;
+		    if (reply.isError()) {
+			    qCWarning(logDevice) << "Failed to cancel pairing with device" << this << ":"
+			                         << reply.error().message();
+		    } else {
+			    qCDebug(logDevice) << "Successfully cancelled pairing with device" << this;
+		    }
+
+		    this->bPairing = false;
+		    delete watcher;
+	    }
+	);
+}
+
+void BluetoothDevice::forget() {
+	if (!this->mInterface || !this->mInterface->isValid()) {
+		qCCritical(logDevice) << "Cannot forget - device interface is invalid";
+		return;
+	}
+
+	if (auto* adapter = Bluez::instance()->adapter(this->bAdapterPath.value().path())) {
+		qCDebug(logDevice) << "Forgetting device" << this << "via adapter" << adapter;
+		adapter->removeDevice(this->path());
+	} else {
+		qCCritical(logDevice) << "Could not find adapter for path" << this->bAdapterPath.value().path()
+		                      << "to forget from";
+	}
+}
+
+void BluetoothDevice::addInterface(const QString& interface, const QVariantMap& properties) {
+	if (interface == "org.bluez.Device1") {
+		this->properties.updatePropertySet(properties, false);
+		qCDebug(logDevice) << "Updated Device properties for" << this;
+	} else if (interface == "org.bluez.Battery1") {
+		if (!this->mBatteryInterface) {
+			this->mBatteryInterface = new QDBusInterface(
+			    "org.bluez",
+			    this->path(),
+			    "org.bluez.Battery1",
+			    QDBusConnection::systemBus(),
+			    this
+			);
+
+			if (!this->mBatteryInterface->isValid()) {
+				qCWarning(logDevice) << "Could not create Battery interface for device at" << this;
+				delete this->mBatteryInterface;
+				this->mBatteryInterface = nullptr;
+				return;
+			}
+		}
+
+		this->batteryProperties.setInterface(this->mBatteryInterface);
+		this->batteryProperties.updatePropertySet(properties, false);
+
+		emit this->batteryAvailableChanged();
+		qCDebug(logDevice) << "Updated Battery properties for" << this;
+	}
+}
+
+void BluetoothDevice::removeInterface(const QString& interface) {
+	if (interface == "org.bluez.Battery1" && this->mBatteryInterface) {
+		this->batteryProperties.setInterface(nullptr);
+		delete this->mBatteryInterface;
+		this->mBatteryInterface = nullptr;
+		this->bBattery = 0;
+
+		emit this->batteryAvailableChanged();
+		qCDebug(logDevice) << "Battery interface removed from device" << this;
+	}
+}
+
+void BluetoothDevice::onConnectedChanged() {
+	this->bState =
+	    this->bConnected ? BluetoothDeviceState::Connected : BluetoothDeviceState::Disconnected;
+	emit this->connectedChanged();
+}
+
+} // namespace qs::bluetooth
+
+namespace qs::dbus {
+
+using namespace qs::bluetooth;
+
+DBusResult<qreal> DBusDataTransform<BatteryPercentage>::fromWire(quint8 percentage) {
+	return DBusResult(percentage * 0.01);
+}
+
+} // namespace qs::dbus
+
+QDebug operator<<(QDebug debug, const qs::bluetooth::BluetoothDevice* device) {
+	auto saver = QDebugStateSaver(debug);
+
+	if (device) {
+		debug.nospace() << "BluetoothDevice(" << static_cast<const void*>(device)
+		                << ", path=" << device->path() << ")";
+	} else {
+		debug << "BluetoothDevice(nullptr)";
+	}
+
+	return debug;
+}
diff --git a/src/bluetooth/device.hpp b/src/bluetooth/device.hpp
new file mode 100644
index 00000000..23f230f5
--- /dev/null
+++ b/src/bluetooth/device.hpp
@@ -0,0 +1,225 @@
+#pragma once
+
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../dbus/properties.hpp"
+#include "dbus_device.h"
+
+namespace qs::bluetooth {
+
+///! Connection state of a Bluetooth device.
+class BluetoothDeviceState: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		/// The device is not connected.
+		Disconnected = 0,
+		/// The device is connected.
+		Connected = 1,
+		/// The device is disconnecting.
+		Disconnecting = 2,
+		/// The device is connecting.
+		Connecting = 3,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(BluetoothDeviceState::Enum state);
+};
+
+struct BatteryPercentage {};
+
+} // namespace qs::bluetooth
+
+namespace qs::dbus {
+
+template <>
+struct DBusDataTransform<qs::bluetooth::BatteryPercentage> {
+	using Wire = quint8;
+	using Data = qreal;
+	static DBusResult<Data> fromWire(Wire percentage);
+};
+
+} // namespace qs::dbus
+
+namespace qs::bluetooth {
+
+class BluetoothAdapter;
+
+///! A tracked Bluetooth device.
+class BluetoothDevice: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_UNCREATABLE("");
+	// clang-format off
+	/// MAC address of the device.
+	Q_PROPERTY(QString address READ default NOTIFY addressChanged BINDABLE bindableAddress);
+	/// The name of the Bluetooth device. This property may be written to create an alias, or set to
+	/// an empty string to fall back to the device provided name.
+	///
+	/// See @@deviceName for the name provided by the device.
+	Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged);
+	/// The name of the Bluetooth device, ignoring user provided aliases. See also @@name
+	/// which returns a user provided alias if set.
+	Q_PROPERTY(QString deviceName READ default NOTIFY deviceNameChanged BINDABLE bindableDeviceName);
+	/// System icon representing the device type. Use @@Quickshell.Quickshell.iconPath() to display this in an image.
+	Q_PROPERTY(QString icon READ default NOTIFY iconChanged BINDABLE bindableIcon);
+	/// Connection state of the device.
+	Q_PROPERTY(BluetoothDeviceState::Enum state READ default NOTIFY stateChanged BINDABLE bindableState);
+	/// True if the device is currently connected to the computer.
+	///
+	/// Setting this property is equivalent to calling @@connect() and @@disconnect().
+	///
+	/// > [!NOTE] @@state provides more detailed information if required.
+	Q_PROPERTY(bool connected READ connected WRITE setConnected NOTIFY connectedChanged);
+	/// True if the device is paired to the computer.
+	///
+	/// > [!NOTE] @@pair() can be used to pair a device, however you must @@forget() the device to unpair it.
+	Q_PROPERTY(bool paired READ default NOTIFY pairedChanged BINDABLE bindablePaired);
+	/// True if pairing information is stored for future connections.
+	Q_PROPERTY(bool bonded READ default NOTIFY bondedChanged BINDABLE bindableBonded);
+	/// True if the device is currently being paired.
+	///
+	/// > [!NOTE] @@cancelPair() can be used to cancel the pairing process.
+	Q_PROPERTY(bool pairing READ pairing NOTIFY pairingChanged);
+	/// True if the device is considered to be trusted by the system.
+	/// Trusted devices are allowed to reconnect themselves to the system without intervention.
+	Q_PROPERTY(bool trusted READ trusted WRITE setTrusted NOTIFY trustedChanged);
+	/// True if the device is blocked from connecting.
+	/// If a device is blocked, any connection attempts will be immediately rejected by the system.
+	Q_PROPERTY(bool blocked READ blocked WRITE setBlocked NOTIFY blockedChanged);
+	/// True if the device is allowed to wake up the host system from suspend.
+	Q_PROPERTY(bool wakeAllowed READ wakeAllowed WRITE setWakeAllowed NOTIFY wakeAllowedChanged);
+	/// True if the connected device reports its battery level. Battery level can be accessed via @@battery.
+	Q_PROPERTY(bool batteryAvailable READ batteryAvailable NOTIFY batteryAvailableChanged);
+	/// Battery level of the connected device, from `0.0` to `1.0`. Only valid if @@batteryAvailable is true.
+	Q_PROPERTY(qreal battery READ default NOTIFY batteryChanged BINDABLE bindableBattery);
+	/// The Bluetooth adapter this device belongs to.
+	Q_PROPERTY(BluetoothAdapter* adapter READ adapter NOTIFY adapterChanged);
+	/// DBus path of the device under the `org.bluez` system service.
+	Q_PROPERTY(QString dbusPath READ path CONSTANT);
+	// clang-format on
+
+public:
+	explicit BluetoothDevice(const QString& path, QObject* parent = nullptr);
+
+	/// Attempt to connect to the device.
+	Q_INVOKABLE void connect();
+	/// Disconnect from the device.
+	Q_INVOKABLE void disconnect();
+	/// Attempt to pair the device.
+	///
+	/// > [!NOTE] @@paired and @@pairing return the current pairing status of the device.
+	Q_INVOKABLE void pair();
+	/// Cancel an active pairing attempt.
+	Q_INVOKABLE void cancelPair();
+	/// Forget the device.
+	Q_INVOKABLE void forget();
+
+	[[nodiscard]] bool isValid() const { return this->mInterface && this->mInterface->isValid(); }
+	[[nodiscard]] QString path() const {
+		return this->mInterface ? this->mInterface->path() : QString();
+	}
+
+	[[nodiscard]] bool batteryAvailable() const { return this->mBatteryInterface != nullptr; }
+	[[nodiscard]] BluetoothAdapter* adapter() const;
+	[[nodiscard]] QDBusObjectPath adapterPath() const { return this->bAdapterPath.value(); }
+
+	[[nodiscard]] bool connected() const { return this->bConnected; }
+	void setConnected(bool connected);
+
+	[[nodiscard]] bool trusted() const { return this->bTrusted; }
+	void setTrusted(bool trusted);
+
+	[[nodiscard]] bool blocked() const { return this->bBlocked; }
+	void setBlocked(bool blocked);
+
+	[[nodiscard]] QString name() const { return this->bName; }
+	void setName(const QString& name);
+
+	[[nodiscard]] bool wakeAllowed() const { return this->bWakeAllowed; }
+	void setWakeAllowed(bool wakeAllowed);
+
+	[[nodiscard]] bool pairing() const { return this->bPairing; }
+
+	[[nodiscard]] QBindable<QString> bindableAddress() { return &this->bAddress; }
+	[[nodiscard]] QBindable<QString> bindableDeviceName() { return &this->bDeviceName; }
+	[[nodiscard]] QBindable<QString> bindableName() { return &this->bName; }
+	[[nodiscard]] QBindable<bool> bindableConnected() { return &this->bConnected; }
+	[[nodiscard]] QBindable<bool> bindablePaired() { return &this->bPaired; }
+	[[nodiscard]] QBindable<bool> bindableBonded() { return &this->bBonded; }
+	[[nodiscard]] QBindable<bool> bindableTrusted() { return &this->bTrusted; }
+	[[nodiscard]] QBindable<bool> bindableBlocked() { return &this->bBlocked; }
+	[[nodiscard]] QBindable<bool> bindableWakeAllowed() { return &this->bWakeAllowed; }
+	[[nodiscard]] QBindable<QString> bindableIcon() { return &this->bIcon; }
+	[[nodiscard]] QBindable<qreal> bindableBattery() { return &this->bBattery; }
+	[[nodiscard]] QBindable<BluetoothDeviceState::Enum> bindableState() { return &this->bState; }
+
+	void addInterface(const QString& interface, const QVariantMap& properties);
+	void removeInterface(const QString& interface);
+
+signals:
+	void addressChanged();
+	void deviceNameChanged();
+	void nameChanged();
+	void connectedChanged();
+	void stateChanged();
+	void pairedChanged();
+	void bondedChanged();
+	void pairingChanged();
+	void trustedChanged();
+	void blockedChanged();
+	void wakeAllowedChanged();
+	void iconChanged();
+	void batteryAvailableChanged();
+	void batteryChanged();
+	void adapterChanged();
+
+private:
+	void onConnectedChanged();
+
+	DBusBluezDeviceInterface* mInterface = nullptr;
+	QDBusInterface* mBatteryInterface = nullptr;
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, QString, bAddress, &BluetoothDevice::addressChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, QString, bDeviceName, &BluetoothDevice::deviceNameChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, QString, bName, &BluetoothDevice::nameChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, bool, bConnected, &BluetoothDevice::onConnectedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, bool, bPaired, &BluetoothDevice::pairedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, bool, bBonded, &BluetoothDevice::bondedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, bool, bTrusted, &BluetoothDevice::trustedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, bool, bBlocked, &BluetoothDevice::blockedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, bool, bWakeAllowed, &BluetoothDevice::wakeAllowedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, QString, bIcon, &BluetoothDevice::iconChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, QDBusObjectPath, bAdapterPath);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, qreal, bBattery, &BluetoothDevice::batteryChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, BluetoothDeviceState::Enum, bState, &BluetoothDevice::stateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(BluetoothDevice, bool, bPairing, &BluetoothDevice::pairingChanged);
+
+	QS_DBUS_BINDABLE_PROPERTY_GROUP(BluetoothDevice, properties);
+	QS_DBUS_PROPERTY_BINDING(BluetoothDevice, pAddress, bAddress, properties, "Address");
+	QS_DBUS_PROPERTY_BINDING(BluetoothDevice, pDeviceName, bDeviceName, properties, "Name");
+	QS_DBUS_PROPERTY_BINDING(BluetoothDevice, pName, bName, properties, "Alias");
+	QS_DBUS_PROPERTY_BINDING(BluetoothDevice, pConnected, bConnected, properties, "Connected");
+	QS_DBUS_PROPERTY_BINDING(BluetoothDevice, pPaired, bPaired, properties, "Paired");
+	QS_DBUS_PROPERTY_BINDING(BluetoothDevice, pBonded, bBonded, properties, "Bonded");
+	QS_DBUS_PROPERTY_BINDING(BluetoothDevice, pTrusted, bTrusted, properties, "Trusted");
+	QS_DBUS_PROPERTY_BINDING(BluetoothDevice, pBlocked, bBlocked, properties, "Blocked");
+	QS_DBUS_PROPERTY_BINDING(BluetoothDevice, pWakeAllowed, bWakeAllowed, properties, "WakeAllowed");
+	QS_DBUS_PROPERTY_BINDING(BluetoothDevice, pIcon, bIcon, properties, "Icon");
+	QS_DBUS_PROPERTY_BINDING(BluetoothDevice, pAdapterPath, bAdapterPath, properties, "Adapter");
+
+	QS_DBUS_BINDABLE_PROPERTY_GROUP(BluetoothDevice, batteryProperties);
+	QS_DBUS_PROPERTY_BINDING(BluetoothDevice, BatteryPercentage, pBattery, bBattery, batteryProperties, "Percentage", true);
+	// clang-format on
+};
+
+} // namespace qs::bluetooth
+
+QDebug operator<<(QDebug debug, const qs::bluetooth::BluetoothDevice* device);
diff --git a/src/bluetooth/module.md b/src/bluetooth/module.md
new file mode 100644
index 00000000..eb797d93
--- /dev/null
+++ b/src/bluetooth/module.md
@@ -0,0 +1,12 @@
+name = "Quickshell.Bluetooth"
+description = "Bluetooth API"
+headers = [
+	"bluez.hpp",
+	"adapter.hpp",
+	"device.hpp",
+]
+-----
+This module exposes Bluetooth management APIs provided by the BlueZ DBus interface.
+Both DBus and BlueZ must be running to use it.
+
+See the @@Quickshell.Bluetooth.Bluetooth singleton.
diff --git a/src/bluetooth/org.bluez.Adapter.xml b/src/bluetooth/org.bluez.Adapter.xml
new file mode 100644
index 00000000..286991e1
--- /dev/null
+++ b/src/bluetooth/org.bluez.Adapter.xml
@@ -0,0 +1,9 @@
+<node>
+	<interface name="org.bluez.Adapter1">
+		<method name="StartDiscovery"/>
+		<method name="StopDiscovery"/>
+		<method name="RemoveDevice">
+			<arg name="device" type="o"/>
+		</method>
+	</interface>
+</node>
diff --git a/src/bluetooth/org.bluez.Device.xml b/src/bluetooth/org.bluez.Device.xml
new file mode 100644
index 00000000..274e9fde
--- /dev/null
+++ b/src/bluetooth/org.bluez.Device.xml
@@ -0,0 +1,8 @@
+<node>
+	<interface name="org.bluez.Device1">
+		<method name="Connect"/>
+		<method name="Disconnect"/>
+		<method name="Pair"/>
+		<method name="CancelPairing"/>
+	</interface>
+</node>
diff --git a/src/bluetooth/test/manual/test.qml b/src/bluetooth/test/manual/test.qml
new file mode 100644
index 00000000..21c53b1d
--- /dev/null
+++ b/src/bluetooth/test/manual/test.qml
@@ -0,0 +1,200 @@
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Layouts
+import Quickshell
+import Quickshell.Widgets
+import Quickshell.Bluetooth
+
+FloatingWindow {
+	color: contentItem.palette.window
+
+	ListView {
+		anchors.fill: parent
+		anchors.margins: 5
+		model: Bluetooth.adapters
+
+		delegate: WrapperRectangle {
+			width: parent.width
+			color: "transparent"
+			border.color: palette.button
+			border.width: 1
+			margin: 5
+
+			ColumnLayout {
+				Label { text: `Adapter: ${modelData.name} (${modelData.adapterId})` }
+
+				RowLayout {
+					Layout.fillWidth: true
+
+					CheckBox {
+						text: "Enable"
+						checked: modelData.enabled
+						onToggled: modelData.enabled = checked
+					}
+
+					Label {
+						color: modelData.state === BluetoothAdapterState.Blocked ? palette.errorText : palette.placeholderText
+						text: BluetoothAdapterState.toString(modelData.state)
+					}
+
+					CheckBox {
+						text: "Discoverable"
+						checked: modelData.discoverable
+						onToggled: modelData.discoverable = checked
+					}
+
+					CheckBox {
+						text: "Discovering"
+						checked: modelData.discovering
+						onToggled: modelData.discovering = checked
+					}
+
+					CheckBox {
+						text: "Pairable"
+						checked: modelData.pairable
+						onToggled: modelData.pairable = checked
+					}
+				}
+
+				RowLayout {
+					Layout.fillWidth: true
+
+					Label { text: "Discoverable timeout:" }
+
+					SpinBox {
+						from: 0
+						to: 3600
+						value: modelData.discoverableTimeout
+						onValueModified: modelData.discoverableTimeout = value
+						textFromValue: time => time === 0 ? "∞" : time + "s"
+					}
+
+					Label { text: "Pairable timeout:" }
+
+					SpinBox {
+						from: 0
+						to: 3600
+						value: modelData.pairableTimeout
+						onValueModified: modelData.pairableTimeout = value
+						textFromValue: time => time === 0 ? "∞" : time + "s"
+					}
+				}
+
+				Repeater {
+					model: modelData.devices
+
+					WrapperRectangle {
+						Layout.fillWidth: true
+						color: palette.button
+						border.color: palette.mid
+						border.width: 1
+						margin: 5
+
+						RowLayout {
+							ColumnLayout {
+								Layout.fillWidth: true
+
+								RowLayout {
+									IconImage {
+										Layout.fillHeight: true
+										implicitWidth: height
+										source: Quickshell.iconPath(modelData.icon)
+									}
+
+									TextField {
+										text: modelData.name
+										font.bold: true
+										background: null
+										readOnly: false
+										selectByMouse: true
+										onEditingFinished: modelData.name = text
+									}
+
+									Label {
+										visible: modelData.name && modelData.name !== modelData.deviceName
+										text: `(${modelData.deviceName})`
+										color: palette.placeholderText
+									}
+								}
+
+								RowLayout {
+									Label {
+										text: modelData.address
+										color: palette.placeholderText
+									}
+
+									Label {
+										visible: modelData.batteryAvailable
+										text: `| Battery: ${Math.round(modelData.battery * 100)}%`
+										color: palette.placeholderText
+									}
+								}
+
+								RowLayout {
+									Label {
+										text: BluetoothDeviceState.toString(modelData.state)
+
+										color: modelData.connected ? palette.link : palette.placeholderText
+									}
+
+									Label {
+										text: modelData.pairing ? "Pairing" : (modelData.paired ? "Paired" : "Not Paired")
+										color: modelData.paired || modelData.pairing ? palette.link : palette.placeholderText
+									}
+
+									Label {
+										visible: modelData.bonded
+										text: "| Bonded"
+										color: palette.link
+									}
+
+									CheckBox {
+										text: "Trusted"
+										checked: modelData.trusted
+										onToggled: modelData.trusted = checked
+									}
+
+									CheckBox {
+										text: "Blocked"
+										checked: modelData.blocked
+										onToggled: modelData.blocked = checked
+									}
+
+									CheckBox {
+										text: "Wake Allowed"
+										checked: modelData.wakeAllowed
+										onToggled: modelData.wakeAllowed = checked
+									}
+								}
+							}
+
+							ColumnLayout {
+								Layout.alignment: Qt.AlignRight
+
+								Button {
+									Layout.alignment: Qt.AlignRight
+									text: modelData.connected ? "Disconnect" : "Connect"
+									onClicked: modelData.connected = !modelData.connected
+								}
+
+								Button {
+									Layout.alignment: Qt.AlignRight
+									text: modelData.pairing ? "Cancel" : (modelData.paired ? "Forget" : "Pair")
+									onClicked: {
+										if (modelData.pairing) {
+											modelData.cancelPair();
+										} else if (modelData.paired) {
+											modelData.forget();
+										} else {
+											modelData.pair();
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/src/build/CMakeLists.txt b/src/build/CMakeLists.txt
new file mode 100644
index 00000000..bb35da99
--- /dev/null
+++ b/src/build/CMakeLists.txt
@@ -0,0 +1,26 @@
+add_library(quickshell-build INTERFACE)
+
+if (NOT DEFINED GIT_REVISION)
+	execute_process(
+		COMMAND git rev-parse HEAD
+		WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+		OUTPUT_VARIABLE GIT_REVISION
+		OUTPUT_STRIP_TRAILING_WHITESPACE
+	)
+endif()
+
+if (CRASH_REPORTER)
+	set(CRASH_REPORTER_DEF 1)
+else()
+	set(CRASH_REPORTER_DEF 0)
+endif()
+
+if (DISTRIBUTOR_DEBUGINFO_AVAILABLE)
+	set(DEBUGINFO_AVAILABLE 1)
+else()
+	set(DEBUGINFO_AVAILABLE 0)
+endif()
+
+configure_file(build.hpp.in build.hpp @ONLY ESCAPE_QUOTES)
+
+target_include_directories(quickshell-build INTERFACE ${CMAKE_CURRENT_BINARY_DIR})
diff --git a/src/build/build.hpp.in b/src/build/build.hpp.in
new file mode 100644
index 00000000..075abd17
--- /dev/null
+++ b/src/build/build.hpp.in
@@ -0,0 +1,12 @@
+#pragma once
+
+// NOLINTBEGIN
+#define GIT_REVISION "@GIT_REVISION@"
+#define DISTRIBUTOR "@DISTRIBUTOR@"
+#define DISTRIBUTOR_DEBUGINFO_AVAILABLE @DEBUGINFO_AVAILABLE@
+#define CRASH_REPORTER @CRASH_REPORTER_DEF@
+#define BUILD_TYPE "@CMAKE_BUILD_TYPE@"
+#define COMPILER "@CMAKE_CXX_COMPILER_ID@ (@CMAKE_CXX_COMPILER_VERSION@)"
+#define COMPILE_FLAGS "@CMAKE_CXX_FLAGS@"
+#define BUILD_CONFIGURATION "@QS_BUILD_OPTIONS@"
+// NOLINTEND
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index c1fdee8e..7cef987a 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -1,23 +1,62 @@
-qt_add_executable(quickshell
-	main.cpp
+qt_add_library(quickshell-core STATIC
 	plugin.cpp
 	shell.cpp
 	variants.cpp
 	rootwrapper.cpp
-	proxywindow.cpp
 	reload.cpp
 	rootwrapper.cpp
 	qmlglobal.cpp
 	qmlscreen.cpp
-	watcher.cpp
 	region.cpp
 	persistentprops.cpp
-	windowinterface.cpp
-	floatingwindow.cpp
-	panelinterface.cpp
+	singleton.cpp
+	generation.cpp
+	scan.cpp
+	qsintercept.cpp
+	incubator.cpp
+	lazyloader.cpp
+	easingcurve.cpp
+	iconimageprovider.cpp
+	imageprovider.cpp
+	transformwatcher.cpp
+	boundcomponent.cpp
+	model.cpp
+	elapsedtimer.cpp
+	desktopentry.cpp
+	objectrepeater.cpp
+	platformmenu.cpp
+	qsmenu.cpp
+	retainable.cpp
+	popupanchor.cpp
+	types.cpp
+	qsmenuanchor.cpp
+	clock.cpp
+	logging.cpp
+	paths.cpp
+	instanceinfo.cpp
+	common.cpp
+	iconprovider.cpp
+	scriptmodel.cpp
+	colorquantizer.cpp
+	toolsupport.cpp
 )
 
-set_source_files_properties(main.cpp PROPERTIES COMPILE_DEFINITIONS GIT_REVISION="${GIT_REVISION}")
-qt_add_qml_module(quickshell URI Quickshell VERSION 0.1)
+qt_add_qml_module(quickshell-core
+	URI Quickshell
+	VERSION 0.1
+	DEPENDENCIES QtQuick
+	OPTIONAL_IMPORTS Quickshell._Window
+	DEFAULT_IMPORTS Quickshell._Window
+)
 
-target_link_libraries(quickshell PRIVATE ${QT_DEPS})
+install_qml_module(quickshell-core)
+
+target_link_libraries(quickshell-core PRIVATE Qt::Quick Qt::Widgets)
+
+qs_module_pch(quickshell-core SET large)
+
+target_link_libraries(quickshell PRIVATE quickshell-coreplugin)
+
+if (BUILD_TESTING)
+	add_subdirectory(test)
+endif()
diff --git a/src/core/boundcomponent.cpp b/src/core/boundcomponent.cpp
new file mode 100644
index 00000000..8b1c8284
--- /dev/null
+++ b/src/core/boundcomponent.cpp
@@ -0,0 +1,258 @@
+#include "boundcomponent.hpp"
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qlogging.h>
+#include <qmetaobject.h>
+#include <qobject.h>
+#include <qobjectdefs.h>
+#include <qqmlcomponent.h>
+#include <qqmlcontext.h>
+#include <qqmlengine.h>
+#include <qqmlerror.h>
+#include <qquickitem.h>
+#include <qtmetamacros.h>
+
+#include "incubator.hpp"
+
+QObject* BoundComponent::item() const { return this->object; }
+QQmlComponent* BoundComponent::sourceComponent() const { return this->mComponent; }
+
+void BoundComponent::setSourceComponent(QQmlComponent* component) {
+	if (component == this->mComponent) return;
+
+	if (this->componentCompleted) {
+		qWarning() << "BoundComponent.component cannot be set after creation";
+		return;
+	}
+	this->disconnectComponent();
+
+	this->ownsComponent = false;
+	this->mComponent = component;
+	if (component != nullptr) {
+		QObject::connect(component, &QObject::destroyed, this, &BoundComponent::onComponentDestroyed);
+	}
+
+	emit this->sourceComponentChanged();
+}
+
+void BoundComponent::disconnectComponent() {
+	if (this->mComponent == nullptr) return;
+
+	if (this->ownsComponent) {
+		delete this->mComponent;
+	} else {
+		QObject::disconnect(this->mComponent, nullptr, this, nullptr);
+	}
+
+	this->mComponent = nullptr;
+}
+
+void BoundComponent::onComponentDestroyed() { this->mComponent = nullptr; }
+QString BoundComponent::source() const { return this->mSource; }
+
+void BoundComponent::setSource(QString source) {
+	if (source == this->mSource) return;
+
+	if (this->componentCompleted) {
+		qWarning() << "BoundComponent.url cannot be set after creation";
+		return;
+	}
+
+	auto* context = QQmlEngine::contextForObject(this);
+	auto* component = new QQmlComponent(context->engine(), context->resolvedUrl(source), this);
+
+	if (component->isError()) {
+		qWarning() << component->errorString().toStdString().c_str();
+		delete component;
+	} else {
+		this->disconnectComponent();
+		this->ownsComponent = true;
+		this->mSource = std::move(source);
+		this->mComponent = component;
+
+		emit this->sourceChanged();
+		emit this->sourceComponentChanged();
+	}
+}
+
+bool BoundComponent::bindValues() const { return this->mBindValues; }
+
+void BoundComponent::setBindValues(bool bindValues) {
+	if (this->componentCompleted) {
+		qWarning() << "BoundComponent.bindValues cannot be set after creation";
+		return;
+	}
+
+	this->mBindValues = bindValues;
+	emit this->bindValuesChanged();
+}
+
+void BoundComponent::componentComplete() {
+	this->QQuickItem::componentComplete();
+	this->componentCompleted = true;
+	this->tryCreate();
+}
+
+void BoundComponent::tryCreate() {
+	if (this->mComponent == nullptr) {
+		qWarning() << "BoundComponent has no component";
+		return;
+	}
+
+	auto initialProperties = QVariantMap();
+
+	const auto* metaObject = this->metaObject();
+	for (auto i = metaObject->propertyOffset(); i < metaObject->propertyCount(); i++) {
+		const auto prop = metaObject->property(i);
+
+		if (prop.isReadable()) {
+			initialProperties.insert(prop.name(), prop.read(this));
+		}
+	}
+
+	this->incubator = new QsQmlIncubator(QsQmlIncubator::AsynchronousIfNested, this);
+	this->incubator->setInitialProperties(initialProperties);
+
+	// clang-format off
+	QObject::connect(this->incubator, &QsQmlIncubator::completed, this, &BoundComponent::onIncubationCompleted);
+	QObject::connect(this->incubator, &QsQmlIncubator::failed, this, &BoundComponent::onIncubationFailed);
+	// clang-format on
+
+	this->mComponent->create(*this->incubator, QQmlEngine::contextForObject(this));
+}
+
+void BoundComponent::onIncubationCompleted() {
+	this->object = this->incubator->object();
+	delete this->incubator;
+	this->disconnectComponent();
+
+	this->object->setParent(this);
+	this->mItem = qobject_cast<QQuickItem*>(this->object);
+
+	const auto* metaObject = this->metaObject();
+	const auto* objectMetaObject = this->object->metaObject();
+
+	if (this->mBindValues) {
+		for (auto i = metaObject->propertyOffset(); i < metaObject->propertyCount(); i++) {
+			const auto prop = metaObject->property(i);
+
+			if (prop.isReadable() && prop.hasNotifySignal()) {
+				const auto objectPropIndex = objectMetaObject->indexOfProperty(prop.name());
+
+				if (objectPropIndex == -1) {
+					qWarning() << "property" << prop.name()
+					           << "defined on BoundComponent but not on its contained object.";
+					continue;
+				}
+
+				const auto objectProp = objectMetaObject->property(objectPropIndex);
+				if (objectProp.isWritable()) {
+					auto* proxy = new BoundComponentPropertyProxy(this, this->object, prop, objectProp);
+					proxy->onNotified(); // any changes that might've happened before connection
+				} else {
+					qWarning() << "property" << prop.name()
+					           << "defined on BoundComponent is not writable for its contained object.";
+				}
+			}
+		}
+	}
+
+	for (auto i = metaObject->methodOffset(); i < metaObject->methodCount(); i++) {
+		const auto method = metaObject->method(i);
+
+		if (method.name().startsWith("on") && method.name().length() > 2) {
+			auto sig = QString(method.methodSignature()).sliced(2);
+			if (!sig[0].isUpper()) continue;
+			sig[0] = sig[0].toLower();
+			auto name = sig.sliced(0, sig.indexOf('('));
+
+			auto mostViableSignal = QMetaMethod();
+			for (auto i = 0; i < objectMetaObject->methodCount(); i++) {
+				const auto method = objectMetaObject->method(i);
+				if (method.methodSignature() == sig) {
+					mostViableSignal = method;
+					break;
+				}
+
+				if (method.name() == name) {
+					if (mostViableSignal.isValid()) {
+						qWarning() << "Multiple candidates, so none will be attached for signal" << name;
+						goto next;
+					}
+
+					mostViableSignal = method;
+				}
+			}
+
+			if (!mostViableSignal.isValid()) {
+				qWarning() << "Function" << method.name() << "appears to be a signal handler for" << name
+				           << "but it does not match any signals on the target object";
+				goto next;
+			}
+
+			QMetaObject::connect(
+			    this->object,
+			    mostViableSignal.methodIndex(),
+			    this,
+			    method.methodIndex()
+			);
+		}
+
+	next:;
+	}
+
+	if (this->mItem != nullptr) {
+		this->mItem->setParentItem(this);
+
+		// clang-format off
+		QObject::connect(this, &QQuickItem::widthChanged, this, &BoundComponent::updateSize);
+		QObject::connect(this, &QQuickItem::heightChanged, this, &BoundComponent::updateSize);
+		QObject::connect(this->mItem, &QQuickItem::implicitWidthChanged, this, &BoundComponent::updateImplicitSize);
+		QObject::connect(this->mItem, &QQuickItem::implicitHeightChanged, this, &BoundComponent::updateImplicitSize);
+		// clang-format on
+
+		this->updateImplicitSize();
+		this->updateSize();
+	}
+
+	emit this->loaded();
+}
+
+void BoundComponent::onIncubationFailed() {
+	qWarning() << "Failed to create BoundComponent";
+
+	for (auto& error: this->incubator->errors()) {
+		qWarning() << error;
+	}
+
+	delete this->incubator;
+	this->disconnectComponent();
+}
+
+void BoundComponent::updateSize() { this->mItem->setSize(this->size()); }
+
+void BoundComponent::updateImplicitSize() {
+	this->setImplicitWidth(this->mItem->implicitWidth());
+	this->setImplicitHeight(this->mItem->implicitHeight());
+}
+
+BoundComponentPropertyProxy::BoundComponentPropertyProxy(
+    QObject* from,
+    QObject* to,
+    QMetaProperty fromProperty,
+    QMetaProperty toProperty
+)
+    : QObject(from)
+    , from(from)
+    , to(to)
+    , fromProperty(fromProperty)
+    , toProperty(toProperty) {
+	const auto* metaObject = this->metaObject();
+	auto method = metaObject->indexOfSlot("onNotified()");
+	QMetaObject::connect(from, fromProperty.notifySignal().methodIndex(), this, method);
+}
+
+void BoundComponentPropertyProxy::onNotified() {
+	this->toProperty.write(this->to, this->fromProperty.read(this->from));
+}
diff --git a/src/core/boundcomponent.hpp b/src/core/boundcomponent.hpp
new file mode 100644
index 00000000..d47121df
--- /dev/null
+++ b/src/core/boundcomponent.hpp
@@ -0,0 +1,125 @@
+#pragma once
+
+#include <qmetaobject.h>
+#include <qobject.h>
+#include <qqmlcomponent.h>
+#include <qqmlparserstatus.h>
+#include <qquickitem.h>
+#include <qsignalmapper.h>
+#include <qtmetamacros.h>
+
+#include "incubator.hpp"
+
+///! Component loader that allows setting initial properties.
+/// Component loader that allows setting initial properties, primarily useful for
+/// escaping cyclic dependency errors.
+///
+/// Properties defined on the BoundComponent will be applied to its loaded component,
+/// including required properties, and will remain reactive. Functions created with
+/// the names of signal handlers will also be attached to signals of the loaded component.
+///
+/// ```qml {filename="MyComponent.qml"}
+/// MouseArea {
+///   required property color color;
+///   width: 100
+///   height: 100
+///
+///   Rectangle {
+///     anchors.fill: parent
+///     color: parent.color
+///   }
+/// }
+/// ```
+///
+/// ```qml
+/// BoundComponent {
+///   source: "MyComponent.qml"
+///
+///   // this is the same as assigning to `color` on MyComponent if loaded normally.
+///   property color color: "red";
+///
+///   // this will be triggered when the `clicked` signal from the MouseArea is sent.
+///   function onClicked() {
+///     color = "blue";
+///   }
+/// }
+/// ```
+class BoundComponent: public QQuickItem {
+	Q_OBJECT;
+	// clang-format off
+	/// The loaded component. Will be null until it has finished loading.
+	Q_PROPERTY(QObject* item READ item NOTIFY loaded);
+	/// The source to load, as a Component.
+	Q_PROPERTY(QQmlComponent* sourceComponent READ sourceComponent WRITE setSourceComponent NOTIFY sourceComponentChanged);
+	/// The source to load, as a Url.
+	Q_PROPERTY(QString source READ source WRITE setSource NOTIFY sourceChanged);
+	/// If property values should be bound after they are initially set. Defaults to `true`.
+	Q_PROPERTY(bool bindValues READ bindValues WRITE setBindValues NOTIFY bindValuesChanged);
+	Q_PROPERTY(qreal implicitWidth READ implicitWidth NOTIFY implicitWidthChanged);
+	Q_PROPERTY(qreal implicitHeight READ implicitHeight NOTIFY implicitHeightChanged);
+	// clang-format on
+	QML_ELEMENT;
+
+public:
+	explicit BoundComponent(QQuickItem* parent = nullptr): QQuickItem(parent) {}
+
+	void componentComplete() override;
+
+	[[nodiscard]] QObject* item() const;
+
+	[[nodiscard]] QQmlComponent* sourceComponent() const;
+	void setSourceComponent(QQmlComponent* sourceComponent);
+
+	[[nodiscard]] QString source() const;
+	void setSource(QString source);
+
+	[[nodiscard]] bool bindValues() const;
+	void setBindValues(bool bindValues);
+
+signals:
+	void loaded();
+	void sourceComponentChanged();
+	void sourceChanged();
+	void bindValuesChanged();
+
+private slots:
+	void onComponentDestroyed();
+	void onIncubationCompleted();
+	void onIncubationFailed();
+	void updateSize();
+	void updateImplicitSize();
+
+private:
+	void disconnectComponent();
+	void tryCreate();
+
+	QString mSource;
+	bool mBindValues = true;
+	QQmlComponent* mComponent = nullptr;
+	bool ownsComponent = false;
+	QsQmlIncubator* incubator = nullptr;
+	QObject* object = nullptr;
+	QQuickItem* mItem = nullptr;
+	bool componentCompleted = false;
+};
+
+class BoundComponentPropertyProxy: public QObject {
+	Q_OBJECT;
+
+public:
+	BoundComponentPropertyProxy(
+	    QObject* from,
+	    QObject* to,
+	    QMetaProperty fromProperty,
+	    QMetaProperty toProperty
+	);
+
+public slots:
+	void onNotified();
+
+private:
+	QObject* from;
+	QObject* to;
+	QMetaProperty fromProperty;
+	QMetaProperty toProperty;
+};
diff --git a/src/core/clock.cpp b/src/core/clock.cpp
new file mode 100644
index 00000000..90938d21
--- /dev/null
+++ b/src/core/clock.cpp
@@ -0,0 +1,88 @@
+#include "clock.hpp"
+
+#include <qdatetime.h>
+#include <qobject.h>
+#include <qtimer.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+SystemClock::SystemClock(QObject* parent): QObject(parent) {
+	QObject::connect(&this->timer, &QTimer::timeout, this, &SystemClock::onTimeout);
+	this->update();
+}
+
+bool SystemClock::enabled() const { return this->mEnabled; }
+
+void SystemClock::setEnabled(bool enabled) {
+	if (enabled == this->mEnabled) return;
+	this->mEnabled = enabled;
+	emit this->enabledChanged();
+	this->update();
+}
+
+SystemClock::Enum SystemClock::precision() const { return this->mPrecision; }
+
+void SystemClock::setPrecision(SystemClock::Enum precision) {
+	if (precision == this->mPrecision) return;
+	this->mPrecision = precision;
+	emit this->precisionChanged();
+	this->update();
+}
+
+void SystemClock::onTimeout() {
+	this->setTime(this->targetTime);
+	this->schedule(this->targetTime);
+}
+
+void SystemClock::update() {
+	if (this->mEnabled) {
+		this->setTime(QDateTime::fromMSecsSinceEpoch(0));
+		this->schedule(QDateTime::fromMSecsSinceEpoch(0));
+	} else {
+		this->timer.stop();
+	}
+}
+
+void SystemClock::setTime(const QDateTime& targetTime) {
+	auto currentTime = QDateTime::currentDateTime();
+	auto offset = currentTime.msecsTo(targetTime);
+	this->currentTime = offset > -500 && offset < 500 ? targetTime : currentTime;
+
+	auto time = this->currentTime.time();
+	this->currentTime.setTime(QTime(
+	    this->mPrecision >= SystemClock::Hours ? time.hour() : 0,
+	    this->mPrecision >= SystemClock::Minutes ? time.minute() : 0,
+	    this->mPrecision >= SystemClock::Seconds ? time.second() : 0
+	));
+
+	emit this->dateChanged();
+}
+
+void SystemClock::schedule(const QDateTime& targetTime) {
+	auto secondPrecision = this->mPrecision >= SystemClock::Seconds;
+	auto minutePrecision = this->mPrecision >= SystemClock::Minutes;
+	auto hourPrecision = this->mPrecision >= SystemClock::Hours;
+
+	auto currentTime = QDateTime::currentDateTime();
+
+	auto offset = currentTime.msecsTo(targetTime);
+
+	// timer skew
+	auto nextTime = offset > 0 && offset < 500 ? targetTime : currentTime;
+
+	auto baseTimeT = nextTime.time();
+	nextTime.setTime(QTime(
+	    hourPrecision ? baseTimeT.hour() : 0,
+	    minutePrecision ? baseTimeT.minute() : 0,
+	    secondPrecision ? baseTimeT.second() : 0
+	));
+
+	if (secondPrecision) nextTime = nextTime.addSecs(1);
+	else if (minutePrecision) nextTime = nextTime.addSecs(60);
+	else if (hourPrecision) nextTime = nextTime.addSecs(3600);
+
+	auto delay = currentTime.msecsTo(nextTime);
+
+	this->timer.start(static_cast<qint32>(delay));
+	this->targetTime = nextTime;
+}
diff --git a/src/core/clock.hpp b/src/core/clock.hpp
new file mode 100644
index 00000000..67461911
--- /dev/null
+++ b/src/core/clock.hpp
@@ -0,0 +1,91 @@
+#pragma once
+
+#include <qdatetime.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtimer.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+///! System clock accessor.
+/// SystemClock is a view into the system's clock.
+/// It updates at hour, minute, or second intervals depending on @@precision.
+///
+/// # Examples
+/// ```qml
+/// SystemClock {
+///   id: clock
+///   precision: SystemClock.Seconds
+/// }
+///
+/// @@QtQuick.Text {
+///   text: Qt.formatDateTime(clock.date, "hh:mm:ss - yyyy-MM-dd")
+/// }
+/// ```
+///
+/// > [!WARNING] Clock updates will trigger within 50ms of the system clock changing,
+/// > however this can be either before or after the clock changes (+-50ms). If you
+/// > need a date object, use @@date instead of constructing a new one, or the time
+/// > of the constructed object could be off by up to a second.
+class SystemClock: public QObject {
+	Q_OBJECT;
+	/// If the clock should update. Defaults to true.
+	///
+	/// Setting enabled to false pauses the clock.
+	Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged);
+	/// The precision the clock should measure at. Defaults to `SystemClock.Seconds`.
+	Q_PROPERTY(SystemClock::Enum precision READ precision WRITE setPrecision NOTIFY precisionChanged);
+	/// The current date and time.
+	///
+	/// > [!TIP] You can use @@QtQml.Qt.formatDateTime() to get the time as a string in
+	/// > your format of choice.
+	Q_PROPERTY(QDateTime date READ date NOTIFY dateChanged);
+	/// The current hour.
+	Q_PROPERTY(quint32 hours READ hours NOTIFY dateChanged);
+	/// The current minute, or 0 if @@precision is `SystemClock.Hours`.
+	Q_PROPERTY(quint32 minutes READ minutes NOTIFY dateChanged);
+	/// The current second, or 0 if @@precision is `SystemClock.Hours` or `SystemClock.Minutes`.
+	Q_PROPERTY(quint32 seconds READ seconds NOTIFY dateChanged);
+	QML_ELEMENT;
+
+public:
+	// must be named enum until docgen is ready to handle member enums better
+	enum Enum : quint8 {
+		Hours = 1,
+		Minutes = 2,
+		Seconds = 3,
+	};
+	Q_ENUM(Enum);
+
+	explicit SystemClock(QObject* parent = nullptr);
+
+	[[nodiscard]] bool enabled() const;
+	void setEnabled(bool enabled);
+
+	[[nodiscard]] SystemClock::Enum precision() const;
+	void setPrecision(SystemClock::Enum precision);
+
+	[[nodiscard]] QDateTime date() const { return this->currentTime; }
+	[[nodiscard]] quint32 hours() const { return this->currentTime.time().hour(); }
+	[[nodiscard]] quint32 minutes() const { return this->currentTime.time().minute(); }
+	[[nodiscard]] quint32 seconds() const { return this->currentTime.time().second(); }
+
+signals:
+	void enabledChanged();
+	void precisionChanged();
+	void dateChanged();
+
+private slots:
+	void onTimeout();
+
+private:
+	bool mEnabled = true;
+	SystemClock::Enum mPrecision = SystemClock::Seconds;
+	QTimer timer;
+	QDateTime currentTime;
+	QDateTime targetTime;
+
+	void update();
+	void setTime(const QDateTime& targetTime);
+	void schedule(const QDateTime& targetTime);
+};
diff --git a/src/core/colorquantizer.cpp b/src/core/colorquantizer.cpp
new file mode 100644
index 00000000..6cfb05db
--- /dev/null
+++ b/src/core/colorquantizer.cpp
@@ -0,0 +1,242 @@
+#include "colorquantizer.hpp"
+#include <algorithm>
+
+#include <qatomic.h>
+#include <qcolor.h>
+#include <qdatetime.h>
+#include <qimage.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qminmax.h>
+#include <qnamespace.h>
+#include <qnumeric.h>
+#include <qobject.h>
+#include <qqmllist.h>
+#include <qrgb.h>
+#include <qthreadpool.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "logcat.hpp"
+
+namespace {
+QS_LOGGING_CATEGORY(logColorQuantizer, "quickshell.colorquantizer", QtWarningMsg);
+}
+
+ColorQuantizerOperation::ColorQuantizerOperation(QUrl* source, qreal depth, qreal rescaleSize)
+    : source(source)
+    , maxDepth(depth)
+    , rescaleSize(rescaleSize) {
+	setAutoDelete(false);
+}
+
+void ColorQuantizerOperation::quantizeImage(const QAtomicInteger<bool>& shouldCancel) {
+	if (shouldCancel.loadAcquire() || source->isEmpty()) return;
+
+	colors.clear();
+
+	auto image = QImage(source->toLocalFile());
+	if ((image.width() > rescaleSize || image.height() > rescaleSize) && rescaleSize > 0) {
+		image = image.scaled(
+		    static_cast<int>(rescaleSize),
+		    static_cast<int>(rescaleSize),
+		    Qt::KeepAspectRatio,
+		    Qt::SmoothTransformation
+		);
+	}
+
+	if (image.isNull()) {
+		qCWarning(logColorQuantizer) << "Failed to load image from" << source->toString();
+		return;
+	}
+
+	QList<QColor> pixels;
+	for (int y = 0; y != image.height(); ++y) {
+		for (int x = 0; x != image.width(); ++x) {
+			auto pixel = image.pixel(x, y);
+			if (qAlpha(pixel) == 0) continue;
+
+			pixels.append(QColor::fromRgb(pixel));
+		}
+	}
+
+	auto startTime = QDateTime::currentDateTime();
+
+	colors = quantization(pixels, 0);
+
+	auto endTime = QDateTime::currentDateTime();
+	auto milliseconds = startTime.msecsTo(endTime);
+	qCDebug(logColorQuantizer) << "Color Quantization took: " << milliseconds << "ms";
+}
+
+QList<QColor> ColorQuantizerOperation::quantization(
+    QList<QColor>& rgbValues,
+    qreal depth,
+    const QAtomicInteger<bool>& shouldCancel
+) {
+	if (shouldCancel.loadAcquire()) return QList<QColor>();
+
+	if (depth >= maxDepth || rgbValues.isEmpty()) {
+		if (rgbValues.isEmpty()) return QList<QColor>();
+
+		auto totalR = 0;
+		auto totalG = 0;
+		auto totalB = 0;
+
+		for (const auto& color: rgbValues) {
+			if (shouldCancel.loadAcquire()) return QList<QColor>();
+
+			totalR += color.red();
+			totalG += color.green();
+			totalB += color.blue();
+		}
+
+		auto avgColor = QColor(
+		    qRound(totalR / static_cast<double>(rgbValues.size())),
+		    qRound(totalG / static_cast<double>(rgbValues.size())),
+		    qRound(totalB / static_cast<double>(rgbValues.size()))
+		);
+
+		return QList<QColor>() << avgColor;
+	}
+
+	auto dominantChannel = findBiggestColorRange(rgbValues);
+	std::ranges::sort(rgbValues, [dominantChannel](const auto& a, const auto& b) {
+		if (dominantChannel == 'r') return a.red() < b.red();
+		else if (dominantChannel == 'g') return a.green() < b.green();
+		return a.blue() < b.blue();
+	});
+
+	auto mid = rgbValues.size() / 2;
+
+	auto leftHalf = rgbValues.mid(0, mid);
+	auto rightHalf = rgbValues.mid(mid);
+
+	QList<QColor> result;
+	result.append(quantization(leftHalf, depth + 1));
+	result.append(quantization(rightHalf, depth + 1));
+
+	return result;
+}
+
+char ColorQuantizerOperation::findBiggestColorRange(const QList<QColor>& rgbValues) {
+	if (rgbValues.isEmpty()) return 'r';
+
+	auto rMin = 255;
+	auto gMin = 255;
+	auto bMin = 255;
+	auto rMax = 0;
+	auto gMax = 0;
+	auto bMax = 0;
+
+	for (const auto& color: rgbValues) {
+		rMin = qMin(rMin, color.red());
+		gMin = qMin(gMin, color.green());
+		bMin = qMin(bMin, color.blue());
+
+		rMax = qMax(rMax, color.red());
+		gMax = qMax(gMax, color.green());
+		bMax = qMax(bMax, color.blue());
+	}
+
+	auto rRange = rMax - rMin;
+	auto gRange = gMax - gMin;
+	auto bRange = bMax - bMin;
+
+	auto biggestRange = qMax(rRange, qMax(gRange, bRange));
+	if (biggestRange == rRange) {
+		return 'r';
+	} else if (biggestRange == gRange) {
+		return 'g';
+	} else {
+		return 'b';
+	}
+}
+
+void ColorQuantizerOperation::finishRun() {
+	QMetaObject::invokeMethod(this, &ColorQuantizerOperation::finished, Qt::QueuedConnection);
+}
+
+void ColorQuantizerOperation::finished() {
+	emit this->done(colors);
+	delete this;
+}
+
+void ColorQuantizerOperation::run() {
+	if (!this->shouldCancel) {
+		this->quantizeImage();
+
+		if (this->shouldCancel.loadAcquire()) {
+			qCDebug(logColorQuantizer) << "Color quantization" << this << "cancelled";
+		}
+	}
+
+	this->finishRun();
+}
+
+void ColorQuantizerOperation::tryCancel() { this->shouldCancel.storeRelease(true); }
+
+void ColorQuantizer::componentComplete() {
+	componentCompleted = true;
+	if (!mSource.isEmpty()) quantizeAsync();
+}
+
+void ColorQuantizer::setSource(const QUrl& source) {
+	if (mSource != source) {
+		mSource = source;
+		emit this->sourceChanged();
+
+		if (this->componentCompleted && !mSource.isEmpty()) quantizeAsync();
+	}
+}
+
+void ColorQuantizer::setDepth(qreal depth) {
+	if (mDepth != depth) {
+		mDepth = depth;
+		emit this->depthChanged();
+
+		if (this->componentCompleted) quantizeAsync();
+	}
+}
+
+void ColorQuantizer::setRescaleSize(int rescaleSize) {
+	if (mRescaleSize != rescaleSize) {
+		mRescaleSize = rescaleSize;
+		emit this->rescaleSizeChanged();
+
+		if (this->componentCompleted) quantizeAsync();
+	}
+}
+
+void ColorQuantizer::operationFinished(const QList<QColor>& result) {
+	bColors = result;
+	this->liveOperation = nullptr;
+	emit this->colorsChanged();
+}
+
+void ColorQuantizer::quantizeAsync() {
+	if (this->liveOperation) this->cancelAsync();
+
+	qCDebug(logColorQuantizer) << "Starting color quantization asynchronously";
+	this->liveOperation = new ColorQuantizerOperation(&mSource, mDepth, mRescaleSize);
+
+	QObject::connect(
+	    this->liveOperation,
+	    &ColorQuantizerOperation::done,
+	    this,
+	    &ColorQuantizer::operationFinished
+	);
+
+	QThreadPool::globalInstance()->start(this->liveOperation);
+}
+
+void ColorQuantizer::cancelAsync() {
+	if (!this->liveOperation) return;
+
+	this->liveOperation->tryCancel();
+	QThreadPool::globalInstance()->waitForDone();
+
+	QObject::disconnect(this->liveOperation, nullptr, this, nullptr);
+	this->liveOperation = nullptr;
+}
diff --git a/src/core/colorquantizer.hpp b/src/core/colorquantizer.hpp
new file mode 100644
index 00000000..d35a15ac
--- /dev/null
+++ b/src/core/colorquantizer.hpp
@@ -0,0 +1,128 @@
+#pragma once
+
+#include <qlist.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qqmlparserstatus.h>
+#include <qrunnable.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qurl.h>
+
+class ColorQuantizerOperation
+    : public QObject
+    , public QRunnable {
+	Q_OBJECT;
+
+public:
+	explicit ColorQuantizerOperation(QUrl* source, qreal depth, qreal rescaleSize);
+
+	void run() override;
+	void tryCancel();
+
+signals:
+	void done(QList<QColor> colors);
+
+private slots:
+	void finished();
+
+private:
+	static char findBiggestColorRange(const QList<QColor>& rgbValues);
+
+	void quantizeImage(const QAtomicInteger<bool>& shouldCancel = false);
+
+	QList<QColor> quantization(
+	    QList<QColor>& rgbValues,
+	    qreal depth,
+	    const QAtomicInteger<bool>& shouldCancel = false
+	);
+
+	void finishRun();
+
+	QAtomicInteger<bool> shouldCancel = false;
+	QList<QColor> colors;
+	QUrl* source;
+	qreal maxDepth;
+	qreal rescaleSize;
+};
+
+///! Color Quantization Utility
+/// A color quantization utility used for getting prevalent colors in an image, by
+/// averaging out the image's color data recursively.
+///
+/// #### Example
+/// ```qml
+/// ColorQuantizer {
+///   id: colorQuantizer
+///   source: Qt.resolvedUrl("./yourImage.png")
+///   depth: 3 // Will produce 8 colors (2³)
+///   rescaleSize: 64 // Rescale to 64x64 for faster processing
+/// }
+/// ```
+class ColorQuantizer
+    : public QObject
+    , public QQmlParserStatus {
+	Q_OBJECT;
+	QML_ELEMENT;
+	Q_INTERFACES(QQmlParserStatus);
+	/// Access the colors resulting from the color quantization performed.
+	/// > [!NOTE] The amount of colors returned from the quantization is determined by
+	/// > the property depth, specifically 2ⁿ where n is the depth.
+	Q_PROPERTY(QList<QColor> colors READ default NOTIFY colorsChanged BINDABLE bindableColors);
+
+	/// Path to the image you'd like to run the color quantization on.
+	Q_PROPERTY(QUrl source READ source WRITE setSource NOTIFY sourceChanged);
+
+	/// Max depth for the color quantization. Each level of depth represents another
+	/// binary split of the color space
+	Q_PROPERTY(qreal depth READ depth WRITE setDepth NOTIFY depthChanged);
+
+	/// The size to rescale the image to, when rescaleSize is 0 then no scaling will be done.
+	/// > [!NOTE] Results from color quantization doesn't suffer much when rescaling, it's
+	/// > reccommended to rescale, otherwise the quantization process will take much longer.
+	Q_PROPERTY(qreal rescaleSize READ rescaleSize WRITE setRescaleSize NOTIFY rescaleSizeChanged);
+
+public:
+	explicit ColorQuantizer(QObject* parent = nullptr): QObject(parent) {}
+
+	void componentComplete() override;
+	void classBegin() override {}
+
+	[[nodiscard]] QBindable<QList<QColor>> bindableColors() { return &this->bColors; }
+
+	[[nodiscard]] QUrl source() const { return mSource; }
+	void setSource(const QUrl& source);
+
+	[[nodiscard]] qreal depth() const { return mDepth; }
+	void setDepth(qreal depth);
+
+	[[nodiscard]] qreal rescaleSize() const { return mRescaleSize; }
+	void setRescaleSize(int rescaleSize);
+
+signals:
+	void colorsChanged();
+	void sourceChanged();
+	void depthChanged();
+	void rescaleSizeChanged();
+
+public slots:
+	void operationFinished(const QList<QColor>& result);
+
+private:
+	void quantizeAsync();
+	void cancelAsync();
+
+	bool componentCompleted = false;
+	ColorQuantizerOperation* liveOperation = nullptr;
+	QUrl mSource;
+	qreal mDepth = 0;
+	qreal mRescaleSize = 0;
+
+	Q_OBJECT_BINDABLE_PROPERTY(
+	    ColorQuantizer,
+	    QList<QColor>,
+	    bColors,
+	    &ColorQuantizer::colorsChanged
+	);
+};
diff --git a/src/core/common.cpp b/src/core/common.cpp
new file mode 100644
index 00000000..080019ab
--- /dev/null
+++ b/src/core/common.cpp
@@ -0,0 +1,9 @@
+#include "common.hpp"
+
+#include <qdatetime.h>
+
+namespace qs {
+
+const QDateTime Common::LAUNCH_TIME = QDateTime::currentDateTime();
+
+} // namespace qs
diff --git a/src/core/common.hpp b/src/core/common.hpp
new file mode 100644
index 00000000..ab8edb80
--- /dev/null
+++ b/src/core/common.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <qdatetime.h>
+#include <qprocess.h>
+
+namespace qs {
+
+struct Common {
+	static const QDateTime LAUNCH_TIME;
+	static inline QProcessEnvironment INITIAL_ENVIRONMENT = {}; // NOLINT
+};
+
+} // namespace qs
diff --git a/src/core/desktopentry.cpp b/src/core/desktopentry.cpp
new file mode 100644
index 00000000..95fcb89e
--- /dev/null
+++ b/src/core/desktopentry.cpp
@@ -0,0 +1,422 @@
+#include "desktopentry.hpp"
+#include <algorithm>
+
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qdir.h>
+#include <qfileinfo.h>
+#include <qhash.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qpair.h>
+#include <qstringview.h>
+#include <qtenvironmentvariables.h>
+#include <ranges>
+
+#include "../io/processcore.hpp"
+#include "logcat.hpp"
+#include "model.hpp"
+#include "qmlglobal.hpp"
+
+namespace {
+QS_LOGGING_CATEGORY(logDesktopEntry, "quickshell.desktopentry", QtWarningMsg);
+}
+
+struct Locale {
+	explicit Locale() = default;
+
+	explicit Locale(const QString& string) {
+		auto territoryIdx = string.indexOf('_');
+		auto codesetIdx = string.indexOf('.');
+		auto modifierIdx = string.indexOf('@');
+
+		auto parseEnd = string.length();
+
+		if (modifierIdx != -1) {
+			this->modifier = string.sliced(modifierIdx + 1, parseEnd - modifierIdx - 1);
+			parseEnd = modifierIdx;
+		}
+
+		if (codesetIdx != -1) {
+			parseEnd = codesetIdx;
+		}
+
+		if (territoryIdx != -1) {
+			this->territory = string.sliced(territoryIdx + 1, parseEnd - territoryIdx - 1);
+			parseEnd = territoryIdx;
+		}
+
+		this->language = string.sliced(0, parseEnd);
+	}
+
+	[[nodiscard]] bool isValid() const { return !this->language.isEmpty(); }
+
+	[[nodiscard]] int matchScore(const Locale& other) const {
+		if (this->language != other.language) return 0;
+		auto territoryMatches = !this->territory.isEmpty() && this->territory == other.territory;
+		auto modifierMatches = !this->modifier.isEmpty() && this->modifier == other.modifier;
+
+		auto score = 1;
+		if (territoryMatches) score += 2;
+		if (modifierMatches) score += 1;
+
+		return score;
+	}
+
+	static const Locale& system() {
+		static Locale* locale = nullptr; // NOLINT
+
+		if (locale == nullptr) {
+			auto lstr = qEnvironmentVariable("LC_MESSAGES");
+			if (lstr.isEmpty()) lstr = qEnvironmentVariable("LANG");
+			locale = new Locale(lstr);
+		}
+
+		return *locale;
+	}
+
+	QString language;
+	QString territory;
+	QString modifier;
+};
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+QDebug operator<<(QDebug debug, const Locale& locale) {
+	auto saver = QDebugStateSaver(debug);
+	debug.nospace() << "Locale(language=" << locale.language << ", territory=" << locale.territory
+	                << ", modifier" << locale.modifier << ')';
+
+	return debug;
+}
+
+void DesktopEntry::parseEntry(const QString& text) {
+	const auto& system = Locale::system();
+
+	auto groupName = QString();
+	auto entries = QHash<QString, QPair<Locale, QString>>();
+
+	auto finishCategory = [this, &groupName, &entries]() {
+		if (groupName == "Desktop Entry") {
+			if (entries["Type"].second != "Application") return;
+			if (entries.contains("Hidden") && entries["Hidden"].second == "true") return;
+
+			for (const auto& [key, pair]: entries.asKeyValueRange()) {
+				auto& [_, value] = pair;
+				this->mEntries.insert(key, value);
+
+				if (key == "Name") this->mName = value;
+				else if (key == "GenericName") this->mGenericName = value;
+				else if (key == "StartupWMClass") this->mStartupClass = value;
+				else if (key == "NoDisplay") this->mNoDisplay = value == "true";
+				else if (key == "Comment") this->mComment = value;
+				else if (key == "Icon") this->mIcon = value;
+				else if (key == "Exec") {
+					this->mExecString = value;
+					this->mCommand = DesktopEntry::parseExecString(value);
+				} else if (key == "Path") this->mWorkingDirectory = value;
+				else if (key == "Terminal") this->mTerminal = value == "true";
+				else if (key == "Categories") this->mCategories = value.split(u';', Qt::SkipEmptyParts);
+				else if (key == "Keywords") this->mKeywords = value.split(u';', Qt::SkipEmptyParts);
+			}
+		} else if (groupName.startsWith("Desktop Action ")) {
+			auto actionName = groupName.sliced(16);
+			auto* action = new DesktopAction(actionName, this);
+
+			for (const auto& [key, pair]: entries.asKeyValueRange()) {
+				const auto& [_, value] = pair;
+				action->mEntries.insert(key, value);
+
+				if (key == "Name") action->mName = value;
+				else if (key == "Icon") action->mIcon = value;
+				else if (key == "Exec") {
+					action->mExecString = value;
+					action->mCommand = DesktopEntry::parseExecString(value);
+				}
+			}
+
+			this->mActions.insert(actionName, action);
+		}
+
+		entries.clear();
+	};
+
+	for (auto& line: text.split(u'\n', Qt::SkipEmptyParts)) {
+		if (line.startsWith(u'#')) continue;
+
+		if (line.startsWith(u'[') && line.endsWith(u']')) {
+			finishCategory();
+			groupName = line.sliced(1, line.length() - 2);
+			continue;
+		}
+
+		auto splitIdx = line.indexOf(u'=');
+		if (splitIdx == -1) {
+			qCWarning(logDesktopEntry) << "Encountered invalid line in desktop entry (no =)" << line;
+			continue;
+		}
+
+		auto key = line.sliced(0, splitIdx);
+		const auto& value = line.sliced(splitIdx + 1);
+
+		auto localeIdx = key.indexOf('[');
+		Locale locale;
+		if (localeIdx != -1 && localeIdx != key.length() - 1) {
+			locale = Locale(key.sliced(localeIdx + 1, key.length() - localeIdx - 2));
+			key = key.sliced(0, localeIdx);
+		}
+
+		if (entries.contains(key)) {
+			const auto& old = entries.value(key);
+
+			auto oldScore = system.matchScore(old.first);
+			auto newScore = system.matchScore(locale);
+
+			if (newScore > oldScore || (oldScore == 0 && !locale.isValid())) {
+				entries.insert(key, qMakePair(locale, value));
+			}
+		} else {
+			entries.insert(key, qMakePair(locale, value));
+		}
+	}
+
+	finishCategory();
+}
+
+void DesktopEntry::execute() const {
+	DesktopEntry::doExec(this->mCommand, this->mWorkingDirectory);
+}
+
+bool DesktopEntry::isValid() const { return !this->mName.isEmpty(); }
+bool DesktopEntry::noDisplay() const { return this->mNoDisplay; }
+
+QVector<DesktopAction*> DesktopEntry::actions() const { return this->mActions.values(); }
+
+QVector<QString> DesktopEntry::parseExecString(const QString& execString) {
+	QVector<QString> arguments;
+	QString currentArgument;
+	auto parsingString = false;
+	auto escape = 0;
+	auto percent = false;
+
+	for (auto c: execString) {
+		if (escape == 0 && c == u'\\') {
+			escape = 1;
+		} else if (parsingString) {
+			if (c == '\\') {
+				escape++;
+				if (escape == 4) {
+					currentArgument += '\\';
+					escape = 0;
+				}
+			} else if (escape != 0) {
+				if (escape != 2) {
+					// Technically this is an illegal state, but the spec has a terrible double escape
+					// rule in strings for no discernable reason. Assuming someone might understandably
+					// misunderstand it, treat it as a normal escape and log it.
+					qCWarning(logDesktopEntry).noquote()
+					    << "Illegal escape sequence in desktop entry exec string:" << execString;
+				}
+
+				currentArgument += c;
+				escape = 0;
+			} else if (c == u'"' || c == u'\'') {
+				parsingString = false;
+			} else {
+				currentArgument += c;
+			}
+		} else if (escape != 0) {
+			currentArgument += c;
+			escape = 0;
+		} else if (percent) {
+			if (c == '%') {
+				currentArgument += '%';
+			} // else discard
+
+			percent = false;
+		} else if (c == '%') {
+			percent = true;
+		} else if (c == u'"' || c == u'\'') {
+			parsingString = true;
+		} else if (c == u' ') {
+			if (!currentArgument.isEmpty()) {
+				arguments.push_back(currentArgument);
+				currentArgument.clear();
+			}
+		} else {
+			currentArgument += c;
+		}
+	}
+
+	if (!currentArgument.isEmpty()) {
+		arguments.push_back(currentArgument);
+		currentArgument.clear();
+	}
+
+	return arguments;
+}
+
+void DesktopEntry::doExec(const QList<QString>& execString, const QString& workingDirectory) {
+	qs::io::process::ProcessContext ctx;
+	ctx.setCommand(execString);
+	ctx.setWorkingDirectory(workingDirectory);
+	QuickshellGlobal::execDetached(ctx);
+}
+
+void DesktopAction::execute() const {
+	DesktopEntry::doExec(this->mCommand, this->entry->mWorkingDirectory);
+}
+
+DesktopEntryManager::DesktopEntryManager() {
+	this->scanDesktopEntries();
+	this->populateApplications();
+}
+
+void DesktopEntryManager::scanDesktopEntries() {
+	QList<QString> dataPaths;
+
+	if (qEnvironmentVariableIsSet("XDG_DATA_HOME")) {
+		dataPaths.push_back(qEnvironmentVariable("XDG_DATA_HOME"));
+	} else if (qEnvironmentVariableIsSet("HOME")) {
+		dataPaths.push_back(qEnvironmentVariable("HOME") + "/.local/share");
+	}
+
+	if (qEnvironmentVariableIsSet("XDG_DATA_DIRS")) {
+		auto var = qEnvironmentVariable("XDG_DATA_DIRS");
+		dataPaths += var.split(u':', Qt::SkipEmptyParts);
+	} else {
+		dataPaths.push_back("/usr/local/share");
+		dataPaths.push_back("/usr/share");
+	}
+
+	qCDebug(logDesktopEntry) << "Creating desktop entry scanners";
+
+	for (auto& path: std::ranges::reverse_view(dataPaths)) {
+		auto p = QDir(path).filePath("applications");
+		auto file = QFileInfo(p);
+
+		if (!file.isDir()) {
+			qCDebug(logDesktopEntry) << "Not scanning path" << p << "as it is not a directory";
+			continue;
+		}
+
+		qCDebug(logDesktopEntry) << "Scanning path" << p;
+		this->scanPath(p);
+	}
+}
+
+void DesktopEntryManager::populateApplications() {
+	for (auto& entry: this->desktopEntries.values()) {
+		if (!entry->noDisplay()) this->mApplications.insertObject(entry);
+	}
+}
+
+void DesktopEntryManager::scanPath(const QDir& dir, const QString& prefix) {
+	auto entries = dir.entryInfoList(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot);
+
+	for (auto& entry: entries) {
+		if (entry.isDir()) this->scanPath(entry.absoluteFilePath(), prefix + dir.dirName() + "-");
+		else if (entry.isFile()) {
+			auto path = entry.filePath();
+			if (!path.endsWith(".desktop")) {
+				qCDebug(logDesktopEntry) << "Skipping file" << path << "as it has no .desktop extension";
+				continue;
+			}
+
+			auto file = QFile(path);
+			if (!file.open(QFile::ReadOnly)) {
+				qCDebug(logDesktopEntry) << "Could not open file" << path;
+				continue;
+			}
+
+			auto id = prefix + entry.fileName().sliced(0, entry.fileName().length() - 8);
+			auto lowerId = id.toLower();
+
+			auto text = QString::fromUtf8(file.readAll());
+			auto* dentry = new DesktopEntry(id, this);
+			dentry->parseEntry(text);
+
+			if (!dentry->isValid()) {
+				qCDebug(logDesktopEntry) << "Skipping desktop entry" << path;
+				delete dentry;
+				continue;
+			}
+
+			qCDebug(logDesktopEntry) << "Found desktop entry" << id << "at" << path;
+
+			auto conflictingId = this->desktopEntries.contains(id);
+
+			if (conflictingId) {
+				qCDebug(logDesktopEntry) << "Replacing old entry for" << id;
+				delete this->desktopEntries.value(id);
+				this->desktopEntries.remove(id);
+				this->lowercaseDesktopEntries.remove(lowerId);
+			}
+
+			this->desktopEntries.insert(id, dentry);
+
+			if (this->lowercaseDesktopEntries.contains(lowerId)) {
+				qCInfo(logDesktopEntry).nospace()
+				    << "Multiple desktop entries have the same lowercased id " << lowerId
+				    << ". This can cause ambiguity when byId requests are not made with the correct case "
+				       "already.";
+
+				this->lowercaseDesktopEntries.remove(lowerId);
+			}
+
+			this->lowercaseDesktopEntries.insert(lowerId, dentry);
+		}
+	}
+}
+
+DesktopEntryManager* DesktopEntryManager::instance() {
+	static auto* instance = new DesktopEntryManager(); // NOLINT
+	return instance;
+}
+
+DesktopEntry* DesktopEntryManager::byId(const QString& id) {
+	if (auto* entry = this->desktopEntries.value(id)) {
+		return entry;
+	} else if (auto* entry = this->lowercaseDesktopEntries.value(id.toLower())) {
+		return entry;
+	} else {
+		return nullptr;
+	}
+}
+
+DesktopEntry* DesktopEntryManager::heuristicLookup(const QString& name) {
+	if (auto* entry = this->byId(name)) return entry;
+
+	auto list = this->desktopEntries.values();
+
+	auto iter = std::ranges::find_if(list, [&](const DesktopEntry* entry) {
+		return name == entry->mStartupClass;
+	});
+
+	if (iter != list.end()) return *iter;
+
+	iter = std::ranges::find_if(list, [&](const DesktopEntry* entry) {
+		return name.toLower() == entry->mStartupClass.toLower();
+	});
+
+	if (iter != list.end()) return *iter;
+	return nullptr;
+}
+
+ObjectModel<DesktopEntry>* DesktopEntryManager::applications() { return &this->mApplications; }
+
+DesktopEntries::DesktopEntries() { DesktopEntryManager::instance(); }
+
+DesktopEntry* DesktopEntries::byId(const QString& id) {
+	return DesktopEntryManager::instance()->byId(id);
+}
+
+DesktopEntry* DesktopEntries::heuristicLookup(const QString& name) {
+	return DesktopEntryManager::instance()->heuristicLookup(name);
+}
+
+ObjectModel<DesktopEntry>* DesktopEntries::applications() {
+	return DesktopEntryManager::instance()->applications();
+}
diff --git a/src/core/desktopentry.hpp b/src/core/desktopentry.hpp
new file mode 100644
index 00000000..827a6187
--- /dev/null
+++ b/src/core/desktopentry.hpp
@@ -0,0 +1,204 @@
+#pragma once
+
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qdir.h>
+#include <qhash.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+
+#include "doc.hpp"
+#include "model.hpp"
+
+class DesktopAction;
+
+/// A desktop entry. See @@DesktopEntries for details.
+class DesktopEntry: public QObject {
+	Q_OBJECT;
+	Q_PROPERTY(QString id MEMBER mId CONSTANT);
+	/// Name of the specific application, such as "Firefox".
+	Q_PROPERTY(QString name MEMBER mName CONSTANT);
+	/// Short description of the application, such as "Web Browser". May be empty.
+	Q_PROPERTY(QString genericName MEMBER mGenericName CONSTANT);
+	/// Initial class or app id the app intends to use. May be useful for matching running apps
+	/// to desktop entries.
+	Q_PROPERTY(QString startupClass MEMBER mStartupClass CONSTANT);
+	/// If true, this application should not be displayed in menus and launchers.
+	Q_PROPERTY(bool noDisplay MEMBER mNoDisplay CONSTANT);
+	/// Long description of the application, such as "View websites on the internet". May be empty.
+	Q_PROPERTY(QString comment MEMBER mComment CONSTANT);
+	/// Name of the icon associated with this application. May be empty.
+	Q_PROPERTY(QString icon MEMBER mIcon CONSTANT);
+	/// The raw `Exec` string from the desktop entry.
+	///
+	/// > [!WARNING] This cannot be reliably run as a command. See @@command for one you can run.
+	Q_PROPERTY(QString execString MEMBER mExecString CONSTANT);
+	/// The parsed `Exec` command in the desktop entry.
+	///
+	/// The entry can be run with @@execute(), or by using this command in
+	/// @@Quickshell.Quickshell.execDetached() or @@Quickshell.Io.Process.
+	/// If used in `execDetached` or a `Process`, @@workingDirectory should also be passed to
+	/// the invoked process. See @@execute() for details.
+	///
+	/// > [!NOTE]	The provided command does not invoke a terminal even if @@runInTerminal is true.
+	Q_PROPERTY(QVector<QString> command MEMBER mCommand CONSTANT);
+	/// The working directory to execute from.
+	Q_PROPERTY(QString workingDirectory MEMBER mWorkingDirectory CONSTANT);
+	/// If the application should run in a terminal.
+	Q_PROPERTY(bool runInTerminal MEMBER mTerminal CONSTANT);
+	Q_PROPERTY(QVector<QString> categories MEMBER mCategories CONSTANT);
+	Q_PROPERTY(QVector<QString> keywords MEMBER mKeywords CONSTANT);
+	Q_PROPERTY(QVector<DesktopAction*> actions READ actions CONSTANT);
+	QML_ELEMENT;
+	QML_UNCREATABLE("DesktopEntry instances must be retrieved from DesktopEntries");
+
+public:
+	explicit DesktopEntry(QString id, QObject* parent): QObject(parent), mId(std::move(id)) {}
+
+	void parseEntry(const QString& text);
+
+	/// Run the application. Currently ignores @@runInTerminal and field codes.
+	///
+	/// This is equivalent to calling @@Quickshell.Quickshell.execDetached() with @@command
+	/// and @@DesktopEntry.workingDirectory as shown below:
+	///
+	/// ```qml
+	/// Quickshell.execDetached({
+	///   command: desktopEntry.command,
+	///   workingDirectory: desktopEntry.workingDirectory,
+	/// });
+	/// ```
+	Q_INVOKABLE void execute() const;
+
+	[[nodiscard]] bool isValid() const;
+	[[nodiscard]] bool noDisplay() const;
+	[[nodiscard]] QVector<DesktopAction*> actions() const;
+
+	// currently ignores all field codes.
+	static QVector<QString> parseExecString(const QString& execString);
+	static void doExec(const QList<QString>& execString, const QString& workingDirectory);
+
+public:
+	QString mId;
+	QString mName;
+	QString mGenericName;
+	QString mStartupClass;
+	bool mNoDisplay = false;
+	QString mComment;
+	QString mIcon;
+	QString mExecString;
+	QVector<QString> mCommand;
+	QString mWorkingDirectory;
+	bool mTerminal = false;
+	QVector<QString> mCategories;
+	QVector<QString> mKeywords;
+
+private:
+	QHash<QString, QString> mEntries;
+	QHash<QString, DesktopAction*> mActions;
+
+	friend class DesktopAction;
+};
+
+/// An action of a @@DesktopEntry$.
+class DesktopAction: public QObject {
+	Q_OBJECT;
+	Q_PROPERTY(QString id MEMBER mId CONSTANT);
+	Q_PROPERTY(QString name MEMBER mName CONSTANT);
+	Q_PROPERTY(QString icon MEMBER mIcon CONSTANT);
+	/// The raw `Exec` string from the action.
+	///
+	/// > [!WARNING] This cannot be reliably run as a command. See @@command for one you can run.
+	Q_PROPERTY(QString execString MEMBER mExecString CONSTANT);
+	/// The parsed `Exec` command in the action.
+	///
+	/// The entry can be run with @@execute(), or by using this command in
+	/// @@Quickshell.Quickshell.execDetached() or @@Quickshell.Io.Process.
+	/// If used in `execDetached` or a `Process`, @@DesktopEntry.workingDirectory should also be passed to
+	/// the invoked process.
+	///
+	/// > [!NOTE]	The provided command does not invoke a terminal even if @@runInTerminal is true.
+	Q_PROPERTY(QVector<QString> command MEMBER mCommand CONSTANT);
+	QML_ELEMENT;
+	QML_UNCREATABLE("DesktopAction instances must be retrieved from a DesktopEntry");
+
+public:
+	explicit DesktopAction(QString id, DesktopEntry* entry)
+	    : QObject(entry)
+	    , entry(entry)
+	    , mId(std::move(id)) {}
+
+	/// Run the application. Currently ignores @@DesktopEntry.runInTerminal and field codes.
+	///
+	/// This is equivalent to calling @@Quickshell.Quickshell.execDetached() with @@command
+	/// and @@DesktopEntry.workingDirectory.
+	Q_INVOKABLE void execute() const;
+
+private:
+	DesktopEntry* entry;
+	QString mId;
+	QString mName;
+	QString mIcon;
+	QString mExecString;
+	QVector<QString> mCommand;
+	QHash<QString, QString> mEntries;
+
+	friend class DesktopEntry;
+};
+
+class DesktopEntryManager: public QObject {
+	Q_OBJECT;
+
+public:
+	void scanDesktopEntries();
+
+	[[nodiscard]] DesktopEntry* byId(const QString& id);
+	[[nodiscard]] DesktopEntry* heuristicLookup(const QString& name);
+
+	[[nodiscard]] ObjectModel<DesktopEntry>* applications();
+
+	static DesktopEntryManager* instance();
+
+private:
+	explicit DesktopEntryManager();
+
+	void populateApplications();
+	void scanPath(const QDir& dir, const QString& prefix = QString());
+
+	QHash<QString, DesktopEntry*> desktopEntries;
+	QHash<QString, DesktopEntry*> lowercaseDesktopEntries;
+	ObjectModel<DesktopEntry> mApplications {this};
+};
+
+///! Desktop entry index.
+/// Index of desktop entries according to the [desktop entry specification].
+///
+/// Primarily useful for looking up icons and metadata from an id, as there is
+/// currently no mechanism for usage based sorting of entries and other launcher niceties.
+///
+/// [desktop entry specification]: https://specifications.freedesktop.org/desktop-entry-spec/latest/
+class DesktopEntries: public QObject {
+	Q_OBJECT;
+	/// All desktop entries of type Application that are not Hidden or NoDisplay.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<DesktopEntry>*);
+	Q_PROPERTY(UntypedObjectModel* applications READ applications CONSTANT);
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	explicit DesktopEntries();
+
+	/// Look up a desktop entry by name. Includes NoDisplay entries. May return null.
+	///
+	/// While this function requires an exact match, @@heuristicLookup() will correctly
+	/// find an entry more often and is generally more useful.
+	Q_INVOKABLE [[nodiscard]] static DesktopEntry* byId(const QString& id);
+	/// Look up a desktop entry by name using heuristics. Unlike @@byId(),
+	/// if no exact matches are found this function will try to guess - potentially incorrectly.
+	/// May return null.
+	Q_INVOKABLE [[nodiscard]] static DesktopEntry* heuristicLookup(const QString& name);
+
+	[[nodiscard]] static ObjectModel<DesktopEntry>* applications();
+};
diff --git a/src/core/doc.hpp b/src/core/doc.hpp
index e4c907aa..fbb21400 100644
--- a/src/core/doc.hpp
+++ b/src/core/doc.hpp
@@ -9,3 +9,15 @@
 // make the type visible in the docs even if not a QML_ELEMENT
 #define QSDOC_ELEMENT
 #define QSDOC_NAMED_ELEMENT(name)
+
+// unmark uncreatable (will be overlayed by other types)
+#define QSDOC_CREATABLE
+
+// change the cname used for this type
+#define QSDOC_CNAME(name)
+
+// overridden properties
+#define QSDOC_PROPERTY_OVERRIDE(...)
+
+// override types of properties for docs
+#define QSDOC_TYPE_OVERRIDE(type)
diff --git a/src/core/easingcurve.cpp b/src/core/easingcurve.cpp
new file mode 100644
index 00000000..a758bd3c
--- /dev/null
+++ b/src/core/easingcurve.cpp
@@ -0,0 +1,33 @@
+#include "easingcurve.hpp"
+#include <utility>
+
+#include <qeasingcurve.h>
+#include <qpoint.h>
+#include <qrect.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+qreal EasingCurve::valueAt(qreal x) const { return this->mCurve.valueForProgress(x); }
+
+qreal EasingCurve::interpolate(qreal x, qreal a, qreal b) const {
+	return a + (b - a) * this->valueAt(x);
+}
+
+QPointF EasingCurve::interpolate(qreal x, const QPointF& a, const QPointF& b) const {
+	return QPointF(this->interpolate(x, a.x(), b.x()), this->interpolate(x, a.y(), b.y()));
+}
+
+QRectF EasingCurve::interpolate(qreal x, const QRectF& a, const QRectF& b) const {
+	return QRectF(
+	    this->interpolate(x, a.topLeft(), b.topLeft()),
+	    this->interpolate(x, a.bottomRight(), b.bottomRight())
+	);
+}
+
+QEasingCurve EasingCurve::curve() const { return this->mCurve; }
+
+void EasingCurve::setCurve(QEasingCurve curve) {
+	if (this->mCurve == curve) return;
+	this->mCurve = std::move(curve);
+	emit this->curveChanged();
+}
diff --git a/src/core/easingcurve.hpp b/src/core/easingcurve.hpp
new file mode 100644
index 00000000..ef210383
--- /dev/null
+++ b/src/core/easingcurve.hpp
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <qeasingcurve.h>
+#include <qobject.h>
+#include <qpoint.h>
+#include <qqmlintegration.h>
+#include <qrect.h>
+#include <qtmetamacros.h>
+
+///! Easing curve.
+/// Directly accessible easing curve as used in property animations.
+class EasingCurve: public QObject {
+	Q_OBJECT;
+	/// Easing curve settings. Works exactly the same as
+	/// [PropertyAnimation.easing](https://doc.qt.io/qt-6/qml-qtquick-propertyanimation.html#easing-prop).
+	Q_PROPERTY(QEasingCurve curve READ curve WRITE setCurve NOTIFY curveChanged);
+	QML_ELEMENT;
+
+public:
+	EasingCurve(QObject* parent = nullptr): QObject(parent) {}
+
+	/// Returns the Y value for the given X value on the curve
+	/// from 0.0 to 1.0.
+	Q_INVOKABLE [[nodiscard]] qreal valueAt(qreal x) const;
+	/// Interpolates between two values using the given X coordinate.
+	Q_INVOKABLE [[nodiscard]] qreal interpolate(qreal x, qreal a, qreal b) const;
+	/// Interpolates between two points using the given X coordinate.
+	Q_INVOKABLE [[nodiscard]] QPointF interpolate(qreal x, const QPointF& a, const QPointF& b) const;
+	/// Interpolates two rects using the given X coordinate.
+	Q_INVOKABLE [[nodiscard]] QRectF interpolate(qreal x, const QRectF& a, const QRectF& b) const;
+
+	[[nodiscard]] QEasingCurve curve() const;
+	void setCurve(QEasingCurve curve);
+
+signals:
+	void curveChanged();
+
+private:
+	QEasingCurve mCurve;
+};
diff --git a/src/core/elapsedtimer.cpp b/src/core/elapsedtimer.cpp
new file mode 100644
index 00000000..91321122
--- /dev/null
+++ b/src/core/elapsedtimer.cpp
@@ -0,0 +1,22 @@
+#include "elapsedtimer.hpp"
+
+#include <qtypes.h>
+
+ElapsedTimer::ElapsedTimer() { this->timer.start(); }
+
+qreal ElapsedTimer::elapsed() { return static_cast<qreal>(this->elapsedNs()) / 1000000000.0; }
+
+qreal ElapsedTimer::restart() { return static_cast<qreal>(this->restartNs()) / 1000000000.0; }
+
+qint64 ElapsedTimer::elapsedMs() { return this->timer.elapsed(); }
+
+qint64 ElapsedTimer::restartMs() { return this->timer.restart(); }
+
+qint64 ElapsedTimer::elapsedNs() { return this->timer.nsecsElapsed(); }
+
+qint64 ElapsedTimer::restartNs() {
+	// see qelapsedtimer.cpp
+	auto old = this->timer;
+	this->timer.start();
+	return old.durationTo(this->timer).count();
+}
diff --git a/src/core/elapsedtimer.hpp b/src/core/elapsedtimer.hpp
new file mode 100644
index 00000000..85850963
--- /dev/null
+++ b/src/core/elapsedtimer.hpp
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <qelapsedtimer.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+///! Measures time between events
+/// The ElapsedTimer measures time since its last restart, and is useful
+/// for determining the time between events that don't supply it.
+class ElapsedTimer: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+
+public:
+	explicit ElapsedTimer();
+
+	/// Return the number of seconds since the timer was last
+	/// started or restarted, with nanosecond precision.
+	Q_INVOKABLE qreal elapsed();
+
+	/// Restart the timer, returning the number of seconds since
+	/// the timer was last started or restarted, with nanosecond precision.
+	Q_INVOKABLE qreal restart();
+
+	/// Return the number of milliseconds since the timer was last
+	/// started or restarted.
+	Q_INVOKABLE qint64 elapsedMs();
+
+	/// Restart the timer, returning the number of milliseconds since
+	/// the timer was last started or restarted.
+	Q_INVOKABLE qint64 restartMs();
+
+	/// Return the number of nanoseconds since the timer was last
+	/// started or restarted.
+	Q_INVOKABLE qint64 elapsedNs();
+
+	/// Restart the timer, returning the number of nanoseconds since
+	/// the timer was last started or restarted.
+	Q_INVOKABLE qint64 restartNs();
+
+private:
+	QElapsedTimer timer;
+};
diff --git a/src/core/enginecontext.hpp b/src/core/enginecontext.hpp
new file mode 100644
index 00000000..6675fc30
--- /dev/null
+++ b/src/core/enginecontext.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "qsintercept.hpp"
+#include "scan.hpp"
+#include "singleton.hpp"
+
+class EngineContext {
+public:
+	explicit EngineContext(const QmlScanner& scanner);
+
+private:
+	const QmlScanner& scanner;
+	QQmlEngine engine;
+	QsInterceptNetworkAccessManagerFactory interceptFactory;
+	SingletonRegistry singletonRegistry;
+};
diff --git a/src/core/floatingwindow.cpp b/src/core/floatingwindow.cpp
deleted file mode 100644
index 0f909c23..00000000
--- a/src/core/floatingwindow.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-#include "floatingwindow.hpp"
-
-#include <qobject.h>
-#include <qqmllist.h>
-#include <qquickitem.h>
-#include <qtypes.h>
-
-#include "proxywindow.hpp"
-#include "windowinterface.hpp"
-
-void ProxyFloatingWindow::setWidth(qint32 width) {
-	if (this->window == nullptr || !this->window->isVisible()) {
-		this->ProxyWindowBase::setWidth(width);
-	}
-}
-
-void ProxyFloatingWindow::setHeight(qint32 height) {
-	if (this->window == nullptr || !this->window->isVisible()) {
-		this->ProxyWindowBase::setHeight(height);
-	}
-}
-
-// FloatingWindowInterface
-
-FloatingWindowInterface::FloatingWindowInterface(QObject* parent)
-    : WindowInterface(parent)
-    , window(new ProxyFloatingWindow(this)) {
-	// clang-format off
-	QObject::connect(this->window, &ProxyWindowBase::windowConnected, this, &FloatingWindowInterface::windowConnected);
-	QObject::connect(this->window, &ProxyWindowBase::visibleChanged, this, &FloatingWindowInterface::visibleChanged);
-	QObject::connect(this->window, &ProxyWindowBase::heightChanged, this, &FloatingWindowInterface::heightChanged);
-	QObject::connect(this->window, &ProxyWindowBase::widthChanged, this, &FloatingWindowInterface::widthChanged);
-	QObject::connect(this->window, &ProxyWindowBase::screenChanged, this, &FloatingWindowInterface::screenChanged);
-	QObject::connect(this->window, &ProxyWindowBase::colorChanged, this, &FloatingWindowInterface::colorChanged);
-	QObject::connect(this->window, &ProxyWindowBase::maskChanged, this, &FloatingWindowInterface::maskChanged);
-	// clang-format on
-}
-
-void FloatingWindowInterface::onReload(QObject* oldInstance) {
-	auto* old = qobject_cast<FloatingWindowInterface*>(oldInstance);
-	this->window->onReload(old != nullptr ? old->window : nullptr);
-}
-
-QQmlListProperty<QObject> FloatingWindowInterface::data() { return this->window->data(); }
-QQuickItem* FloatingWindowInterface::contentItem() const { return this->window->contentItem(); }
-
-// NOLINTBEGIN
-#define proxyPair(type, get, set)                                                                  \
-	type FloatingWindowInterface::get() const { return this->window->get(); }                        \
-	void FloatingWindowInterface::set(type value) { this->window->set(value); }
-
-proxyPair(bool, isVisible, setVisible);
-proxyPair(qint32, width, setWidth);
-proxyPair(qint32, height, setHeight);
-proxyPair(QuickshellScreenInfo*, screen, setScreen);
-proxyPair(QColor, color, setColor);
-proxyPair(PendingRegion*, mask, setMask);
-
-#undef proxyPair
-#undef proxySet
-#undef proxyGet
-// NOLINTEND
diff --git a/src/core/floatingwindow.hpp b/src/core/floatingwindow.hpp
deleted file mode 100644
index 408b1e9f..00000000
--- a/src/core/floatingwindow.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#pragma once
-
-#include <qobject.h>
-#include <qtmetamacros.h>
-
-#include "proxywindow.hpp"
-
-class ProxyFloatingWindow: public ProxyWindowBase {
-	Q_OBJECT;
-
-public:
-	explicit ProxyFloatingWindow(QObject* parent = nullptr): ProxyWindowBase(parent) {}
-
-	// Setting geometry while the window is visible makes the content item shrinks but not the window
-	// which is awful so we disable it for floating windows.
-	void setWidth(qint32 width) override;
-	void setHeight(qint32 height) override;
-};
-
-///! Standard floating window.
-class FloatingWindowInterface: public WindowInterface {
-	Q_OBJECT;
-	QML_NAMED_ELEMENT(FloatingWindow);
-
-public:
-	explicit FloatingWindowInterface(QObject* parent = nullptr);
-
-	void onReload(QObject* oldInstance) override;
-
-	[[nodiscard]] QQuickItem* contentItem() const override;
-
-	// NOLINTBEGIN
-	[[nodiscard]] bool isVisible() const override;
-	void setVisible(bool visible) override;
-
-	[[nodiscard]] qint32 width() const override;
-	void setWidth(qint32 width) override;
-
-	[[nodiscard]] qint32 height() const override;
-	void setHeight(qint32 height) override;
-
-	[[nodiscard]] QuickshellScreenInfo* screen() const override;
-	void setScreen(QuickshellScreenInfo* screen) override;
-
-	[[nodiscard]] QColor color() const override;
-	void setColor(QColor color) override;
-
-	[[nodiscard]] PendingRegion* mask() const override;
-	void setMask(PendingRegion* mask) override;
-
-	[[nodiscard]] QQmlListProperty<QObject> data() override;
-	// NOLINTEND
-
-private:
-	ProxyFloatingWindow* window;
-};
diff --git a/src/core/generation.cpp b/src/core/generation.cpp
new file mode 100644
index 00000000..fee94416
--- /dev/null
+++ b/src/core/generation.cpp
@@ -0,0 +1,413 @@
+#include "generation.hpp"
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qcoreapplication.h>
+#include <qdebug.h>
+#include <qdir.h>
+#include <qfileinfo.h>
+#include <qfilesystemwatcher.h>
+#include <qhash.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qqmlcontext.h>
+#include <qqmlengine.h>
+#include <qqmlerror.h>
+#include <qqmlincubator.h>
+#include <qtmetamacros.h>
+
+#include "iconimageprovider.hpp"
+#include "imageprovider.hpp"
+#include "incubator.hpp"
+#include "logcat.hpp"
+#include "plugin.hpp"
+#include "qsintercept.hpp"
+#include "reload.hpp"
+#include "scan.hpp"
+
+namespace {
+QS_LOGGING_CATEGORY(logScene, "scene");
+}
+
+static QHash<const QQmlEngine*, EngineGeneration*> g_generations; // NOLINT
+
+EngineGeneration::EngineGeneration(const QDir& rootPath, QmlScanner scanner)
+    : rootPath(rootPath)
+    , scanner(std::move(scanner))
+    , urlInterceptor(this->rootPath)
+    , interceptNetFactory(this->rootPath, this->scanner.fileIntercepts)
+    , engine(new QQmlEngine()) {
+	g_generations.insert(this->engine, this);
+
+	this->engine->setOutputWarningsToStandardError(false);
+	QObject::connect(this->engine, &QQmlEngine::warnings, this, &EngineGeneration::onEngineWarnings);
+
+	this->engine->addUrlInterceptor(&this->urlInterceptor);
+	this->engine->addImportPath("qs:@/");
+
+	this->engine->setNetworkAccessManagerFactory(&this->interceptNetFactory);
+	this->engine->setIncubationController(&this->delayedIncubationController);
+
+	this->engine->addImageProvider("icon", new IconImageProvider());
+	this->engine->addImageProvider("qsimage", new QsImageProvider());
+	this->engine->addImageProvider("qspixmap", new QsPixmapProvider());
+
+	QsEnginePlugin::runConstructGeneration(*this);
+}
+
+EngineGeneration::EngineGeneration(): EngineGeneration(QDir(), QmlScanner()) {}
+
+EngineGeneration::~EngineGeneration() {
+	if (this->engine != nullptr) {
+		qFatal() << this << "destroyed without calling destroy()";
+	}
+}
+
+void EngineGeneration::destroy() {
+	if (this->destroying) return;
+	this->destroying = true;
+
+	if (this->watcher != nullptr) {
+		// Multiple generations can detect a reload at the same time.
+		QObject::disconnect(this->watcher, nullptr, this, nullptr);
+		this->watcher->deleteLater();
+		this->watcher = nullptr;
+	}
+
+	for (auto* extension: this->extensions.values()) {
+		delete extension;
+	}
+
+	if (this->root != nullptr) {
+		QObject::connect(this->root, &QObject::destroyed, this, [this]() {
+			// prevent further js execution between garbage collection and engine destruction.
+			this->engine->setInterrupted(true);
+
+			g_generations.remove(this->engine);
+
+			// Garbage is not collected during engine destruction.
+			this->engine->collectGarbage();
+
+			delete this->engine;
+			this->engine = nullptr;
+
+			auto terminate = this->shouldTerminate;
+			auto code = this->exitCode;
+			delete this;
+
+			if (terminate) QCoreApplication::exit(code);
+		});
+
+		this->root->deleteLater();
+		this->root = nullptr;
+	} else {
+		g_generations.remove(this->engine);
+
+		// the engine has never been used, no need to clean up
+		delete this->engine;
+		this->engine = nullptr;
+
+		auto terminate = this->shouldTerminate;
+		auto code = this->exitCode;
+		delete this;
+
+		if (terminate) QCoreApplication::exit(code);
+	}
+}
+
+void EngineGeneration::shutdown() {
+	if (this->destroying) return;
+
+	delete this->root;
+	this->root = nullptr;
+	delete this->engine;
+	this->engine = nullptr;
+	delete this;
+}
+
+void EngineGeneration::onReload(EngineGeneration* old) {
+	if (old != nullptr) {
+		// if the old generation holds the window incubation controller as the
+		// new generation acquires it then incubators will hang intermittently
+		qCDebug(logIncubator) << "Locking incubation controllers of old generation" << old;
+		old->incubationControllersLocked = true;
+		old->assignIncubationController();
+	}
+
+	QObject::connect(this->engine, &QQmlEngine::quit, this, &EngineGeneration::quit);
+	QObject::connect(this->engine, &QQmlEngine::exit, this, &EngineGeneration::exit);
+
+	if (auto* reloadable = qobject_cast<Reloadable*>(this->root)) {
+		reloadable->reload(old ? old->root : nullptr);
+	}
+
+	this->singletonRegistry.onReload(old == nullptr ? nullptr : &old->singletonRegistry);
+	this->reloadComplete = true;
+	emit this->reloadFinished();
+
+	if (old != nullptr) {
+		QObject::connect(old, &QObject::destroyed, this, [this]() { this->postReload(); });
+		old->destroy();
+	} else {
+		this->postReload();
+	}
+}
+
+void EngineGeneration::postReload() {
+	// This can be called on a generation during its destruction.
+	if (this->engine == nullptr || this->root == nullptr) return;
+
+	QsEnginePlugin::runOnReload();
+
+	emit this->firePostReload();
+	QObject::disconnect(this, &EngineGeneration::firePostReload, nullptr, nullptr);
+}
+
+void EngineGeneration::setWatchingFiles(bool watching) {
+	if (watching) {
+		if (this->watcher == nullptr) {
+			this->watcher = new QFileSystemWatcher();
+
+			for (auto& file: this->scanner.scannedFiles) {
+				this->watcher->addPath(file);
+				this->watcher->addPath(QFileInfo(file).dir().absolutePath());
+			}
+
+			for (auto& file: this->extraWatchedFiles) {
+				this->watcher->addPath(file);
+				this->watcher->addPath(QFileInfo(file).dir().absolutePath());
+			}
+
+			QObject::connect(
+			    this->watcher,
+			    &QFileSystemWatcher::fileChanged,
+			    this,
+			    &EngineGeneration::onFileChanged
+			);
+
+			QObject::connect(
+			    this->watcher,
+			    &QFileSystemWatcher::directoryChanged,
+			    this,
+			    &EngineGeneration::onDirectoryChanged
+			);
+		}
+	} else {
+		if (this->watcher != nullptr) {
+			this->watcher->deleteLater();
+			this->watcher = nullptr;
+		}
+	}
+}
+
+bool EngineGeneration::setExtraWatchedFiles(const QVector<QString>& files) {
+	this->extraWatchedFiles.clear();
+	for (const auto& file: files) {
+		if (!this->scanner.scannedFiles.contains(file)) {
+			this->extraWatchedFiles.append(file);
+		}
+	}
+
+	if (this->watcher) {
+		this->setWatchingFiles(false);
+		this->setWatchingFiles(true);
+	}
+
+	return !this->extraWatchedFiles.isEmpty();
+}
+
+void EngineGeneration::onFileChanged(const QString& name) {
+	if (!this->watcher->files().contains(name)) {
+		this->deletedWatchedFiles.push_back(name);
+	} else {
+		// some editors (e.g vscode) perform file saving in two steps: truncate + write
+		// ignore the first event (truncate) with size 0 to prevent incorrect live reloading
+		auto fileInfo = QFileInfo(name);
+		if (fileInfo.isFile() && fileInfo.size() == 0) return;
+
+		emit this->filesChanged();
+	}
+}
+
+void EngineGeneration::onDirectoryChanged() {
+	// try to find any files that were just deleted from a replace operation
+	for (auto& file: this->deletedWatchedFiles) {
+		if (QFileInfo(file).exists()) {
+			emit this->filesChanged();
+			break;
+		}
+	}
+}
+
+void EngineGeneration::registerIncubationController(QQmlIncubationController* controller) {
+	// We only want controllers that we can swap out if destroyed.
+	// This happens if the window owning the active controller dies.
+	auto* obj = dynamic_cast<QObject*>(controller);
+	if (!obj) {
+		qCWarning(logIncubator) << "Could not register incubation controller as it is not a QObject"
+		                        << controller;
+
+		return;
+	}
+
+	QObject::connect(
+	    obj,
+	    &QObject::destroyed,
+	    this,
+	    &EngineGeneration::incubationControllerDestroyed,
+	    Qt::UniqueConnection
+	);
+
+	this->incubationControllers.push_back(obj);
+	qCDebug(logIncubator) << "Registered incubation controller" << obj << "to generation" << this;
+
+	// This function can run during destruction.
+	if (this->engine == nullptr) return;
+
+	if (this->engine->incubationController() == &this->delayedIncubationController) {
+		this->assignIncubationController();
+	}
+}
+
+// Multiple controllers may be destroyed at once. Dynamic casts must be performed before working
+// with any controllers. The QQmlIncubationController destructor will already have run by the
+// point QObject::destroyed is called, so we can't cast to that.
+void EngineGeneration::deregisterIncubationController(QQmlIncubationController* controller) {
+	auto* obj = dynamic_cast<QObject*>(controller);
+	if (!obj) {
+		qCCritical(logIncubator) << "Deregistering incubation controller which is not a QObject, "
+		                            "however only QObject controllers should be registered.";
+	}
+
+	QObject::disconnect(obj, nullptr, this, nullptr);
+
+	if (this->incubationControllers.removeOne(obj)) {
+		qCDebug(logIncubator) << "Deregistered incubation controller" << obj << "from" << this;
+	} else {
+		qCCritical(logIncubator) << "Failed to deregister incubation controller" << obj << "from"
+		                         << this << "as it was not registered to begin with";
+		qCCritical(logIncubator) << "Current registered incuabation controllers"
+		                         << this->incubationControllers;
+	}
+
+	// This function can run during destruction.
+	if (this->engine == nullptr) return;
+
+	if (this->engine->incubationController() == controller) {
+		qCDebug(logIncubator
+		) << "Destroyed incubation controller was currently active, reassigning from pool";
+		this->assignIncubationController();
+	}
+}
+
+void EngineGeneration::incubationControllerDestroyed() {
+	auto* sender = this->sender();
+
+	if (this->incubationControllers.removeAll(sender) != 0) {
+		qCDebug(logIncubator) << "Destroyed incubation controller" << sender << "deregistered from"
+		                      << this;
+	} else {
+		qCCritical(logIncubator) << "Destroyed incubation controller" << sender
+		                         << "was not registered, but its destruction was observed by" << this;
+
+		return;
+	}
+
+	// This function can run during destruction.
+	if (this->engine == nullptr) return;
+
+	if (dynamic_cast<QObject*>(this->engine->incubationController()) == sender) {
+		qCDebug(logIncubator
+		) << "Destroyed incubation controller was currently active, reassigning from pool";
+		this->assignIncubationController();
+	}
+}
+
+void EngineGeneration::onEngineWarnings(const QList<QQmlError>& warnings) {
+	for (const auto& error: warnings) {
+		const auto& url = error.url();
+		auto rel = url.scheme() == "qs" && url.path().startsWith("@/qs/") ? "@" % url.path().sliced(5)
+		                                                                  : url.toString();
+
+		QString objectName;
+		auto desc = error.description();
+		if (auto i = desc.indexOf(": "); i != -1 && desc.startsWith("QML ")) {
+			objectName = desc.first(i) + " at ";
+			desc = desc.sliced(i + 2);
+		}
+
+		qCWarning(logScene).noquote().nospace()
+		    << objectName << rel << '[' << error.line() << ':' << error.column() << "]: " << desc;
+	}
+}
+
+void EngineGeneration::registerExtension(const void* key, EngineGenerationExt* extension) {
+	if (this->extensions.contains(key)) {
+		delete this->extensions.value(key);
+	}
+
+	this->extensions.insert(key, extension);
+}
+
+EngineGenerationExt* EngineGeneration::findExtension(const void* key) {
+	return this->extensions.value(key);
+}
+
+void EngineGeneration::quit() {
+	this->shouldTerminate = true;
+	this->destroy();
+}
+
+void EngineGeneration::exit(int code) {
+	this->shouldTerminate = true;
+	this->exitCode = code;
+	this->destroy();
+}
+
+void EngineGeneration::assignIncubationController() {
+	QQmlIncubationController* controller = nullptr;
+
+	if (this->incubationControllersLocked || this->incubationControllers.isEmpty()) {
+		controller = &this->delayedIncubationController;
+	} else {
+		controller = dynamic_cast<QQmlIncubationController*>(this->incubationControllers.first());
+	}
+
+	qCDebug(logIncubator) << "Assigning incubation controller" << controller << "to generation"
+	                      << this
+	                      << "fallback:" << (controller == &this->delayedIncubationController);
+
+	this->engine->setIncubationController(controller);
+}
+
+EngineGeneration* EngineGeneration::currentGeneration() {
+	if (g_generations.size() == 1) {
+		return *g_generations.begin();
+	} else return nullptr;
+}
+
+EngineGeneration* EngineGeneration::findEngineGeneration(const QQmlEngine* engine) {
+	return g_generations.value(engine);
+}
+
+EngineGeneration* EngineGeneration::findObjectGeneration(const QObject* object) {
+	// Objects can still attempt to find their generation after it has been destroyed.
+	// if (g_generations.size() == 1) return EngineGeneration::currentGeneration();
+
+	while (object != nullptr) {
+		auto* context = QQmlEngine::contextForObject(object);
+
+		if (context != nullptr) {
+			if (auto* generation = EngineGeneration::findEngineGeneration(context->engine())) {
+				return generation;
+			}
+		}
+
+		object = object->parent();
+	}
+
+	return nullptr;
+}
diff --git a/src/core/generation.hpp b/src/core/generation.hpp
new file mode 100644
index 00000000..3c0c4ae5
--- /dev/null
+++ b/src/core/generation.hpp
@@ -0,0 +1,100 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qdir.h>
+#include <qfilesystemwatcher.h>
+#include <qhash.h>
+#include <qlist.h>
+#include <qobject.h>
+#include <qqmlengine.h>
+#include <qqmlerror.h>
+#include <qqmlincubator.h>
+#include <qtclasshelpermacros.h>
+
+#include "incubator.hpp"
+#include "qsintercept.hpp"
+#include "scan.hpp"
+#include "singleton.hpp"
+
+class RootWrapper;
+class QuickshellGlobal;
+
+class EngineGenerationExt {
+public:
+	EngineGenerationExt() = default;
+	virtual ~EngineGenerationExt() = default;
+	Q_DISABLE_COPY_MOVE(EngineGenerationExt);
+};
+
+class EngineGeneration: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit EngineGeneration();
+	explicit EngineGeneration(const QDir& rootPath, QmlScanner scanner);
+	~EngineGeneration() override;
+	Q_DISABLE_COPY_MOVE(EngineGeneration);
+
+	// assumes root has been initialized, consumes old generation
+	void onReload(EngineGeneration* old);
+	void setWatchingFiles(bool watching);
+	bool setExtraWatchedFiles(const QVector<QString>& files);
+
+	void registerIncubationController(QQmlIncubationController* controller);
+	void deregisterIncubationController(QQmlIncubationController* controller);
+
+	// takes ownership
+	void registerExtension(const void* key, EngineGenerationExt* extension);
+	EngineGenerationExt* findExtension(const void* key);
+
+	static EngineGeneration* findEngineGeneration(const QQmlEngine* engine);
+	static EngineGeneration* findObjectGeneration(const QObject* object);
+
+	// Returns the current generation if there is only one generation,
+	// otherwise null.
+	static EngineGeneration* currentGeneration();
+
+	RootWrapper* wrapper = nullptr;
+	QDir rootPath;
+	QmlScanner scanner;
+	QsUrlInterceptor urlInterceptor;
+	QsInterceptNetworkAccessManagerFactory interceptNetFactory;
+	QQmlEngine* engine = nullptr;
+	QObject* root = nullptr;
+	SingletonRegistry singletonRegistry;
+	QFileSystemWatcher* watcher = nullptr;
+	QVector<QString> deletedWatchedFiles;
+	QVector<QString> extraWatchedFiles;
+	DelayedQmlIncubationController delayedIncubationController;
+	bool reloadComplete = false;
+	QuickshellGlobal* qsgInstance = nullptr;
+
+	void destroy();
+	void shutdown();
+
+signals:
+	void filesChanged();
+	void reloadFinished();
+	void firePostReload();
+
+public slots:
+	void quit();
+	void exit(int code);
+
+private slots:
+	void onFileChanged(const QString& name);
+	void onDirectoryChanged();
+	void incubationControllerDestroyed();
+	static void onEngineWarnings(const QList<QQmlError>& warnings);
+
+private:
+	void postReload();
+	void assignIncubationController();
+	QVector<QObject*> incubationControllers;
+	bool incubationControllersLocked = false;
+	QHash<const void*, EngineGenerationExt*> extensions;
+
+	bool destroying = false;
+	bool shouldTerminate = false;
+	int exitCode = 0;
+};
diff --git a/src/core/iconimageprovider.cpp b/src/core/iconimageprovider.cpp
new file mode 100644
index 00000000..43e00fd8
--- /dev/null
+++ b/src/core/iconimageprovider.cpp
@@ -0,0 +1,84 @@
+#include "iconimageprovider.hpp"
+#include <algorithm>
+
+#include <qcolor.h>
+#include <qicon.h>
+#include <qlogging.h>
+#include <qpainter.h>
+#include <qpixmap.h>
+#include <qsize.h>
+#include <qstring.h>
+
+QPixmap
+IconImageProvider::requestPixmap(const QString& id, QSize* size, const QSize& requestedSize) {
+	QString iconName;
+	QString fallbackName;
+	QString path;
+
+	auto splitIdx = id.indexOf("?path=");
+	if (splitIdx != -1) {
+		iconName = id.sliced(0, splitIdx);
+		path = id.sliced(splitIdx + 6);
+		qWarning() << "Searching custom icon paths is not yet supported. Icon path will be ignored for"
+		           << id;
+	} else {
+		splitIdx = id.indexOf("?fallback=");
+		if (splitIdx != -1) {
+			iconName = id.sliced(0, splitIdx);
+			fallbackName = id.sliced(splitIdx + 10);
+		} else {
+			iconName = id;
+		}
+	}
+
+	auto icon = QIcon::fromTheme(iconName);
+	if (icon.isNull()) icon = QIcon::fromTheme(fallbackName);
+
+	auto targetSize = requestedSize.isValid() ? requestedSize : QSize(100, 100);
+	if (targetSize.width() == 0 || targetSize.height() == 0) targetSize = QSize(2, 2);
+	auto pixmap = icon.pixmap(targetSize.width(), targetSize.height());
+
+	if (pixmap.isNull()) {
+		qWarning() << "Could not load icon" << id << "at size" << targetSize << "from request";
+		pixmap = IconImageProvider::missingPixmap(targetSize);
+	}
+
+	if (size != nullptr) *size = pixmap.size();
+	return pixmap;
+}
+
+QPixmap IconImageProvider::missingPixmap(const QSize& size) {
+	auto width = size.width() % 2 == 0 ? size.width() : size.width() + 1;
+	auto height = size.height() % 2 == 0 ? size.height() : size.height() + 1;
+	width = std::max(width, 2);
+	height = std::max(height, 2);
+
+	auto pixmap = QPixmap(width, height);
+	pixmap.fill(QColorConstants::Black);
+	auto painter = QPainter(&pixmap);
+
+	auto halfWidth = width / 2;
+	auto halfHeight = height / 2;
+	auto purple = QColor(0xd900d8);
+	painter.fillRect(halfWidth, 0, halfWidth, halfHeight, purple);
+	painter.fillRect(0, halfHeight, halfWidth, halfHeight, purple);
+	return pixmap;
+}
+
+QString IconImageProvider::requestString(
+    const QString& icon,
+    const QString& path,
+    const QString& fallback
+) {
+	auto req = "image://icon/" + icon;
+
+	if (!path.isEmpty()) {
+		req += "?path=" + path;
+	}
+
+	if (!fallback.isEmpty()) {
+		req += "?fallback=" + fallback;
+	}
+
+	return req;
+}
diff --git a/src/core/iconimageprovider.hpp b/src/core/iconimageprovider.hpp
new file mode 100644
index 00000000..57e26049
--- /dev/null
+++ b/src/core/iconimageprovider.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <qpixmap.h>
+#include <qquickimageprovider.h>
+
+class IconImageProvider: public QQuickImageProvider {
+public:
+	explicit IconImageProvider(): QQuickImageProvider(QQuickImageProvider::Pixmap) {}
+
+	QPixmap requestPixmap(const QString& id, QSize* size, const QSize& requestedSize) override;
+
+	static QPixmap missingPixmap(const QSize& size);
+
+	static QString requestString(
+	    const QString& icon,
+	    const QString& path = QString(),
+	    const QString& fallback = QString()
+	);
+};
diff --git a/src/core/iconprovider.cpp b/src/core/iconprovider.cpp
new file mode 100644
index 00000000..99b423ed
--- /dev/null
+++ b/src/core/iconprovider.cpp
@@ -0,0 +1,105 @@
+#include "iconprovider.hpp"
+#include <utility>
+
+#include <qicon.h>
+#include <qiconengine.h>
+#include <qlogging.h>
+#include <qobject.h>
+#include <qpixmap.h>
+#include <qqmlengine.h>
+#include <qquickimageprovider.h>
+#include <qrect.h>
+#include <qsize.h>
+#include <qstring.h>
+
+#include "generation.hpp"
+
+// QMenu re-calls pixmap() every time the mouse moves so its important to cache it.
+class PixmapCacheIconEngine: public QIconEngine {
+	void paint(
+	    QPainter* /*unused*/,
+	    const QRect& /*unused*/,
+	    QIcon::Mode /*unused*/,
+	    QIcon::State /*unused*/
+	) override {
+		qFatal(
+		) << "Unexpected icon paint request bypassed pixmap method. Please report this as a bug.";
+	}
+
+	QPixmap pixmap(const QSize& size, QIcon::Mode /*unused*/, QIcon::State /*unused*/) override {
+		if (this->lastPixmap.isNull() || size != this->lastSize) {
+			this->lastPixmap = this->createPixmap(size);
+			this->lastSize = size;
+		}
+
+		return this->lastPixmap;
+	}
+
+	virtual QPixmap createPixmap(const QSize& size) = 0;
+
+private:
+	QSize lastSize;
+	QPixmap lastPixmap;
+};
+
+class ImageProviderIconEngine: public PixmapCacheIconEngine {
+public:
+	explicit ImageProviderIconEngine(QQuickImageProvider* provider, QString id)
+	    : provider(provider)
+	    , id(std::move(id)) {}
+
+	QPixmap createPixmap(const QSize& size) override {
+		if (this->provider->imageType() == QQmlImageProviderBase::Pixmap) {
+			return this->provider->requestPixmap(this->id, nullptr, size);
+		} else if (this->provider->imageType() == QQmlImageProviderBase::Image) {
+			auto image = this->provider->requestImage(this->id, nullptr, size);
+			return QPixmap::fromImage(image);
+		} else {
+			qFatal() << "Unexpected ImageProviderIconEngine image type" << this->provider->imageType();
+			return QPixmap(); // never reached, satisfies lint
+		}
+	}
+
+	[[nodiscard]] QIconEngine* clone() const override {
+		return new ImageProviderIconEngine(this->provider, this->id);
+	}
+
+private:
+	QQuickImageProvider* provider;
+	QString id;
+};
+
+QIcon getEngineImageAsIcon(QQmlEngine* engine, const QUrl& url) {
+	if (!engine || url.isEmpty()) return QIcon();
+
+	auto scheme = url.scheme();
+	if (scheme == "image") {
+		auto providerName = url.authority();
+		auto path = url.path();
+		if (!path.isEmpty()) path = path.sliced(1);
+
+		auto* provider = qobject_cast<QQuickImageProvider*>(engine->imageProvider(providerName));
+
+		if (provider == nullptr) {
+			qWarning() << "iconByUrl failed: no provider found for" << url;
+			return QIcon();
+		}
+
+		if (provider->imageType() == QQmlImageProviderBase::Pixmap
+		    || provider->imageType() == QQmlImageProviderBase::Image)
+		{
+			return QIcon(new ImageProviderIconEngine(provider, path));
+		}
+
+	} else {
+		qWarning() << "iconByUrl failed: unsupported scheme" << scheme << "in path" << url;
+	}
+
+	return QIcon();
+}
+
+QIcon getCurrentEngineImageAsIcon(const QUrl& url) {
+	auto* generation = EngineGeneration::currentGeneration();
+	if (!generation) return QIcon();
+	return getEngineImageAsIcon(generation->engine, url);
+}
diff --git a/src/core/iconprovider.hpp b/src/core/iconprovider.hpp
new file mode 100644
index 00000000..173d20e6
--- /dev/null
+++ b/src/core/iconprovider.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include <qicon.h>
+#include <qqmlengine.h>
+#include <qurl.h>
+
+QIcon getEngineImageAsIcon(QQmlEngine* engine, const QUrl& url);
+QIcon getCurrentEngineImageAsIcon(const QUrl& url);
diff --git a/src/core/imageprovider.cpp b/src/core/imageprovider.cpp
new file mode 100644
index 00000000..47f284c7
--- /dev/null
+++ b/src/core/imageprovider.cpp
@@ -0,0 +1,93 @@
+#include "imageprovider.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qimage.h>
+#include <qlogging.h>
+#include <qmap.h>
+#include <qobject.h>
+#include <qpixmap.h>
+#include <qqmlengine.h>
+#include <qtypes.h>
+
+namespace {
+
+namespace {
+QMap<QString, QsImageHandle*> liveImages; // NOLINT
+quint32 handleIndex = 0;                  // NOLINT
+} // namespace
+
+void parseReq(const QString& req, QString& target, QString& param) {
+	auto splitIdx = req.indexOf('/');
+	if (splitIdx != -1) {
+		target = req.sliced(0, splitIdx);
+		param = req.sliced(splitIdx + 1);
+	} else {
+		target = req;
+	}
+}
+
+} // namespace
+
+QsImageHandle::QsImageHandle(QQmlImageProviderBase::ImageType type)
+    : type(type)
+    , id(QString::number(++handleIndex)) {
+	liveImages.insert(this->id, this);
+}
+
+QsImageHandle::~QsImageHandle() { liveImages.remove(this->id); }
+
+QString QsImageHandle::url() const {
+	QString url = "image://";
+	if (this->type == QQmlImageProviderBase::Image) url += "qsimage";
+	else if (this->type == QQmlImageProviderBase::Pixmap) url += "qspixmap";
+	url += "/" + this->id;
+	return url;
+}
+
+QImage
+QsImageHandle::requestImage(const QString& /*unused*/, QSize* /*unused*/, const QSize& /*unused*/) {
+	qWarning() << "Image handle" << this << "does not provide QImages";
+	return QImage();
+}
+
+QPixmap QsImageHandle::
+    requestPixmap(const QString& /*unused*/, QSize* /*unused*/, const QSize& /*unused*/) {
+	qWarning() << "Image handle" << this << "does not provide QPixmaps";
+	return QPixmap();
+}
+
+QImage QsImageProvider::requestImage(const QString& id, QSize* size, const QSize& requestedSize) {
+	QString target;
+	QString param;
+	parseReq(id, target, param);
+
+	auto* handle = liveImages.value(target);
+	if (handle != nullptr) {
+		return handle->requestImage(param, size, requestedSize);
+	} else {
+		qWarning() << "Requested image from unknown handle" << id;
+		return QImage();
+	}
+}
+
+QPixmap
+QsPixmapProvider::requestPixmap(const QString& id, QSize* size, const QSize& requestedSize) {
+	QString target;
+	QString param;
+	parseReq(id, target, param);
+
+	auto* handle = liveImages.value(target);
+	if (handle != nullptr) {
+		return handle->requestPixmap(param, size, requestedSize);
+	} else {
+		qWarning() << "Requested image from unknown handle" << id;
+		return QPixmap();
+	}
+}
+
+QString QsIndexedImageHandle::url() const {
+	return this->QsImageHandle::url() % '/' % QString::number(this->changeIndex);
+}
+
+void QsIndexedImageHandle::imageChanged() { ++this->changeIndex; }
diff --git a/src/core/imageprovider.hpp b/src/core/imageprovider.hpp
new file mode 100644
index 00000000..8568d4f7
--- /dev/null
+++ b/src/core/imageprovider.hpp
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <qimage.h>
+#include <qmap.h>
+#include <qobject.h>
+#include <qqmlengine.h>
+#include <qquickimageprovider.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+
+class QsImageProvider: public QQuickImageProvider {
+public:
+	explicit QsImageProvider(): QQuickImageProvider(QQuickImageProvider::Image) {}
+	QImage requestImage(const QString& id, QSize* size, const QSize& requestedSize) override;
+};
+
+class QsPixmapProvider: public QQuickImageProvider {
+public:
+	explicit QsPixmapProvider(): QQuickImageProvider(QQuickImageProvider::Pixmap) {}
+	QPixmap requestPixmap(const QString& id, QSize* size, const QSize& requestedSize) override;
+};
+
+class QsImageHandle {
+public:
+	explicit QsImageHandle(QQmlImageProviderBase::ImageType type);
+	virtual ~QsImageHandle();
+	Q_DISABLE_COPY_MOVE(QsImageHandle);
+
+	[[nodiscard]] virtual QString url() const;
+
+	virtual QImage requestImage(const QString& id, QSize* size, const QSize& requestedSize);
+	virtual QPixmap requestPixmap(const QString& id, QSize* size, const QSize& requestedSize);
+
+private:
+	QQmlImageProviderBase::ImageType type;
+	QString id;
+};
+
+class QsIndexedImageHandle: public QsImageHandle {
+public:
+	explicit QsIndexedImageHandle(QQmlImageProviderBase::ImageType type): QsImageHandle(type) {}
+
+	[[nodiscard]] QString url() const override;
+	void imageChanged();
+
+private:
+	quint32 changeIndex = 0;
+};
diff --git a/src/core/incubator.cpp b/src/core/incubator.cpp
new file mode 100644
index 00000000..c9d149a8
--- /dev/null
+++ b/src/core/incubator.cpp
@@ -0,0 +1,17 @@
+#include "incubator.hpp"
+
+#include <qlogging.h>
+#include <qqmlincubator.h>
+#include <qtmetamacros.h>
+
+#include "logcat.hpp"
+
+QS_LOGGING_CATEGORY(logIncubator, "quickshell.incubator", QtWarningMsg);
+
+void QsQmlIncubator::statusChanged(QQmlIncubator::Status status) {
+	switch (status) {
+	case QQmlIncubator::Ready: emit this->completed(); break;
+	case QQmlIncubator::Error: emit this->failed(); break;
+	default: break;
+	}
+}
diff --git a/src/core/incubator.hpp b/src/core/incubator.hpp
new file mode 100644
index 00000000..5ebb9a0e
--- /dev/null
+++ b/src/core/incubator.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <qobject.h>
+#include <qqmlincubator.h>
+#include <qtmetamacros.h>
+
+#include "logcat.hpp"
+
+QS_DECLARE_LOGGING_CATEGORY(logIncubator);
+
+class QsQmlIncubator
+    : public QObject
+    , public QQmlIncubator {
+	Q_OBJECT;
+
+public:
+	explicit QsQmlIncubator(QsQmlIncubator::IncubationMode mode, QObject* parent = nullptr)
+	    : QObject(parent)
+	    , QQmlIncubator(mode) {}
+
+	void statusChanged(QQmlIncubator::Status status) override;
+
+signals:
+	void completed();
+	void failed();
+};
+
+class DelayedQmlIncubationController: public QQmlIncubationController {
+	// Do nothing.
+	// This ensures lazy loaders don't start blocking before onReload creates windows.
+};
diff --git a/src/core/instanceinfo.cpp b/src/core/instanceinfo.cpp
new file mode 100644
index 00000000..7f0132be
--- /dev/null
+++ b/src/core/instanceinfo.cpp
@@ -0,0 +1,35 @@
+#include "instanceinfo.hpp"
+
+#include <qdatastream.h>
+
+QDataStream& operator<<(QDataStream& stream, const InstanceInfo& info) {
+	stream << info.instanceId << info.configPath << info.shellId << info.launchTime << info.pid;
+	return stream;
+}
+
+QDataStream& operator>>(QDataStream& stream, InstanceInfo& info) {
+	stream >> info.instanceId >> info.configPath >> info.shellId >> info.launchTime >> info.pid;
+	return stream;
+}
+
+QDataStream& operator<<(QDataStream& stream, const RelaunchInfo& info) {
+	stream << info.instance << info.noColor << info.timestamp << info.sparseLogsOnly
+	       << info.defaultLogLevel << info.logRules;
+
+	return stream;
+}
+
+QDataStream& operator>>(QDataStream& stream, RelaunchInfo& info) {
+	stream >> info.instance >> info.noColor >> info.timestamp >> info.sparseLogsOnly
+	    >> info.defaultLogLevel >> info.logRules;
+
+	return stream;
+}
+
+InstanceInfo InstanceInfo::CURRENT = {}; // NOLINT
+
+namespace qs::crash {
+
+CrashInfo CrashInfo::INSTANCE = {}; // NOLINT
+
+}
diff --git a/src/core/instanceinfo.hpp b/src/core/instanceinfo.hpp
new file mode 100644
index 00000000..98ce614f
--- /dev/null
+++ b/src/core/instanceinfo.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <qdatetime.h>
+#include <qlogging.h>
+#include <qstring.h>
+#include <sys/types.h>
+
+struct InstanceInfo {
+	QString instanceId;
+	QString configPath;
+	QString shellId;
+	QDateTime launchTime;
+	pid_t pid = -1;
+
+	static InstanceInfo CURRENT; // NOLINT
+};
+
+struct RelaunchInfo {
+	InstanceInfo instance;
+	bool noColor = false;
+	bool timestamp = false;
+	bool sparseLogsOnly = false;
+	QtMsgType defaultLogLevel = QtWarningMsg;
+	QString logRules;
+};
+
+QDataStream& operator<<(QDataStream& stream, const InstanceInfo& info);
+QDataStream& operator>>(QDataStream& stream, InstanceInfo& info);
+
+QDataStream& operator<<(QDataStream& stream, const RelaunchInfo& info);
+QDataStream& operator>>(QDataStream& stream, RelaunchInfo& info);
+
+namespace qs::crash {
+
+struct CrashInfo {
+	int logFd = -1;
+
+	static CrashInfo INSTANCE; // NOLINT
+};
+
+} // namespace qs::crash
diff --git a/src/core/lazyloader.cpp b/src/core/lazyloader.cpp
new file mode 100644
index 00000000..be0eb78b
--- /dev/null
+++ b/src/core/lazyloader.cpp
@@ -0,0 +1,200 @@
+#include "lazyloader.hpp"
+#include <utility>
+
+#include <qlogging.h>
+#include <qobject.h>
+#include <qqmlcomponent.h>
+#include <qqmlcontext.h>
+#include <qqmlengine.h>
+#include <qqmlincubator.h>
+#include <qtmetamacros.h>
+
+#include "incubator.hpp"
+#include "reload.hpp"
+
+void LazyLoader::onReload(QObject* oldInstance) {
+	auto* old = qobject_cast<LazyLoader*>(oldInstance);
+
+	this->incubateIfReady(true);
+
+	if (old != nullptr && old->mItem != nullptr && this->incubator != nullptr) {
+		this->incubator->forceCompletion();
+	}
+
+	if (this->mItem != nullptr) {
+		if (auto* reloadable = qobject_cast<Reloadable*>(this->mItem)) {
+			reloadable->reload(old == nullptr ? nullptr : old->mItem);
+		} else {
+			Reloadable::reloadRecursive(this->mItem, old);
+		}
+	}
+}
+
+QObject* LazyLoader::item() {
+	if (this->isLoading()) this->setActive(true);
+	return this->mItem;
+}
+
+void LazyLoader::setItem(QObject* item) {
+	if (item == this->mItem) return;
+
+	if (this->mItem != nullptr) {
+		this->mItem->deleteLater();
+	}
+
+	this->mItem = item;
+
+	if (item != nullptr) {
+		item->setParent(this);
+	}
+
+	this->targetActive = this->isActive();
+
+	emit this->itemChanged();
+	emit this->activeChanged();
+}
+
+bool LazyLoader::isLoading() const { return this->incubator != nullptr; }
+
+void LazyLoader::setLoading(bool loading) {
+	if (loading == this->targetLoading || this->isActive()) return;
+	this->targetLoading = loading;
+
+	if (loading) {
+		this->incubateIfReady();
+	} else if (this->mItem != nullptr) {
+		this->mItem->deleteLater();
+		this->mItem = nullptr;
+	} else if (this->incubator != nullptr) {
+		delete this->incubator;
+		this->incubator = nullptr;
+	}
+}
+
+bool LazyLoader::isActive() const { return this->mItem != nullptr; }
+
+void LazyLoader::setActive(bool active) {
+	if (active == this->targetActive) return;
+	this->targetActive = active;
+
+	if (active) {
+		if (this->isLoading()) {
+			this->incubator->forceCompletion();
+		} else if (!this->isActive()) {
+			this->incubateIfReady();
+		}
+	} else if (this->isActive()) {
+		this->setItem(nullptr);
+	}
+}
+
+void LazyLoader::setActiveAsync(bool active) {
+	if (active == (this->targetActive || this->targetLoading)) return;
+	if (active) this->setLoading(true);
+	else this->setActive(false);
+}
+
+QQmlComponent* LazyLoader::component() const {
+	return this->cleanupComponent ? nullptr : this->mComponent;
+}
+
+void LazyLoader::setComponent(QQmlComponent* component) {
+	if (this->cleanupComponent) this->setSource(nullptr);
+	if (component == this->mComponent) return;
+	this->cleanupComponent = false;
+
+	if (this->mComponent != nullptr) {
+		QObject::disconnect(this->mComponent, nullptr, this, nullptr);
+	}
+
+	this->mComponent = component;
+
+	if (component != nullptr) {
+		QObject::connect(
+		    this->mComponent,
+		    &QObject::destroyed,
+		    this,
+		    &LazyLoader::onComponentDestroyed
+		);
+	}
+
+	emit this->componentChanged();
+}
+
+void LazyLoader::onComponentDestroyed() {
+	this->mComponent = nullptr;
+	// todo: figure out what happens to the incubator
+}
+
+QString LazyLoader::source() const { return this->mSource; }
+
+void LazyLoader::setSource(QString source) {
+	if (!this->cleanupComponent) this->setComponent(nullptr);
+	if (source == this->mSource) return;
+	this->cleanupComponent = true;
+
+	this->mSource = std::move(source);
+	delete this->mComponent;
+
+	if (!this->mSource.isEmpty()) {
+		auto* context = QQmlEngine::contextForObject(this);
+		this->mComponent = new QQmlComponent(
+		    context == nullptr ? nullptr : context->engine(),
+		    context == nullptr ? this->mSource : context->resolvedUrl(this->mSource)
+		);
+
+		if (this->mComponent->isError()) {
+			qWarning() << this->mComponent->errorString().toStdString().c_str();
+			delete this->mComponent;
+			this->mComponent = nullptr;
+		}
+	} else {
+		this->mComponent = nullptr;
+	}
+
+	emit this->sourceChanged();
+}
+
+void LazyLoader::incubateIfReady(bool overrideReloadCheck) {
+	if (!(this->reloadComplete || overrideReloadCheck) || !(this->targetLoading || this->targetActive)
+	    || this->mComponent == nullptr || this->incubator != nullptr)
+	{
+		return;
+	}
+
+	this->incubator = new QsQmlIncubator(
+	    this->targetActive ? QQmlIncubator::Synchronous : QQmlIncubator::Asynchronous,
+	    this
+	);
+
+	// clang-format off
+	QObject::connect(this->incubator, &QsQmlIncubator::completed, this, &LazyLoader::onIncubationCompleted);
+	QObject::connect(this->incubator, &QsQmlIncubator::failed, this, &LazyLoader::onIncubationFailed);
+	// clang-format on
+
+	emit this->loadingChanged();
+
+	this->mComponent->create(*this->incubator, QQmlEngine::contextForObject(this->mComponent));
+}
+
+void LazyLoader::onIncubationCompleted() {
+	this->setItem(this->incubator->object());
+	// The incubator is not necessarily inert at the time of this callback,
+	// so deleteLater is required.
+	this->incubator->deleteLater();
+	this->incubator = nullptr;
+	this->targetLoading = false;
+	emit this->loadingChanged();
+}
+
+void LazyLoader::onIncubationFailed() {
+	qWarning() << "Failed to create LazyLoader component";
+
+	for (auto& error: this->incubator->errors()) {
+		qWarning() << error;
+	}
+
+	delete this->incubator;
+	this->targetLoading = false;
+	emit this->loadingChanged();
+}
diff --git a/src/core/lazyloader.hpp b/src/core/lazyloader.hpp
new file mode 100644
index 00000000..dbaad4b5
--- /dev/null
+++ b/src/core/lazyloader.hpp
@@ -0,0 +1,173 @@
+#pragma once
+
+#include <QtQml/qqmlcomponent.h>
+#include <qobject.h>
+#include <qqmlincubator.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+
+#include "incubator.hpp"
+#include "reload.hpp"
+
+///! Asynchronous component loader.
+/// The LazyLoader can be used to prepare components that don't need to be
+/// created immediately, such as windows that aren't visible until triggered
+/// by another action. It works on creating the component in the gaps between
+/// frame rendering to prevent blocking the interface thread.
+/// It can also be used to preserve memory by loading components only
+/// when you need them and unloading them afterward.
+///
+/// Note that when reloading the UI due to changes, lazy loaders will always
+/// load synchronously so windows can be reused.
+///
+/// #### Example
+/// The following example creates a PopupWindow asynchronously as the bar loads.
+/// This means the bar can be shown onscreen before the popup is ready, however
+/// trying to show the popup before it has finished loading in the background
+/// will cause the UI thread to block.
+///
+/// ```qml
+/// import QtQuick
+/// import QtQuick.Controls
+/// import Quickshell
+///
+/// ShellRoot {
+///   PanelWindow {
+///     id: window
+///     height: 50
+///
+///     anchors {
+///       bottom: true
+///       left: true
+///       right: true
+///     }
+///
+///     LazyLoader {
+///       id: popupLoader
+///
+///       // start loading immediately
+///       loading: true
+///
+///       // this window will be loaded in the background during spare
+///       // frame time unless active is set to true, where it will be
+///       // loaded in the foreground
+///       PopupWindow {
+///         // position the popup above the button
+///         parentWindow: window
+///         relativeX: window.width / 2 - width / 2
+///         relativeY: -height
+///
+///         // some heavy component here
+///
+///         width: 200
+///         height: 200
+///       }
+///     }
+///
+///     Button {
+///       anchors.centerIn: parent
+///       text: "show popup"
+///
+///       // accessing popupLoader.item will force the loader to
+///       // finish loading on the UI thread if it isn't finished yet.
+///       onClicked: popupLoader.item.visible = !popupLoader.item.visible
+///     }
+///   }
+/// }
+/// ```
+///
+/// > [!WARNING] Components that internally load other components must explicitly
+/// > support asynchronous loading to avoid blocking.
+/// >
+/// > Notably, @@Variants does not corrently support asynchronous
+/// > loading, meaning using it inside a LazyLoader will block similarly to not
+/// > having a loader to start with.
+///
+/// > [!WARNING] LazyLoaders do not start loading before the first window is created,
+/// > meaning if you create all windows inside of lazy loaders, none of them will ever load.
+class LazyLoader: public Reloadable {
+	Q_OBJECT;
+	/// The fully loaded item if the loader is @@loading or @@active, or `null`
+	/// if neither @@loading nor @@active.
+	///
+	/// Note that the item is owned by the LazyLoader, and destroying the LazyLoader
+	/// will destroy the item.
+	///
+	/// > [!WARNING] If you access the `item` of a loader that is currently loading,
+	/// > it will block as if you had set `active` to true immediately beforehand.
+	/// >
+	/// > You can instead set @@loading and listen to @@activeChanged(s) signal to
+	/// > ensure loading happens asynchronously.
+	Q_PROPERTY(QObject* item READ item NOTIFY itemChanged);
+	/// If the loader is actively loading.
+	///
+	/// If the component is not loaded, setting this property to true will start
+	/// loading it asynchronously. If the component is already loaded, setting
+	/// this property has no effect.
+	///
+	/// See also: @@activeAsync.
+	Q_PROPERTY(bool loading READ isLoading WRITE setLoading NOTIFY loadingChanged);
+	/// If the component is fully loaded.
+	///
+	/// Setting this property to `true` will force the component to load to completion,
+	/// blocking the UI, and setting it to `false` will destroy the component, requiring
+	/// it to be loaded again.
+	///
+	/// See also: @@activeAsync.
+	Q_PROPERTY(bool active READ isActive WRITE setActive NOTIFY activeChanged);
+	/// If the component is fully loaded.
+	///
+	/// Setting this property to true will asynchronously load the component similarly to
+	/// @@loading. Reading it or setting it to false will behanve
+	/// the same as @@active.
+	Q_PROPERTY(bool activeAsync READ isActive WRITE setActiveAsync NOTIFY activeChanged);
+	/// The component to load. Mutually exclusive to @@source.
+	Q_PROPERTY(QQmlComponent* component READ component WRITE setComponent NOTIFY componentChanged);
+	/// The URI to load the component from. Mutually exclusive to @@component.
+	Q_PROPERTY(QString source READ source WRITE setSource NOTIFY sourceChanged);
+	Q_CLASSINFO("DefaultProperty", "component");
+	QML_ELEMENT;
+
+public:
+	void onReload(QObject* oldInstance) override;
+
+	[[nodiscard]] bool isActive() const;
+	void setActive(bool active);
+	void setActiveAsync(bool active);
+
+	[[nodiscard]] bool isLoading() const;
+	void setLoading(bool loading);
+
+	[[nodiscard]] QObject* item();
+	void setItem(QObject* item);
+
+	[[nodiscard]] QQmlComponent* component() const;
+	void setComponent(QQmlComponent* component);
+
+	[[nodiscard]] QString source() const;
+	void setSource(QString source);
+
+signals:
+	void activeChanged();
+	void loadingChanged();
+	void itemChanged();
+	void sourceChanged();
+	void componentChanged();
+
+private slots:
+	void onIncubationCompleted();
+	void onIncubationFailed();
+	void onComponentDestroyed();
+
+private:
+	void incubateIfReady(bool overrideReloadCheck = false);
+	void waitForObjectCreation();
+
+	bool targetLoading = false;
+	bool targetActive = false;
+	QObject* mItem = nullptr;
+	QString mSource;
+	QQmlComponent* mComponent = nullptr;
+	QsQmlIncubator* incubator = nullptr;
+	bool cleanupComponent = false;
+};
diff --git a/src/core/logcat.hpp b/src/core/logcat.hpp
new file mode 100644
index 00000000..9650ddbf
--- /dev/null
+++ b/src/core/logcat.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <qlogging.h>
+#include <qloggingcategory.h>
+
+namespace qs::log {
+void initLogCategoryLevel(const char* name, QtMsgType defaultLevel = QtDebugMsg);
+}
+
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define QS_DECLARE_LOGGING_CATEGORY(name)                                                          \
+	namespace qslogcat {                                                                             \
+	Q_DECLARE_LOGGING_CATEGORY(name);                                                                \
+	}                                                                                                \
+	const QLoggingCategory& name()
+
+// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
+#define QS_LOGGING_CATEGORY(name, category, ...)                                                   \
+	namespace qslogcat {                                                                             \
+	Q_LOGGING_CATEGORY(name, category __VA_OPT__(, __VA_ARGS__));                                    \
+	}                                                                                                \
+	const QLoggingCategory& name() {                                                                 \
+		static auto* init = []() {                                                                     \
+			qs::log::initLogCategoryLevel(category __VA_OPT__(, __VA_ARGS__));                           \
+			return &qslogcat::name;                                                                      \
+		}();                                                                                           \
+		return (init) ();                                                                              \
+	}
diff --git a/src/core/logging.cpp b/src/core/logging.cpp
new file mode 100644
index 00000000..cb3a2142
--- /dev/null
+++ b/src/core/logging.cpp
@@ -0,0 +1,957 @@
+#include "logging.hpp"
+#include <array>
+#include <cerrno>
+#include <cstdio>
+
+#include <fcntl.h>
+#include <qbytearrayview.h>
+#include <qcoreapplication.h>
+#include <qdatetime.h>
+#include <qendian.h>
+#include <qfilesystemwatcher.h>
+#include <qhash.h>
+#include <qhashfunctions.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qobjectdefs.h>
+#include <qpair.h>
+#include <qstring.h>
+#include <qstringview.h>
+#include <qsysinfo.h>
+#include <qtenvironmentvariables.h>
+#include <qtextstream.h>
+#include <qthread.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <sys/mman.h>
+#include <sys/sendfile.h>
+
+#include "instanceinfo.hpp"
+#include "logcat.hpp"
+#include "logging_p.hpp"
+#include "logging_qtprivate.cpp" // NOLINT
+#include "paths.hpp"
+#include "ringbuf.hpp"
+
+QS_LOGGING_CATEGORY(logBare, "quickshell.bare");
+
+namespace qs::log {
+using namespace qt_logging_registry;
+
+QS_LOGGING_CATEGORY(logLogging, "quickshell.logging", QtWarningMsg);
+
+bool LogMessage::operator==(const LogMessage& other) const {
+	// note: not including time
+	return this->type == other.type && this->category == other.category && this->body == other.body;
+}
+
+size_t qHash(const LogMessage& message) {
+	return qHash(message.type) ^ qHash(message.category) ^ qHash(message.body);
+}
+
+void LogMessage::formatMessage(
+    QTextStream& stream,
+    const LogMessage& msg,
+    bool color,
+    bool timestamp,
+    const QString& prefix
+) {
+	if (!prefix.isEmpty()) {
+		if (color) stream << "\033[90m";
+		stream << '[' << prefix << ']';
+		if (timestamp) stream << ' ';
+		if (color) stream << "\033[0m";
+	}
+
+	if (timestamp) {
+		if (color) stream << "\033[90m";
+		stream << msg.time.toString("yyyy-MM-dd hh:mm:ss.zzz");
+	}
+
+	if (msg.category == "quickshell.bare") {
+		if (!prefix.isEmpty()) stream << ' ';
+		stream << msg.body;
+	} else {
+		if (color) {
+			switch (msg.type) {
+			case QtDebugMsg: stream << "\033[34m DEBUG"; break;
+			case QtInfoMsg: stream << "\033[32m  INFO"; break;
+			case QtWarningMsg: stream << "\033[33m  WARN"; break;
+			case QtCriticalMsg: stream << "\033[31m ERROR"; break;
+			case QtFatalMsg: stream << "\033[31m FATAL"; break;
+			}
+		} else {
+			switch (msg.type) {
+			case QtDebugMsg: stream << " DEBUG"; break;
+			case QtInfoMsg: stream << "  INFO"; break;
+			case QtWarningMsg: stream << "  WARN"; break;
+			case QtCriticalMsg: stream << " ERROR"; break;
+			case QtFatalMsg: stream << " FATAL"; break;
+			}
+		}
+
+		const auto isDefault = msg.category == "default";
+
+		if (color && !isDefault && msg.type != QtFatalMsg) stream << "\033[97m";
+
+		if (!isDefault) {
+			stream << ' ' << msg.category;
+		}
+
+		if (color && msg.type != QtFatalMsg) stream << "\033[0m";
+
+		stream << ": " << msg.body;
+
+		if (color && msg.type == QtFatalMsg) stream << "\033[0m";
+	}
+}
+
+bool CategoryFilter::shouldDisplay(QtMsgType type) const {
+	switch (type) {
+	case QtDebugMsg: return this->debug;
+	case QtInfoMsg: return this->info;
+	case QtWarningMsg: return this->warn;
+	case QtCriticalMsg: return this->critical;
+	default: return true;
+	}
+}
+
+void CategoryFilter::apply(QLoggingCategory* category) const {
+	category->setEnabled(QtDebugMsg, this->debug);
+	category->setEnabled(QtInfoMsg, this->info);
+	category->setEnabled(QtWarningMsg, this->warn);
+	category->setEnabled(QtCriticalMsg, this->critical);
+}
+
+void CategoryFilter::applyRule(
+    QLatin1StringView category,
+    const qt_logging_registry::QLoggingRule& rule
+) {
+	auto filterpass = rule.pass(category, QtDebugMsg);
+	if (filterpass != 0) this->debug = filterpass > 0;
+
+	filterpass = rule.pass(category, QtInfoMsg);
+	if (filterpass != 0) this->info = filterpass > 0;
+
+	filterpass = rule.pass(category, QtWarningMsg);
+	if (filterpass != 0) this->warn = filterpass > 0;
+
+	filterpass = rule.pass(category, QtCriticalMsg);
+	if (filterpass != 0) this->critical = filterpass > 0;
+}
+
+LogManager::LogManager(): stdoutStream(stdout) {}
+
+void LogManager::messageHandler(
+    QtMsgType type,
+    const QMessageLogContext& context,
+    const QString& msg
+) {
+	auto message = LogMessage(type, QLatin1StringView(context.category), msg.toUtf8());
+
+	auto* self = LogManager::instance();
+
+	auto display = true;
+
+	const auto* key = static_cast<const void*>(context.category);
+
+	if (self->sparseFilters.contains(key)) {
+		display = self->sparseFilters.value(key).shouldDisplay(type);
+	}
+
+	if (display) {
+		LogMessage::formatMessage(
+		    self->stdoutStream,
+		    message,
+		    self->colorLogs,
+		    self->timestampLogs,
+		    self->prefix
+		);
+
+		self->stdoutStream << Qt::endl;
+	}
+
+	emit self->logMessage(message, display);
+}
+
+void LogManager::filterCategory(QLoggingCategory* category) {
+	auto* instance = LogManager::instance();
+
+	auto categoryName = QLatin1StringView(category->categoryName());
+	auto isQs = categoryName.startsWith(QLatin1StringView("quickshell."));
+
+	CategoryFilter filter;
+
+	// We don't respect log filters for qs logs because some distros like to ship
+	// default configs that hide everything. QT_LOGGING_RULES is considered via the filter list.
+	if (isQs) {
+		// QtDebugMsg == 0, so default
+		auto defaultLevel = instance->defaultLevels.value(categoryName);
+
+		filter = CategoryFilter();
+		// clang-format off
+		filter.debug = instance->mDefaultLevel == QtDebugMsg || defaultLevel == QtDebugMsg;
+		filter.info = filter.debug || instance->mDefaultLevel == QtInfoMsg || defaultLevel == QtInfoMsg;
+		filter.warn = filter.info || instance->mDefaultLevel == QtWarningMsg || defaultLevel == QtWarningMsg;
+		filter.critical = filter.warn || instance->mDefaultLevel == QtCriticalMsg || defaultLevel == QtCriticalMsg;
+		// clang-format on
+	} else if (instance->lastCategoryFilter) {
+		instance->lastCategoryFilter(category);
+		filter = CategoryFilter(category);
+	}
+
+	for (const auto& rule: *instance->rules) {
+		filter.applyRule(categoryName, rule);
+	}
+
+	if (isQs && !instance->sparse) {
+		// We assume the category name pointer will always be the same and be comparable in the message handler.
+		instance->sparseFilters.insert(static_cast<const void*>(category->categoryName()), filter);
+
+		// all enabled by default
+		CategoryFilter().apply(category);
+	} else {
+		filter.apply(category);
+	}
+
+	instance->allFilters.insert(categoryName, filter);
+}
+
+LogManager* LogManager::instance() {
+	static auto* instance = new LogManager(); // NOLINT
+	return instance;
+}
+
+void LogManager::init(
+    bool color,
+    bool timestamp,
+    bool sparseOnly,
+    QtMsgType defaultLevel,
+    const QString& rules,
+    const QString& prefix
+) {
+	auto* instance = LogManager::instance();
+	instance->colorLogs = color;
+	instance->timestampLogs = timestamp;
+	instance->sparse = sparseOnly;
+	instance->prefix = prefix;
+	instance->mDefaultLevel = defaultLevel;
+	instance->mRulesString = rules;
+
+	{
+		QLoggingSettingsParser parser;
+		// Load QT_LOGGING_RULES because we ignore the last category filter for QS messages
+		// due to disk config files.
+		parser.setContent(qEnvironmentVariable("QT_LOGGING_RULES"));
+		instance->rules = new QList(parser.rules());
+		parser.setContent(rules);
+		instance->rules->append(parser.rules());
+	}
+
+	qInstallMessageHandler(&LogManager::messageHandler);
+
+	instance->lastCategoryFilter = QLoggingCategory::installFilter(&LogManager::filterCategory);
+
+	qCDebug(logLogging) << "Creating offthread logger...";
+	auto* thread = new QThread();
+	instance->threadProxy.moveToThread(thread);
+	thread->start();
+
+	QMetaObject::invokeMethod(
+	    &instance->threadProxy,
+	    &LoggingThreadProxy::initInThread,
+	    Qt::BlockingQueuedConnection
+	);
+
+	qCDebug(logLogging) << "Logger initialized.";
+}
+
+void initLogCategoryLevel(const char* name, QtMsgType defaultLevel) {
+	LogManager::instance()->defaultLevels.insert(QLatin1StringView(name), defaultLevel);
+}
+
+void LogManager::initFs() {
+	QMetaObject::invokeMethod(
+	    &LogManager::instance()->threadProxy,
+	    "initFs",
+	    Qt::BlockingQueuedConnection
+	);
+}
+
+QString LogManager::rulesString() const { return this->mRulesString; }
+QtMsgType LogManager::defaultLevel() const { return this->mDefaultLevel; }
+bool LogManager::isSparse() const { return this->sparse; }
+
+CategoryFilter LogManager::getFilter(QLatin1StringView category) {
+	return this->allFilters.value(category);
+}
+
+void LoggingThreadProxy::initInThread() {
+	this->logging = new ThreadLogging(this);
+	this->logging->init();
+}
+
+void LoggingThreadProxy::initFs() { this->logging->initFs(); }
+
+void ThreadLogging::init() {
+	auto logMfd = memfd_create("quickshell:logs", 0);
+
+	if (logMfd == -1) {
+		qCCritical(logLogging) << "Failed to create memfd for initial log storage"
+		                       << qt_error_string(-1);
+	}
+
+	auto dlogMfd = memfd_create("quickshell:detailedlogs", 0);
+
+	if (dlogMfd == -1) {
+		qCCritical(logLogging) << "Failed to create memfd for initial detailed log storage"
+		                       << qt_error_string(-1);
+	}
+
+	if (logMfd != -1) {
+		this->file = new QFile();
+		this->file->open(logMfd, QFile::ReadWrite, QFile::AutoCloseHandle);
+		this->fileStream.setDevice(this->file);
+	}
+
+	if (dlogMfd != -1) {
+		crash::CrashInfo::INSTANCE.logFd = dlogMfd;
+
+		this->detailedFile = new QFile();
+		// buffered by WriteBuffer
+		this->detailedFile->open(dlogMfd, QFile::ReadWrite | QFile::Unbuffered, QFile::AutoCloseHandle);
+		this->detailedWriter.setDevice(this->detailedFile);
+
+		if (!this->detailedWriter.writeHeader()) {
+			qCCritical(logLogging) << "Could not write header for detailed logs.";
+			this->detailedWriter.setDevice(nullptr);
+			delete this->detailedFile;
+			this->detailedFile = nullptr;
+		}
+	}
+
+	// This connection is direct so it works while the event loop is destroyed between
+	// QCoreApplication delete and Q(Gui)Application launch.
+	QObject::connect(
+	    LogManager::instance(),
+	    &LogManager::logMessage,
+	    this,
+	    &ThreadLogging::onMessage,
+	    Qt::DirectConnection
+	);
+
+	qCDebug(logLogging) << "Created memfd" << logMfd << "for early logs.";
+	qCDebug(logLogging) << "Created memfd" << dlogMfd << "for early detailed logs.";
+}
+
+void ThreadLogging::initFs() {
+	qCDebug(logLogging) << "Starting filesystem logging...";
+	auto* runDir = QsPaths::instance()->instanceRunDir();
+
+	if (!runDir) {
+		qCCritical(logLogging
+		) << "Could not start filesystem logging as the runtime directory could not be created.";
+		return;
+	}
+
+	auto path = runDir->filePath("log.log");
+	auto detailedPath = runDir->filePath("log.qslog");
+	auto* file = new QFile(path);
+	auto* detailedFile = new QFile(detailedPath);
+
+	if (!file->open(QFile::ReadWrite | QFile::Truncate)) {
+		qCCritical(logLogging
+		) << "Could not start filesystem logger as the log file could not be created:"
+		  << path;
+		delete file;
+		file = nullptr;
+	} else {
+		qInfo() << "Saving logs to" << detailedPath;
+	}
+
+	// buffered by WriteBuffer
+	if (!detailedFile->open(QFile::ReadWrite | QFile::Truncate | QFile::Unbuffered)) {
+		qCCritical(logLogging
+		) << "Could not start detailed filesystem logger as the log file could not be created:"
+		  << detailedPath;
+		delete detailedFile;
+		detailedFile = nullptr;
+	} else {
+		auto lock = flock {
+		    .l_type = F_WRLCK,
+		    .l_whence = SEEK_SET,
+		    .l_start = 0,
+		    .l_len = 0,
+		    .l_pid = 0,
+		};
+
+		if (fcntl(detailedFile->handle(), F_SETLK, &lock) != 0) { // NOLINT
+			qCWarning(logLogging) << "Unable to set lock marker on detailed log file. --follow from "
+			                         "other instances will not work.";
+		}
+
+		qCInfo(logLogging) << "Saving detailed logs to" << path;
+	}
+
+	qCDebug(logLogging) << "Copying memfd logs to log file...";
+
+	if (file) {
+		auto* oldFile = this->file;
+		if (oldFile) {
+			oldFile->seek(0);
+			sendfile(file->handle(), oldFile->handle(), nullptr, oldFile->size());
+		}
+
+		this->file = file;
+		this->fileStream.setDevice(file);
+		delete oldFile;
+	}
+
+	if (detailedFile) {
+		auto* oldFile = this->detailedFile;
+		if (oldFile) {
+			oldFile->seek(0);
+			sendfile(detailedFile->handle(), oldFile->handle(), nullptr, oldFile->size());
+		}
+
+		crash::CrashInfo::INSTANCE.logFd = detailedFile->handle();
+
+		this->detailedFile = detailedFile;
+		this->detailedWriter.setDevice(detailedFile);
+
+		if (!oldFile) {
+			if (!this->detailedWriter.writeHeader()) {
+				qCCritical(logLogging) << "Could not write header for detailed logs.";
+				this->detailedWriter.setDevice(nullptr);
+				delete this->detailedFile;
+				this->detailedFile = nullptr;
+			}
+		}
+
+		delete oldFile;
+	}
+
+	qCDebug(logLogging) << "Switched logging to disk logs.";
+
+	auto* logManager = LogManager::instance();
+	QObject::disconnect(logManager, &LogManager::logMessage, this, &ThreadLogging::onMessage);
+
+	QObject::connect(
+	    logManager,
+	    &LogManager::logMessage,
+	    this,
+	    &ThreadLogging::onMessage,
+	    Qt::QueuedConnection
+	);
+
+	qCDebug(logLogging) << "Switched threaded logger to queued eventloop connection.";
+}
+
+void ThreadLogging::onMessage(const LogMessage& msg, bool showInSparse) {
+	if (showInSparse) {
+		if (this->fileStream.device() == nullptr) return;
+		LogMessage::formatMessage(this->fileStream, msg, false, true);
+		this->fileStream << Qt::endl;
+	}
+
+	if (!this->detailedWriter.write(msg) || (this->detailedFile && !this->detailedFile->flush())) {
+		if (this->detailedFile) {
+			qCCritical(logLogging) << "Detailed logger failed to write. Ending detailed logs.";
+		}
+
+		this->detailedWriter.setDevice(nullptr);
+		this->detailedFile->close();
+		this->detailedFile = nullptr;
+	}
+}
+
+CompressedLogType compressedTypeOf(QtMsgType type) {
+	switch (type) {
+	case QtDebugMsg: return CompressedLogType::Debug;
+	case QtInfoMsg: return CompressedLogType::Info;
+	case QtWarningMsg: return CompressedLogType::Warn;
+	case QtCriticalMsg:
+	case QtFatalMsg: return CompressedLogType::Critical;
+	}
+
+	return CompressedLogType::Info; // unreachable under normal conditions
+}
+
+QtMsgType typeOfCompressed(CompressedLogType type) {
+	switch (type) {
+	case CompressedLogType::Debug: return QtDebugMsg;
+	case CompressedLogType::Info: return QtInfoMsg;
+	case CompressedLogType::Warn: return QtWarningMsg;
+	case CompressedLogType::Critical: return QtCriticalMsg;
+	}
+
+	return QtInfoMsg; // unreachable under normal conditions
+}
+
+void WriteBuffer::setDevice(QIODevice* device) { this->device = device; }
+bool WriteBuffer::hasDevice() const { return this->device; }
+
+bool WriteBuffer::flush() {
+	auto written = this->device->write(this->buffer);
+	auto success = written == this->buffer.length();
+	this->buffer.clear();
+	return success;
+}
+
+void WriteBuffer::writeBytes(const char* data, qsizetype length) {
+	this->buffer.append(data, length);
+}
+
+void WriteBuffer::writeU8(quint8 data) { this->writeBytes(reinterpret_cast<char*>(&data), 1); }
+
+void WriteBuffer::writeU16(quint16 data) {
+	data = qToLittleEndian(data);
+	this->writeBytes(reinterpret_cast<char*>(&data), 2);
+}
+
+void WriteBuffer::writeU32(quint32 data) {
+	data = qToLittleEndian(data);
+	this->writeBytes(reinterpret_cast<char*>(&data), 4);
+}
+
+void WriteBuffer::writeU64(quint64 data) {
+	data = qToLittleEndian(data);
+	this->writeBytes(reinterpret_cast<char*>(&data), 8);
+}
+
+void DeviceReader::setDevice(QIODevice* device) { this->device = device; }
+bool DeviceReader::hasDevice() const { return this->device; }
+
+bool DeviceReader::readBytes(char* data, qsizetype length) {
+	return this->device->read(data, length) == length;
+}
+
+qsizetype DeviceReader::peekBytes(char* data, qsizetype length) {
+	return this->device->peek(data, length);
+}
+
+bool DeviceReader::skip(qsizetype length) { return this->device->skip(length) == length; }
+
+bool DeviceReader::readU8(quint8* data) {
+	return this->readBytes(reinterpret_cast<char*>(data), 1);
+}
+
+bool DeviceReader::readU16(quint16* data) {
+	return this->readBytes(reinterpret_cast<char*>(data), 2);
+}
+
+bool DeviceReader::readU32(quint32* data) {
+	return this->readBytes(reinterpret_cast<char*>(data), 4);
+}
+
+bool DeviceReader::readU64(quint64* data) {
+	return this->readBytes(reinterpret_cast<char*>(data), 8);
+}
+
+void EncodedLogWriter::setDevice(QIODevice* target) { this->buffer.setDevice(target); }
+void EncodedLogReader::setDevice(QIODevice* source) { this->reader.setDevice(source); }
+
+constexpr quint8 LOG_VERSION = 2;
+
+bool EncodedLogWriter::writeHeader() {
+	this->buffer.writeU8(LOG_VERSION);
+	return this->buffer.flush();
+}
+
+bool EncodedLogReader::readHeader(bool* success, quint8* version, quint8* readerVersion) {
+	if (!this->reader.readU8(version)) return false;
+	*success = *version == LOG_VERSION;
+	*readerVersion = LOG_VERSION;
+	return true;
+}
+
+bool EncodedLogWriter::write(const LogMessage& message) {
+	if (!this->buffer.hasDevice()) return false;
+
+	LogMessage* prevMessage = nullptr;
+	auto index = this->recentMessages.indexOf(message, &prevMessage);
+
+	// If its a dupe, save memory by reusing the buffer of the first message and letting
+	// the new one be deallocated.
+	auto body = prevMessage ? prevMessage->body : message.body;
+	this->recentMessages.emplace(message.type, message.category, body, message.time);
+
+	if (index != -1) {
+		auto secondDelta = this->lastMessageTime.secsTo(message.time);
+
+		if (secondDelta < 16 && index < 16) {
+			this->writeOp(EncodedLogOpcode::RecentMessageShort);
+			this->buffer.writeU8(index | (secondDelta << 4));
+		} else {
+			this->writeOp(EncodedLogOpcode::RecentMessageLong);
+			this->buffer.writeU8(index);
+			this->writeVarInt(secondDelta);
+		}
+
+		goto finish;
+	} else {
+		auto categoryId = this->getOrCreateCategory(message.category);
+		this->writeVarInt(categoryId);
+
+		auto writeFullTimestamp = [this, &message]() {
+			this->buffer.writeU64(message.time.toSecsSinceEpoch());
+		};
+
+		if (message.type == QtFatalMsg) {
+			this->buffer.writeU8(0xff);
+			writeFullTimestamp();
+		} else {
+			quint8 field = compressedTypeOf(message.type);
+
+			auto secondDelta = this->lastMessageTime.secsTo(message.time);
+			if (secondDelta >= 0x1d) {
+				// 0x1d = followed by delta int
+				// 0x1e = followed by epoch delta int
+				field |= (secondDelta < 0xffff ? 0x1d : 0x1e) << 3;
+			} else {
+				field |= secondDelta << 3;
+			}
+
+			this->buffer.writeU8(field);
+
+			if (secondDelta >= 0x1d) {
+				if (secondDelta > 0xffff) {
+					writeFullTimestamp();
+				} else {
+					this->writeVarInt(secondDelta);
+				}
+			}
+		}
+
+		this->writeString(message.body);
+	}
+
+finish:
+	// copy with second precision
+	this->lastMessageTime = QDateTime::fromSecsSinceEpoch(message.time.toSecsSinceEpoch());
+	return this->buffer.flush();
+}
+
+bool EncodedLogReader::read(LogMessage* slot) {
+start:
+	quint32 next = 0;
+	if (!this->readVarInt(&next)) return false;
+
+	if (next < EncodedLogOpcode::BeginCategories) {
+		if (next == EncodedLogOpcode::RegisterCategory) {
+			if (!this->registerCategory()) return false;
+			goto start;
+		} else if (next == EncodedLogOpcode::RecentMessageShort
+		           || next == EncodedLogOpcode::RecentMessageLong)
+		{
+			quint8 index = 0;
+			quint32 secondDelta = 0;
+
+			if (next == EncodedLogOpcode::RecentMessageShort) {
+				quint8 field = 0;
+				if (!this->reader.readU8(&field)) return false;
+				index = field & 0xf;
+				secondDelta = field >> 4;
+			} else {
+				if (!this->reader.readU8(&index)) return false;
+				if (!this->readVarInt(&secondDelta)) return false;
+			}
+
+			if (index >= this->recentMessages.size()) return false;
+			*slot = this->recentMessages.at(index);
+			this->lastMessageTime = this->lastMessageTime.addSecs(static_cast<qint64>(secondDelta));
+			slot->time = this->lastMessageTime;
+		}
+	} else {
+		auto categoryId = next - EncodedLogOpcode::BeginCategories;
+		auto category = this->categories.value(categoryId);
+
+		quint8 field = 0;
+		if (!this->reader.readU8(&field)) return false;
+
+		auto msgType = QtDebugMsg;
+		quint64 secondDelta = 0;
+		auto needsTimeRead = false;
+
+		if (field == 0xff) {
+			msgType = QtFatalMsg;
+			needsTimeRead = true;
+		} else {
+			msgType = typeOfCompressed(static_cast<CompressedLogType>(field & 0x07));
+			secondDelta = field >> 3;
+
+			if (secondDelta == 0x1d) {
+				quint32 slot = 0;
+				if (!this->readVarInt(&slot)) return false;
+				secondDelta = slot;
+			} else if (secondDelta == 0x1e) {
+				needsTimeRead = true;
+			}
+		}
+
+		if (needsTimeRead) {
+			if (!this->reader.readU64(&secondDelta)) return false;
+		}
+
+		this->lastMessageTime = this->lastMessageTime.addSecs(static_cast<qint64>(secondDelta));
+
+		QByteArray body;
+		if (!this->readString(&body)) return false;
+
+		*slot = LogMessage(msgType, QLatin1StringView(category.first), body, this->lastMessageTime);
+		slot->readCategoryId = categoryId;
+	}
+
+	this->recentMessages.emplace(*slot);
+	return true;
+}
+
+CategoryFilter EncodedLogReader::categoryFilterById(quint16 id) {
+	return this->categories.value(id).second;
+}
+
+void EncodedLogWriter::writeOp(EncodedLogOpcode opcode) { this->buffer.writeU8(opcode); }
+
+void EncodedLogWriter::writeVarInt(quint32 n) {
+	if (n < 0xff) {
+		this->buffer.writeU8(n);
+	} else if (n < 0xffff) {
+		this->buffer.writeU8(0xff);
+		this->buffer.writeU16(n);
+	} else {
+		this->buffer.writeU8(0xff);
+		this->buffer.writeU16(0xffff);
+		this->buffer.writeU32(n);
+	}
+}
+
+bool EncodedLogReader::readVarInt(quint32* slot) {
+	auto bytes = std::array<quint8, 7>();
+	auto readLength = this->reader.peekBytes(reinterpret_cast<char*>(bytes.data()), 7);
+
+	if (bytes[0] != 0xff && readLength >= 1) {
+		auto n = *reinterpret_cast<quint8*>(bytes.data());
+		if (!this->reader.skip(1)) return false;
+		*slot = qFromLittleEndian(n);
+	} else if ((bytes[1] != 0xff || bytes[2] != 0xff) && readLength >= 3) {
+		auto n = *reinterpret_cast<quint16*>(bytes.data() + 1);
+		if (!this->reader.skip(3)) return false;
+		*slot = qFromLittleEndian(n);
+	} else if (readLength == 7) {
+		auto n = *reinterpret_cast<quint32*>(bytes.data() + 3);
+		if (!this->reader.skip(7)) return false;
+		*slot = qFromLittleEndian(n);
+	} else return false;
+
+	return true;
+}
+
+void EncodedLogWriter::writeString(QByteArrayView bytes) {
+	this->writeVarInt(bytes.length());
+	this->buffer.writeBytes(bytes.constData(), bytes.length());
+}
+
+bool EncodedLogReader::readString(QByteArray* slot) {
+	quint32 length = 0;
+	if (!this->readVarInt(&length)) return false;
+
+	*slot = QByteArray(length, Qt::Uninitialized);
+	auto r = this->reader.readBytes(slot->data(), slot->size());
+	return r;
+}
+
+quint16 EncodedLogWriter::getOrCreateCategory(QLatin1StringView category) {
+	if (this->categories.contains(category)) {
+		return this->categories.value(category);
+	} else {
+		this->writeOp(EncodedLogOpcode::RegisterCategory);
+		// id is implicitly the next available id
+		this->writeString(category);
+
+		auto id = this->nextCategory++;
+		this->categories.insert(category, id);
+
+		auto filter = LogManager::instance()->getFilter(category);
+		quint8 flags = 0;
+		flags |= filter.debug << 0;
+		flags |= filter.info << 1;
+		flags |= filter.warn << 2;
+		flags |= filter.critical << 3;
+
+		this->buffer.writeU8(flags);
+		return id;
+	}
+}
+
+bool EncodedLogReader::registerCategory() {
+	QByteArray name;
+	quint8 flags = 0;
+	if (!this->readString(&name)) return false;
+	if (!this->reader.readU8(&flags)) return false;
+
+	CategoryFilter filter;
+	filter.debug = (flags >> 0) & 1;
+	filter.info = (flags >> 1) & 1;
+	filter.warn = (flags >> 2) & 1;
+	filter.critical = (flags >> 3) & 1;
+
+	this->categories.append(qMakePair(name, filter));
+	return true;
+}
+
+bool LogReader::initialize() {
+	this->reader.setDevice(this->file);
+
+	bool readable = false;
+	quint8 logVersion = 0;
+	quint8 readerVersion = 0;
+	if (!this->reader.readHeader(&readable, &logVersion, &readerVersion)) {
+		qCritical() << "Failed to read log header.";
+		return false;
+	}
+
+	if (!readable) {
+		qCritical() << "This log was encoded with version" << logVersion
+		            << "of the quickshell log encoder, which cannot be decoded by the current "
+		               "version of quickshell, with log version"
+		            << readerVersion;
+		return false;
+	}
+
+	return true;
+}
+
+bool LogReader::continueReading() {
+	auto color = LogManager::instance()->colorLogs;
+	auto tailRing = RingBuffer<LogMessage>(this->remainingTail);
+
+	LogMessage message;
+	auto stream = QTextStream(stdout);
+	auto readCursor = this->file->pos();
+	while (this->reader.read(&message)) {
+		readCursor = this->file->pos();
+
+		CategoryFilter filter;
+		if (this->filters.contains(message.readCategoryId)) {
+			filter = this->filters.value(message.readCategoryId);
+		} else {
+			filter = this->reader.categoryFilterById(message.readCategoryId);
+
+			for (const auto& rule: this->rules) {
+				filter.applyRule(message.category, rule);
+			}
+
+			this->filters.insert(message.readCategoryId, filter);
+		}
+
+		if (filter.shouldDisplay(message.type)) {
+			if (this->remainingTail == 0) {
+				LogMessage::formatMessage(stream, message, color, this->timestamps);
+				stream << '\n';
+			} else {
+				tailRing.emplace(message);
+			}
+		}
+	}
+
+	if (this->remainingTail != 0) {
+		for (auto i = tailRing.size() - 1; i != -1; i--) {
+			auto& message = tailRing.at(i);
+			LogMessage::formatMessage(stream, message, color, this->timestamps);
+			stream << '\n';
+		}
+	}
+
+	stream << Qt::flush;
+
+	if (this->file->pos() != readCursor) {
+		qCritical() << "An error occurred parsing the end of this log file.";
+		qCritical() << "Remaining data:" << this->file->readAll();
+		return false;
+	}
+
+	return true;
+}
+
+void LogFollower::FcntlWaitThread::run() {
+	auto lock = flock {
+	    .l_type = F_RDLCK, // won't block other read locks when we take it
+	    .l_whence = SEEK_SET,
+	    .l_start = 0,
+	    .l_len = 0,
+	    .l_pid = 0,
+	};
+
+	auto r = fcntl(this->follower->reader->file->handle(), F_SETLKW, &lock); // NOLINT
+
+	if (r != 0) {
+		qCWarning(logLogging).nospace()
+		    << "Failed to wait for write locks to be removed from log file with error code " << errno
+		    << ": " << qt_error_string();
+	}
+}
+
+bool LogFollower::follow() {
+	QObject::connect(&this->waitThread, &QThread::finished, this, &LogFollower::onFileLocked);
+
+	QObject::connect(
+	    &this->fileWatcher,
+	    &QFileSystemWatcher::fileChanged,
+	    this,
+	    &LogFollower::onFileChanged
+	);
+
+	this->fileWatcher.addPath(this->path);
+	this->waitThread.start();
+
+	auto r = QCoreApplication::exec();
+	return r == 0;
+}
+
+void LogFollower::onFileChanged() {
+	if (!this->reader->continueReading()) {
+		QCoreApplication::exit(1);
+	}
+}
+
+void LogFollower::onFileLocked() {
+	if (!this->reader->continueReading()) {
+		QCoreApplication::exit(1);
+	} else {
+		QCoreApplication::exit(0);
+	}
+}
+
+bool readEncodedLogs(
+    QFile* file,
+    const QString& path,
+    bool timestamps,
+    int tail,
+    bool follow,
+    const QString& rulespec
+) {
+	QList<QLoggingRule> rules;
+
+	{
+		QLoggingSettingsParser parser;
+		parser.setContent(rulespec);
+		rules = parser.rules();
+	}
+
+	auto reader = LogReader(file, timestamps, tail, rules);
+
+	if (!reader.initialize()) return false;
+	if (!reader.continueReading()) return false;
+
+	if (follow) {
+		auto follower = LogFollower(&reader, path);
+		return follower.follow();
+	}
+
+	return true;
+}
+
+} // namespace qs::log
diff --git a/src/core/logging.hpp b/src/core/logging.hpp
new file mode 100644
index 00000000..bf811333
--- /dev/null
+++ b/src/core/logging.hpp
@@ -0,0 +1,154 @@
+#pragma once
+
+#include <utility>
+
+#include <qbytearrayview.h>
+#include <qcontainerfwd.h>
+#include <qdatetime.h>
+#include <qfile.h>
+#include <qhash.h>
+#include <qlatin1stringview.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+#include "logcat.hpp"
+
+QS_DECLARE_LOGGING_CATEGORY(logBare);
+
+namespace qs::log {
+
+struct LogMessage {
+	explicit LogMessage() = default;
+
+	explicit LogMessage(
+	    QtMsgType type,
+	    QLatin1StringView category,
+	    QByteArray body,
+	    QDateTime time = QDateTime::currentDateTime()
+	)
+	    : type(type)
+	    , time(std::move(time))
+	    , category(category)
+	    , body(std::move(body)) {}
+
+	bool operator==(const LogMessage& other) const;
+
+	QtMsgType type = QtDebugMsg;
+	QDateTime time;
+	QLatin1StringView category;
+	QByteArray body;
+	quint16 readCategoryId = 0;
+
+	static void formatMessage(
+	    QTextStream& stream,
+	    const LogMessage& msg,
+	    bool color,
+	    bool timestamp,
+	    const QString& prefix = ""
+	);
+};
+
+size_t qHash(const LogMessage& message);
+
+class ThreadLogging;
+
+class LoggingThreadProxy: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit LoggingThreadProxy() = default;
+
+public slots:
+	void initInThread();
+	void initFs();
+
+private:
+	ThreadLogging* logging = nullptr;
+};
+
+namespace qt_logging_registry {
+class QLoggingRule;
+}
+
+struct CategoryFilter {
+	explicit CategoryFilter() = default;
+	explicit CategoryFilter(QLoggingCategory* category)
+	    : debug(category->isDebugEnabled())
+	    , info(category->isInfoEnabled())
+	    , warn(category->isWarningEnabled())
+	    , critical(category->isCriticalEnabled()) {}
+
+	[[nodiscard]] bool shouldDisplay(QtMsgType type) const;
+	void apply(QLoggingCategory* category) const;
+	void applyRule(QLatin1StringView category, const qt_logging_registry::QLoggingRule& rule);
+
+	bool debug = true;
+	bool info = true;
+	bool warn = true;
+	bool critical = true;
+};
+
+class LogManager: public QObject {
+	Q_OBJECT;
+
+public:
+	static void init(
+	    bool color,
+	    bool timestamp,
+	    bool sparseOnly,
+	    QtMsgType defaultLevel,
+	    const QString& rules,
+	    const QString& prefix = ""
+	);
+
+	static void initFs();
+	static LogManager* instance();
+
+	bool colorLogs = true;
+	bool timestampLogs = false;
+
+	[[nodiscard]] QString rulesString() const;
+	[[nodiscard]] QtMsgType defaultLevel() const;
+	[[nodiscard]] bool isSparse() const;
+
+	[[nodiscard]] CategoryFilter getFilter(QLatin1StringView category);
+
+signals:
+	void logMessage(LogMessage msg, bool showInSparse);
+
+private:
+	explicit LogManager();
+	static void messageHandler(QtMsgType type, const QMessageLogContext& context, const QString& msg);
+
+	static void filterCategory(QLoggingCategory* category);
+
+	QLoggingCategory::CategoryFilter lastCategoryFilter = nullptr;
+	bool sparse = false;
+	QString prefix;
+	QString mRulesString;
+	QList<qt_logging_registry::QLoggingRule>* rules = nullptr;
+	QtMsgType mDefaultLevel = QtWarningMsg;
+	QHash<QLatin1StringView, QtMsgType> defaultLevels;
+	QHash<const void*, CategoryFilter> sparseFilters;
+	QHash<QLatin1StringView, CategoryFilter> allFilters;
+
+	QTextStream stdoutStream;
+	LoggingThreadProxy threadProxy;
+
+	friend void initLogCategoryLevel(const char* name, QtMsgType defaultLevel);
+};
+
+bool readEncodedLogs(
+    QFile* file,
+    const QString& path,
+    bool timestamps,
+    int tail,
+    bool follow,
+    const QString& rulespec
+);
+
+} // namespace qs::log
+
+using LogManager = qs::log::LogManager;
diff --git a/src/core/logging_p.hpp b/src/core/logging_p.hpp
new file mode 100644
index 00000000..3297ea1b
--- /dev/null
+++ b/src/core/logging_p.hpp
@@ -0,0 +1,190 @@
+#pragma once
+#include <utility>
+
+#include <qbytearrayview.h>
+#include <qcontainerfwd.h>
+#include <qfile.h>
+#include <qfilesystemwatcher.h>
+#include <qlogging.h>
+#include <qobject.h>
+#include <qthread.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "logging.hpp"
+#include "logging_qtprivate.hpp"
+#include "ringbuf.hpp"
+
+namespace qs::log {
+
+enum EncodedLogOpcode : quint8 {
+	RegisterCategory = 0,
+	RecentMessageShort,
+	RecentMessageLong,
+	BeginCategories,
+};
+
+enum CompressedLogType : quint8 {
+	Debug = 0,
+	Info = 1,
+	Warn = 2,
+	Critical = 3,
+};
+
+CompressedLogType compressedTypeOf(QtMsgType type);
+QtMsgType typeOfCompressed(CompressedLogType type);
+
+class WriteBuffer {
+public:
+	void setDevice(QIODevice* device);
+	[[nodiscard]] bool hasDevice() const;
+	[[nodiscard]] bool flush();
+	void writeBytes(const char* data, qsizetype length);
+	void writeU8(quint8 data);
+	void writeU16(quint16 data);
+	void writeU32(quint32 data);
+	void writeU64(quint64 data);
+
+private:
+	QIODevice* device = nullptr;
+	QByteArray buffer;
+};
+
+class DeviceReader {
+public:
+	void setDevice(QIODevice* device);
+	[[nodiscard]] bool hasDevice() const;
+	[[nodiscard]] bool readBytes(char* data, qsizetype length);
+	// peek UP TO length
+	[[nodiscard]] qsizetype peekBytes(char* data, qsizetype length);
+	[[nodiscard]] bool skip(qsizetype length);
+	[[nodiscard]] bool readU8(quint8* data);
+	[[nodiscard]] bool readU16(quint16* data);
+	[[nodiscard]] bool readU32(quint32* data);
+	[[nodiscard]] bool readU64(quint64* data);
+
+private:
+	QIODevice* device = nullptr;
+};
+
+class EncodedLogWriter {
+public:
+	void setDevice(QIODevice* target);
+	[[nodiscard]] bool writeHeader();
+	[[nodiscard]] bool write(const LogMessage& message);
+
+private:
+	void writeOp(EncodedLogOpcode opcode);
+	void writeVarInt(quint32 n);
+	void writeString(QByteArrayView bytes);
+	quint16 getOrCreateCategory(QLatin1StringView category);
+
+	WriteBuffer buffer;
+
+	QHash<QLatin1StringView, quint16> categories;
+	quint16 nextCategory = EncodedLogOpcode::BeginCategories;
+
+	QDateTime lastMessageTime = QDateTime::fromSecsSinceEpoch(0);
+	HashBuffer<LogMessage> recentMessages {256};
+};
+
+class EncodedLogReader {
+public:
+	void setDevice(QIODevice* source);
+	[[nodiscard]] bool readHeader(bool* success, quint8* logVersion, quint8* readerVersion);
+	// WARNING: log messages written to the given slot are invalidated when the log reader is destroyed.
+	[[nodiscard]] bool read(LogMessage* slot);
+	[[nodiscard]] CategoryFilter categoryFilterById(quint16 id);
+
+private:
+	[[nodiscard]] bool readVarInt(quint32* slot);
+	[[nodiscard]] bool readString(QByteArray* slot);
+	[[nodiscard]] bool registerCategory();
+
+	DeviceReader reader;
+	QVector<QPair<QByteArray, CategoryFilter>> categories;
+	QDateTime lastMessageTime = QDateTime::fromSecsSinceEpoch(0);
+	RingBuffer<LogMessage> recentMessages {256};
+};
+
+class ThreadLogging: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit ThreadLogging(QObject* parent): QObject(parent) {}
+
+	void init();
+	void initFs();
+	void setupFileLogging();
+
+private slots:
+	void onMessage(const LogMessage& msg, bool showInSparse);
+
+private:
+	QFile* file = nullptr;
+	QTextStream fileStream;
+	QFile* detailedFile = nullptr;
+	EncodedLogWriter detailedWriter;
+};
+
+class LogFollower;
+
+class LogReader {
+public:
+	explicit LogReader(
+	    QFile* file,
+	    bool timestamps,
+	    int tail,
+	    QList<qt_logging_registry::QLoggingRule> rules
+	)
+	    : file(file)
+	    , timestamps(timestamps)
+	    , remainingTail(tail)
+	    , rules(std::move(rules)) {}
+
+	bool initialize();
+	bool continueReading();
+
+private:
+	QFile* file;
+	EncodedLogReader reader;
+	bool timestamps;
+	int remainingTail;
+	QHash<quint16, CategoryFilter> filters;
+	QList<qt_logging_registry::QLoggingRule> rules;
+
+	friend class LogFollower;
+};
+
+class LogFollower: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit LogFollower(LogReader* reader, QString path): reader(reader), path(std::move(path)) {}
+
+	bool follow();
+
+private slots:
+	void onFileChanged();
+	void onFileLocked();
+
+private:
+	LogReader* reader;
+	QString path;
+	QFileSystemWatcher fileWatcher;
+
+	class FcntlWaitThread: public QThread {
+	public:
+		explicit FcntlWaitThread(LogFollower* follower): follower(follower) {}
+
+	protected:
+		void run() override;
+
+	private:
+		LogFollower* follower;
+	};
+
+	FcntlWaitThread waitThread {this};
+};
+
+} // namespace qs::log
diff --git a/src/core/logging_qtprivate.cpp b/src/core/logging_qtprivate.cpp
new file mode 100644
index 00000000..48f74dee
--- /dev/null
+++ b/src/core/logging_qtprivate.cpp
@@ -0,0 +1,139 @@
+// The logging rule parser from qloggingregistry_p.h and qloggingregistry.cpp.
+
+// Was unable to properly link the functions when directly using the headers (which we depend
+// on anyway), so below is a slightly stripped down copy. Making the originals link would
+// be preferable.
+
+#include <utility>
+
+#include <qbytearrayview.h>
+#include <qchar.h>
+#include <qflags.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qstringtokenizer.h>
+#include <qstringview.h>
+#include <qtypes.h>
+
+#include "logcat.hpp"
+#include "logging_qtprivate.hpp"
+
+namespace qs::log {
+QS_DECLARE_LOGGING_CATEGORY(logLogging);
+
+namespace qt_logging_registry {
+
+class QLoggingSettingsParser {
+public:
+	void setContent(QStringView content);
+
+	[[nodiscard]] QList<QLoggingRule> rules() const { return this->mRules; }
+
+private:
+	void parseNextLine(QStringView line);
+
+private:
+	QList<QLoggingRule> mRules;
+};
+
+void QLoggingSettingsParser::setContent(QStringView content) {
+	this->mRules.clear();
+	for (auto line: qTokenize(content, u';')) this->parseNextLine(line);
+}
+
+void QLoggingSettingsParser::parseNextLine(QStringView line) {
+	// Remove whitespace at start and end of line:
+	line = line.trimmed();
+
+	const qsizetype equalPos = line.indexOf(u'=');
+	if (equalPos != -1) {
+		if (line.lastIndexOf(u'=') == equalPos) {
+			const auto key = line.left(equalPos).trimmed();
+			const QStringView pattern = key;
+			const auto valueStr = line.mid(equalPos + 1).trimmed();
+			int value = -1;
+			if (valueStr == QString("true")) value = 1;
+			else if (valueStr == QString("false")) value = 0;
+			QLoggingRule rule(pattern, (value == 1));
+			if (rule.flags != 0 && (value != -1)) this->mRules.append(std::move(rule));
+			else
+				qCWarning(logLogging, "Ignoring malformed logging rule: '%s'", line.toUtf8().constData());
+		} else {
+			qCWarning(logLogging, "Ignoring malformed logging rule: '%s'", line.toUtf8().constData());
+		}
+	}
+}
+
+QLoggingRule::QLoggingRule(QStringView pattern, bool enabled): messageType(-1), enabled(enabled) {
+	this->parse(pattern);
+}
+
+void QLoggingRule::parse(QStringView pattern) {
+	QStringView p;
+
+	// strip trailing ".messagetype"
+	if (pattern.endsWith(QString(".debug"))) {
+		p = pattern.chopped(6); // strlen(".debug")
+		this->messageType = QtDebugMsg;
+	} else if (pattern.endsWith(QString(".info"))) {
+		p = pattern.chopped(5); // strlen(".info")
+		this->messageType = QtInfoMsg;
+	} else if (pattern.endsWith(QString(".warning"))) {
+		p = pattern.chopped(8); // strlen(".warning")
+		this->messageType = QtWarningMsg;
+	} else if (pattern.endsWith(QString(".critical"))) {
+		p = pattern.chopped(9); // strlen(".critical")
+		this->messageType = QtCriticalMsg;
+	} else {
+		p = pattern;
+	}
+
+	const QChar asterisk = u'*';
+	if (!p.contains(asterisk)) {
+		this->flags = FullText;
+	} else {
+		if (p.endsWith(asterisk)) {
+			this->flags |= LeftFilter;
+			p = p.chopped(1);
+		}
+		if (p.startsWith(asterisk)) {
+			this->flags |= RightFilter;
+			p = p.mid(1);
+		}
+		if (p.contains(asterisk)) // '*' only supported at start/end
+			this->flags = PatternFlags();
+	}
+
+	this->category = p.toString();
+}
+
+int QLoggingRule::pass(QLatin1StringView cat, QtMsgType msgType) const {
+	// check message type
+	if (this->messageType > -1 && this->messageType != msgType) return 0;
+
+	if (this->flags == FullText) {
+		// full match
+		if (this->category == cat) return (this->enabled ? 1 : -1);
+		else return 0;
+	}
+
+	const qsizetype idx = cat.indexOf(this->category);
+	if (idx >= 0) {
+		if (this->flags == MidFilter) {
+			// matches somewhere
+			return (this->enabled ? 1 : -1);
+		} else if (this->flags == LeftFilter) {
+			// matches left
+			if (idx == 0) return (this->enabled ? 1 : -1);
+		} else if (this->flags == RightFilter) {
+			// matches right
+			if (idx == (cat.size() - this->category.size())) return (this->enabled ? 1 : -1);
+		}
+	}
+	return 0;
+}
+
+} // namespace qt_logging_registry
+
+} // namespace qs::log
diff --git a/src/core/logging_qtprivate.hpp b/src/core/logging_qtprivate.hpp
new file mode 100644
index 00000000..61d3a7cf
--- /dev/null
+++ b/src/core/logging_qtprivate.hpp
@@ -0,0 +1,47 @@
+#pragma once
+
+// The logging rule parser from qloggingregistry_p.h and qloggingregistry.cpp.
+
+// Was unable to properly link the functions when directly using the headers (which we depend
+// on anyway), so below is a slightly stripped down copy. Making the originals link would
+// be preferable.
+
+#include <qflags.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qstringview.h>
+#include <qtypes.h>
+
+#include "logcat.hpp"
+
+namespace qs::log {
+QS_DECLARE_LOGGING_CATEGORY(logLogging);
+
+namespace qt_logging_registry {
+
+class QLoggingRule {
+public:
+	QLoggingRule();
+	QLoggingRule(QStringView pattern, bool enabled);
+	[[nodiscard]] int pass(QLatin1StringView categoryName, QtMsgType type) const;
+
+	enum PatternFlag : quint8 {
+		FullText = 0x1,
+		LeftFilter = 0x2,
+		RightFilter = 0x4,
+		MidFilter = LeftFilter | RightFilter
+	};
+	Q_DECLARE_FLAGS(PatternFlags, PatternFlag)
+
+	QString category;
+	int messageType;
+	PatternFlags flags;
+	bool enabled;
+
+private:
+	void parse(QStringView pattern);
+};
+
+} // namespace qt_logging_registry
+
+} // namespace qs::log
diff --git a/src/core/main.cpp b/src/core/main.cpp
deleted file mode 100644
index 7dd7af30..00000000
--- a/src/core/main.cpp
+++ /dev/null
@@ -1,257 +0,0 @@
-#include <iostream>
-
-#include <qcommandlineoption.h>
-#include <qcommandlineparser.h>
-#include <qdir.h>
-#include <qfileinfo.h>
-#include <qguiapplication.h>
-#include <qlogging.h>
-#include <qobject.h>
-#include <qquickwindow.h>
-#include <qstandardpaths.h>
-#include <qstring.h>
-#include <qtenvironmentvariables.h>
-#include <qtextstream.h>
-#include <qtpreprocessorsupport.h>
-
-#include "plugin.hpp"
-#include "rootwrapper.hpp"
-
-int main(int argc, char** argv) {
-	const auto app = QGuiApplication(argc, argv);
-	QGuiApplication::setApplicationName("quickshell");
-	QGuiApplication::setApplicationVersion("0.1.0 (" GIT_REVISION ")");
-
-	QCommandLineParser parser;
-	parser.addHelpOption();
-	parser.addVersionOption();
-
-	// clang-format off
-	auto currentOption = QCommandLineOption("current", "Print information about the manifest and defaults.");
-	auto manifestOption = QCommandLineOption({"m", "manifest"}, "Path to a configuration manifest.", "path");
-	auto configOption = QCommandLineOption({"c", "config"}, "Name of a configuration in the manifest.", "name");
-	auto pathOption = QCommandLineOption({"p", "path"}, "Path to a configuration file.", "path");
-	auto workdirOption = QCommandLineOption({"d", "workdir"}, "Initial working directory.", "path");
-	// clang-format on
-
-	parser.addOption(currentOption);
-	parser.addOption(manifestOption);
-	parser.addOption(configOption);
-	parser.addOption(pathOption);
-	parser.addOption(workdirOption);
-	parser.process(app);
-
-	QString configFilePath;
-	{
-		auto printCurrent = parser.isSet(currentOption);
-
-		// NOLINTBEGIN
-#define CHECK(rname, name, level, label, expr)                                                     \
-	QString name = expr;                                                                             \
-	if (rname.isEmpty() && !name.isEmpty()) {                                                        \
-		rname = name;                                                                                  \
-		rname##Level = level;                                                                          \
-		if (!printCurrent) goto label;                                                                 \
-	}
-
-#define OPTSTR(name) (name.isEmpty() ? "(unset)" : name.toStdString())
-		// NOLINTEND
-
-		QString basePath;
-		int basePathLevel = 0;
-		Q_UNUSED(basePathLevel);
-		{
-			// NOLINTBEGIN
-			// clang-format off
-			CHECK(basePath, envBasePath, 0, foundbase, qEnvironmentVariable("QS_BASE_PATH"));
-			CHECK(basePath, defaultBasePath, 0, foundbase, QDir(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation)).filePath("quickshell"));
-			// clang-format on
-			// NOLINTEND
-
-			if (printCurrent) {
-				// clang-format off
-				std::cout << "Base path: " << OPTSTR(basePath) << "\n";
-				std::cout << " - Environment (QS_BASE_PATH): " << OPTSTR(envBasePath) << "\n";
-				std::cout << " - Default: " << OPTSTR(defaultBasePath) << "\n";
-				// clang-format on
-			}
-		}
-	foundbase:;
-
-		QString configPath;
-		int configPathLevel = 10;
-		{
-			// NOLINTBEGIN
-			CHECK(configPath, optionConfigPath, 0, foundpath, parser.value(pathOption));
-			CHECK(configPath, envConfigPath, 1, foundpath, qEnvironmentVariable("QS_CONFIG_PATH"));
-			// NOLINTEND
-
-			if (printCurrent) {
-				// clang-format off
-				std::cout << "\nConfig path: " << OPTSTR(configPath) << "\n";
-				std::cout << " - Option: " << OPTSTR(optionConfigPath) << "\n";
-				std::cout << " - Environment (QS_CONFIG_PATH): " << OPTSTR(envConfigPath) << "\n";
-				// clang-format on
-			}
-		}
-	foundpath:;
-
-		QString manifestPath;
-		int manifestPathLevel = 10;
-		{
-			// NOLINTBEGIN
-			// clang-format off
-			CHECK(manifestPath, optionManifestPath, 0, foundmf, parser.value(manifestOption));
-			CHECK(manifestPath, envManifestPath, 1, foundmf, qEnvironmentVariable("QS_MANIFEST"));
-			CHECK(manifestPath, defaultManifestPath, 2, foundmf, QDir(basePath).filePath("manifest.conf"));
-			// clang-format on
-			// NOLINTEND
-
-			if (printCurrent) {
-				// clang-format off
-				std::cout << "\nManifest path: " << OPTSTR(manifestPath) << "\n";
-				std::cout << " - Option: " << OPTSTR(optionManifestPath) << "\n";
-				std::cout << " - Environment (QS_MANIFEST): " << OPTSTR(envManifestPath) << "\n";
-				std::cout << " - Default: " << OPTSTR(defaultManifestPath) << "\n";
-				// clang-format on
-			}
-		}
-	foundmf:;
-
-		QString configName;
-		int configNameLevel = 10;
-		{
-			// NOLINTBEGIN
-			CHECK(configName, optionConfigName, 0, foundname, parser.value(configOption));
-			CHECK(configName, envConfigName, 1, foundname, qEnvironmentVariable("QS_CONFIG_NAME"));
-			// NOLINTEND
-
-			if (printCurrent) {
-				// clang-format off
-				std::cout << "\nConfig name: " << OPTSTR(configName) << "\n";
-				std::cout << " - Option: " << OPTSTR(optionConfigName) << "\n";
-				std::cout << " - Environment (QS_CONFIG_NAME): " << OPTSTR(envConfigName) << "\n\n";
-				// clang-format on
-			}
-		}
-	foundname:;
-
-		if (configPathLevel == 0 && configNameLevel == 0) {
-			qFatal() << "Pass only one of --path or --config";
-			return -1;
-		}
-
-		if (!configPath.isEmpty() && configPathLevel <= configNameLevel) {
-			configFilePath = configPath;
-		} else if (!configName.isEmpty()) {
-			if (!manifestPath.isEmpty()) {
-				auto file = QFile(manifestPath);
-				if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-					auto stream = QTextStream(&file);
-					while (!stream.atEnd()) {
-						auto line = stream.readLine();
-						if (line.trimmed().startsWith("#")) continue;
-						if (line.trimmed().isEmpty()) continue;
-
-						auto split = line.split('=');
-						if (split.length() != 2) {
-							qFatal() << "manifest line not in expected format 'name = relativepath':" << line;
-							return -1;
-						}
-
-						if (split[0].trimmed() == configName) {
-							configFilePath = QDir(QFileInfo(file).canonicalPath()).filePath(split[1].trimmed());
-							goto haspath; // NOLINT
-						}
-					}
-
-					qFatal() << "configuration" << configName << "not found in manifest" << manifestPath;
-					return -1;
-				} else if (manifestPathLevel < 2) {
-					qFatal() << "cannot open config manifest at" << manifestPath;
-					return -1;
-				}
-			}
-
-			{
-				auto basePathInfo = QFileInfo(basePath);
-				if (!basePathInfo.exists()) {
-					qFatal() << "base path does not exist:" << basePath;
-					return -1;
-				} else if (!QFileInfo(basePathInfo.canonicalFilePath()).isDir()) {
-					qFatal() << "base path is not a directory" << basePath;
-					return -1;
-				}
-
-				auto dir = QDir(basePath);
-				for (auto& entry: dir.entryList(QDir::AllDirs | QDir::NoDotAndDotDot)) {
-					if (entry == configName) {
-						configFilePath = dir.filePath(entry);
-						goto haspath; // NOLINT
-					}
-				}
-
-				qFatal() << "no directory named " << configName << "found in base path" << basePath;
-				return -1;
-			}
-		haspath:;
-		} else {
-			configFilePath = basePath;
-		}
-
-		auto configFile = QFileInfo(configFilePath);
-		if (!configFile.exists()) {
-			qFatal() << "config path does not exist:" << configFilePath;
-			return -1;
-		}
-
-		if (configFile.isDir()) {
-			configFilePath = QDir(configFilePath).filePath("shell.qml");
-		}
-
-		configFile = QFileInfo(configFilePath);
-		if (!configFile.exists()) {
-			qFatal() << "no shell.qml found in config path:" << configFilePath;
-			return -1;
-		} else if (configFile.isDir()) {
-			qFatal() << "shell.qml is a directory:" << configFilePath;
-			return -1;
-		}
-
-		configFilePath = QFileInfo(configFilePath).canonicalFilePath();
-		configFile = QFileInfo(configFilePath);
-		if (!configFile.exists()) {
-			qFatal() << "config file does not exist:" << configFilePath;
-			return -1;
-		} else if (configFile.isDir()) {
-			qFatal() << "config file is a directory:" << configFilePath;
-			return -1;
-		}
-
-#undef CHECK
-#undef OPTSTR
-
-		qInfo() << "config file path:" << configFilePath;
-
-		if (printCurrent) return 0;
-	}
-
-	if (!QFile(configFilePath).exists()) {
-		qCritical() << "config file does not exist";
-		return -1;
-	}
-
-	if (parser.isSet(workdirOption)) {
-		QDir::setCurrent(parser.value(workdirOption));
-	}
-
-	QuickshellPlugin::initPlugins();
-
-	// Base window transparency appears to be additive.
-	// Use a fully transparent window with a colored rect.
-	QQuickWindow::setDefaultAlphaBuffer(true);
-
-	auto root = RootWrapper(configFilePath);
-
-	return QGuiApplication::exec();
-}
diff --git a/src/core/model.cpp b/src/core/model.cpp
new file mode 100644
index 00000000..165c6066
--- /dev/null
+++ b/src/core/model.cpp
@@ -0,0 +1,81 @@
+#include "model.hpp"
+
+#include <qabstractitemmodel.h>
+#include <qhash.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+qint32 UntypedObjectModel::rowCount(const QModelIndex& parent) const {
+	if (parent != QModelIndex()) return 0;
+	return static_cast<qint32>(this->valuesList.length());
+}
+
+QVariant UntypedObjectModel::data(const QModelIndex& index, qint32 role) const {
+	if (role != Qt::UserRole) return QVariant();
+	return QVariant::fromValue(this->valuesList.at(index.row()));
+}
+
+QHash<int, QByteArray> UntypedObjectModel::roleNames() const {
+	return {{Qt::UserRole, "modelData"}};
+}
+
+void UntypedObjectModel::insertObject(QObject* object, qsizetype index) {
+	auto iindex = index == -1 ? this->valuesList.length() : index;
+	emit this->objectInsertedPre(object, iindex);
+
+	auto intIndex = static_cast<qint32>(iindex);
+	this->beginInsertRows(QModelIndex(), intIndex, intIndex);
+	this->valuesList.insert(iindex, object);
+	this->endInsertRows();
+
+	emit this->valuesChanged();
+	emit this->objectInsertedPost(object, iindex);
+}
+
+void UntypedObjectModel::removeAt(qsizetype index) {
+	auto* object = this->valuesList.at(index);
+	emit this->objectRemovedPre(object, index);
+
+	auto intIndex = static_cast<qint32>(index);
+	this->beginRemoveRows(QModelIndex(), intIndex, intIndex);
+	this->valuesList.removeAt(index);
+	this->endRemoveRows();
+
+	emit this->valuesChanged();
+	emit this->objectRemovedPost(object, index);
+}
+
+bool UntypedObjectModel::removeObject(const QObject* object) {
+	auto index = this->valuesList.indexOf(object);
+	if (index == -1) return false;
+
+	this->removeAt(index);
+	return true;
+}
+
+void UntypedObjectModel::diffUpdate(const QVector<QObject*>& newValues) {
+	for (qsizetype i = 0; i < this->valuesList.length();) {
+		if (newValues.contains(this->valuesList.at(i))) i++;
+		else this->removeAt(i);
+	}
+
+	qsizetype oi = 0;
+	for (auto* object: newValues) {
+		if (this->valuesList.length() == oi || this->valuesList.at(oi) != object) {
+			this->insertObject(object, oi);
+		}
+
+		oi++;
+	}
+}
+
+qsizetype UntypedObjectModel::indexOf(QObject* object) { return this->valuesList.indexOf(object); }
+
+UntypedObjectModel* UntypedObjectModel::emptyInstance() {
+	static auto* instance = new UntypedObjectModel(nullptr); // NOLINT
+	return instance;
+}
diff --git a/src/core/model.hpp b/src/core/model.hpp
new file mode 100644
index 00000000..3c5822a4
--- /dev/null
+++ b/src/core/model.hpp
@@ -0,0 +1,126 @@
+#pragma once
+
+#include <functional>
+
+#include <bit>
+#include <qabstractitemmodel.h>
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+#include "doc.hpp"
+
+///! View into a list of objets
+/// Typed view into a list of objects.
+///
+/// An ObjectModel works as a QML [Data Model], allowing efficient interaction with
+/// components that act on models. It has a single role named `modelData`, to match the
+/// behavior of lists.
+/// The same information contained in the list model is available as a normal list
+/// via the `values` property.
+///
+/// #### Differences from a list
+/// Unlike with a list, the following property binding will never be updated when `model[3]` changes.
+/// ```qml
+/// // will not update reactively
+/// property var foo: model[3]
+/// ```
+///
+/// You can work around this limitation using the @@values property of the model to view it as a list.
+/// ```qml
+/// // will update reactively
+/// property var foo: model.values[3]
+/// ```
+///
+/// [Data Model]: https://doc.qt.io/qt-6/qtquick-modelviewsdata-modelview.html#qml-data-models
+class UntypedObjectModel: public QAbstractListModel {
+	QSDOC_CNAME(ObjectModel);
+	Q_OBJECT;
+	/// The content of the object model, as a QML list.
+	/// The values of this property will always be of the type of the model.
+	Q_PROPERTY(QList<QObject*> values READ values NOTIFY valuesChanged);
+	QML_NAMED_ELEMENT(ObjectModel);
+	QML_UNCREATABLE("ObjectModels cannot be created directly.");
+
+public:
+	explicit UntypedObjectModel(QObject* parent): QAbstractListModel(parent) {}
+
+	[[nodiscard]] qint32 rowCount(const QModelIndex& parent) const override;
+	[[nodiscard]] QVariant data(const QModelIndex& index, qint32 role) const override;
+	[[nodiscard]] QHash<int, QByteArray> roleNames() const override;
+
+	[[nodiscard]] QList<QObject*> values() const { return this->valuesList; }
+	void removeAt(qsizetype index);
+
+	Q_INVOKABLE qsizetype indexOf(QObject* object);
+
+	static UntypedObjectModel* emptyInstance();
+
+signals:
+	void valuesChanged();
+	/// Sent immediately before an object is inserted into the list.
+	void objectInsertedPre(QObject* object, qsizetype index);
+	/// Sent immediately after an object is inserted into the list.
+	void objectInsertedPost(QObject* object, qsizetype index);
+	/// Sent immediately before an object is removed from the list.
+	void objectRemovedPre(QObject* object, qsizetype index);
+	/// Sent immediately after an object is removed from the list.
+	void objectRemovedPost(QObject* object, qsizetype index);
+
+protected:
+	void insertObject(QObject* object, qsizetype index = -1);
+	bool removeObject(const QObject* object);
+
+	// Assumes only one instance of a specific value
+	void diffUpdate(const QVector<QObject*>& newValues);
+
+	QVector<QObject*> valuesList;
+
+private:
+	static qsizetype valuesCount(QQmlListProperty<QObject>* property);
+	static QObject* valueAt(QQmlListProperty<QObject>* property, qsizetype index);
+};
+
+template <typename T>
+class ObjectModel: public UntypedObjectModel {
+public:
+	explicit ObjectModel(QObject* parent): UntypedObjectModel(parent) {}
+
+	[[nodiscard]] QVector<T*>& valueList() { return *std::bit_cast<QVector<T*>*>(&this->valuesList); }
+
+	[[nodiscard]] const QVector<T*>& valueList() const {
+		return *std::bit_cast<const QVector<T*>*>(&this->valuesList);
+	}
+
+	void insertObject(T* object, qsizetype index = -1) {
+		this->UntypedObjectModel::insertObject(object, index);
+	}
+
+	void insertObjectSorted(T* object, const std::function<bool(T*, T*)>& compare) {
+		auto& list = this->valueList();
+		auto iter = list.begin();
+
+		while (iter != list.end()) {
+			if (!compare(object, *iter)) break;
+			++iter;
+		}
+
+		auto idx = iter - list.begin();
+		this->UntypedObjectModel::insertObject(object, idx);
+	}
+
+	void removeObject(const T* object) { this->UntypedObjectModel::removeObject(object); }
+
+	// Assumes only one instance of a specific value
+	void diffUpdate(const QVector<T*>& newValues) {
+		this->UntypedObjectModel::diffUpdate(*std::bit_cast<const QVector<QObject*>*>(&newValues));
+	}
+
+	static ObjectModel<T>* emptyInstance() {
+		return static_cast<ObjectModel<T>*>(UntypedObjectModel::emptyInstance());
+	}
+};
diff --git a/src/core/module.md b/src/core/module.md
index 70b2c8c8..b9404ea9 100644
--- a/src/core/module.md
+++ b/src/core/module.md
@@ -7,10 +7,28 @@ headers = [
 	"shell.hpp",
 	"variants.hpp",
 	"region.hpp",
-	"proxywindow.hpp",
+	"../window/proxywindow.hpp",
 	"persistentprops.hpp",
-	"windowinterface.hpp",
-	"panelinterface.hpp",
-	"floatingwindow.hpp",
+	"../window/windowinterface.hpp",
+	"../window/panelinterface.hpp",
+	"../window/floatingwindow.hpp",
+	"../window/popupwindow.hpp",
+	"singleton.hpp",
+	"lazyloader.hpp",
+	"easingcurve.hpp",
+	"transformwatcher.hpp",
+	"boundcomponent.hpp",
+	"model.hpp",
+	"elapsedtimer.hpp",
+	"desktopentry.hpp",
+	"objectrepeater.hpp",
+	"qsmenu.hpp",
+	"retainable.hpp",
+	"popupanchor.hpp",
+	"types.hpp",
+	"qsmenuanchor.hpp",
+	"clock.hpp",
+	"scriptmodel.hpp",
+	"colorquantizer.hpp",
 ]
 -----
diff --git a/src/core/objectrepeater.cpp b/src/core/objectrepeater.cpp
new file mode 100644
index 00000000..7971952c
--- /dev/null
+++ b/src/core/objectrepeater.cpp
@@ -0,0 +1,190 @@
+#include "objectrepeater.hpp"
+#include <utility>
+
+#include <qabstractitemmodel.h>
+#include <qcontainerfwd.h>
+#include <qhash.h>
+#include <qlogging.h>
+#include <qobject.h>
+#include <qqmlcomponent.h>
+#include <qqmlcontext.h>
+#include <qqmlengine.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+QVariant ObjectRepeater::model() const { return this->mModel; }
+
+void ObjectRepeater::setModel(QVariant model) {
+	if (model == this->mModel) return;
+
+	if (this->itemModel != nullptr) {
+		QObject::disconnect(this->itemModel, nullptr, this, nullptr);
+	}
+
+	this->mModel = std::move(model);
+	emit this->modelChanged();
+	this->reloadElements();
+}
+
+void ObjectRepeater::onModelDestroyed() {
+	this->mModel.clear();
+	this->itemModel = nullptr;
+	emit this->modelChanged();
+	this->reloadElements();
+}
+
+QQmlComponent* ObjectRepeater::delegate() const { return this->mDelegate; }
+
+void ObjectRepeater::setDelegate(QQmlComponent* delegate) {
+	if (delegate == this->mDelegate) return;
+
+	if (this->mDelegate != nullptr) {
+		QObject::disconnect(this->mDelegate, nullptr, this, nullptr);
+	}
+
+	this->mDelegate = delegate;
+
+	if (delegate != nullptr) {
+		QObject::connect(
+		    this->mDelegate,
+		    &QObject::destroyed,
+		    this,
+		    &ObjectRepeater::onDelegateDestroyed
+		);
+	}
+
+	emit this->delegateChanged();
+	this->reloadElements();
+}
+
+void ObjectRepeater::onDelegateDestroyed() {
+	this->mDelegate = nullptr;
+	emit this->delegateChanged();
+	this->reloadElements();
+}
+
+void ObjectRepeater::reloadElements() {
+	for (auto i = this->valuesList.length() - 1; i >= 0; i--) {
+		this->removeComponent(i);
+	}
+
+	if (this->mDelegate == nullptr || !this->mModel.isValid()) return;
+
+	if (this->mModel.canConvert<QAbstractItemModel*>()) {
+		auto* model = this->mModel.value<QAbstractItemModel*>();
+		this->itemModel = model;
+
+		this->insertModelElements(model, 0, model->rowCount() - 1); // -1 is fine
+
+		// clang-format off
+		QObject::connect(model, &QObject::destroyed, this, &ObjectRepeater::onModelDestroyed);
+		QObject::connect(model, &QAbstractItemModel::rowsInserted, this, &ObjectRepeater::onModelRowsInserted);
+		QObject::connect(model, &QAbstractItemModel::rowsRemoved, this, &ObjectRepeater::onModelRowsRemoved);
+		QObject::connect(model, &QAbstractItemModel::rowsMoved, this, &ObjectRepeater::onModelRowsMoved);
+		QObject::connect(model, &QAbstractItemModel::modelAboutToBeReset, this, &ObjectRepeater::onModelAboutToBeReset);
+		// clang-format on
+	} else if (this->mModel.canConvert<QQmlListReference>()) {
+		auto values = this->mModel.value<QQmlListReference>();
+		auto len = values.count();
+
+		for (auto i = 0; i != len; i++) {
+			this->insertComponent(i, {{"modelData", QVariant::fromValue(values.at(i))}});
+		}
+	} else if (this->mModel.canConvert<QVector<QVariant>>()) {
+		auto values = this->mModel.value<QVector<QVariant>>();
+
+		for (auto& value: values) {
+			this->insertComponent(this->valuesList.length(), {{"modelData", value}});
+		}
+	} else {
+		qCritical() << this
+		            << "Cannot create components as the model is not compatible:" << this->mModel;
+	}
+}
+
+void ObjectRepeater::insertModelElements(QAbstractItemModel* model, int first, int last) {
+	auto roles = model->roleNames();
+	auto roleDataVec = QVector<QModelRoleData>();
+	for (auto id: roles.keys()) {
+		roleDataVec.push_back(QModelRoleData(id));
+	}
+
+	auto values = QModelRoleDataSpan(roleDataVec);
+	auto props = QVariantMap();
+
+	for (auto i = first; i != last + 1; i++) {
+		auto index = model->index(i, 0);
+		model->multiData(index, values);
+
+		for (auto [id, name]: roles.asKeyValueRange()) {
+			props.insert(name, *values.dataForRole(id));
+		}
+
+		this->insertComponent(i, props);
+
+		props.clear();
+	}
+}
+
+void ObjectRepeater::onModelRowsInserted(const QModelIndex& parent, int first, int last) {
+	if (parent != QModelIndex()) return;
+
+	this->insertModelElements(this->itemModel, first, last);
+}
+
+void ObjectRepeater::onModelRowsRemoved(const QModelIndex& parent, int first, int last) {
+	if (parent != QModelIndex()) return;
+
+	for (auto i = last; i != first - 1; i--) {
+		this->removeComponent(i);
+	}
+}
+
+void ObjectRepeater::onModelRowsMoved(
+    const QModelIndex& sourceParent,
+    int sourceStart,
+    int sourceEnd,
+    const QModelIndex& destParent,
+    int destStart
+) {
+	auto hasSource = sourceParent != QModelIndex();
+	auto hasDest = destParent != QModelIndex();
+
+	if (!hasSource && !hasDest) return;
+
+	if (hasSource) {
+		this->onModelRowsRemoved(sourceParent, sourceStart, sourceEnd);
+	}
+
+	if (hasDest) {
+		this->onModelRowsInserted(destParent, destStart, destStart + (sourceEnd - sourceStart));
+	}
+}
+
+void ObjectRepeater::onModelAboutToBeReset() {
+	auto last = static_cast<int>(this->valuesList.length() - 1);
+	this->onModelRowsRemoved(QModelIndex(), 0, last); // -1 is fine
+}
+
+void ObjectRepeater::insertComponent(qsizetype index, const QVariantMap& properties) {
+	auto* context = QQmlEngine::contextForObject(this);
+	auto* instance = this->mDelegate->createWithInitialProperties(properties, context);
+
+	if (instance == nullptr) {
+		qWarning().noquote() << this->mDelegate->errorString();
+		qWarning() << this << "failed to create object for model data" << properties;
+	} else {
+		QQmlEngine::setObjectOwnership(instance, QQmlEngine::CppOwnership);
+		instance->setParent(this);
+	}
+
+	this->insertObject(instance, index);
+}
+
+void ObjectRepeater::removeComponent(qsizetype index) {
+	auto* instance = this->valuesList.at(index);
+	this->removeAt(index);
+	delete instance;
+}
diff --git a/src/core/objectrepeater.hpp b/src/core/objectrepeater.hpp
new file mode 100644
index 00000000..409b12dc
--- /dev/null
+++ b/src/core/objectrepeater.hpp
@@ -0,0 +1,85 @@
+#pragma once
+
+#include <qabstractitemmodel.h>
+#include <qobject.h>
+#include <qqmlcomponent.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+#include "model.hpp"
+
+///! A Repeater / for loop / map for non Item derived objects.
+/// > [!ERROR] Removed in favor of @@QtQml.Models.Instantiator
+///
+/// The ObjectRepeater creates instances of the provided delegate for every entry in the
+/// given model, similarly to a @@QtQuick.Repeater but for non visual types.
+class ObjectRepeater: public ObjectModel<QObject> {
+	Q_OBJECT;
+	/// The model providing data to the ObjectRepeater.
+	///
+	/// Currently accepted model types are `list<T>` lists, javascript arrays,
+	/// and [QAbstractListModel] derived models, though only one column will be repeated
+	/// from the latter.
+	///
+	/// Note: @@ObjectModel is a [QAbstractListModel] with a single column.
+	///
+	/// [QAbstractListModel]: https://doc.qt.io/qt-6/qabstractlistmodel.html
+	Q_PROPERTY(QVariant model READ model WRITE setModel NOTIFY modelChanged);
+	/// The delegate component to repeat.
+	///
+	/// The delegate is given the same properties as in a Repeater, except `index` which
+	/// is not currently implemented.
+	///
+	/// If the model is a `list<T>` or javascript array, a `modelData` property will be
+	/// exposed containing the entry from the model. If the model is a [QAbstractListModel],
+	/// the roles from the model will be exposed.
+	///
+	/// Note: @@ObjectModel has a single role named `modelData` for compatibility with normal lists.
+	///
+	/// [QAbstractListModel]: https://doc.qt.io/qt-6/qabstractlistmodel.html
+	Q_PROPERTY(QQmlComponent* delegate READ delegate WRITE setDelegate NOTIFY delegateChanged);
+	Q_CLASSINFO("DefaultProperty", "delegate");
+	QML_ELEMENT;
+	QML_UNCREATABLE("ObjectRepeater has been removed in favor of QtQml.Models.Instantiator.");
+
+public:
+	explicit ObjectRepeater(QObject* parent = nullptr): ObjectModel(parent) {}
+
+	[[nodiscard]] QVariant model() const;
+	void setModel(QVariant model);
+
+	[[nodiscard]] QQmlComponent* delegate() const;
+	void setDelegate(QQmlComponent* delegate);
+
+signals:
+	void modelChanged();
+	void delegateChanged();
+
+private slots:
+	void onDelegateDestroyed();
+	void onModelDestroyed();
+	void onModelRowsInserted(const QModelIndex& parent, int first, int last);
+	void onModelRowsRemoved(const QModelIndex& parent, int first, int last);
+
+	void onModelRowsMoved(
+	    const QModelIndex& sourceParent,
+	    int sourceStart,
+	    int sourceEnd,
+	    const QModelIndex& destParent,
+	    int destStart
+	);
+
+	void onModelAboutToBeReset();
+
+private:
+	void reloadElements();
+	void insertModelElements(QAbstractItemModel* model, int first, int last);
+	void insertComponent(qsizetype index, const QVariantMap& properties);
+	void removeComponent(qsizetype index);
+
+	QVariant mModel;
+	QAbstractItemModel* itemModel = nullptr;
+	QQmlComponent* mDelegate = nullptr;
+};
diff --git a/src/core/paths.cpp b/src/core/paths.cpp
new file mode 100644
index 00000000..e17c3bcf
--- /dev/null
+++ b/src/core/paths.cpp
@@ -0,0 +1,425 @@
+#include "paths.hpp"
+#include <cerrno>
+#include <cstdio>
+#include <utility>
+
+#include <fcntl.h>
+#include <qcontainerfwd.h>
+#include <qdatastream.h>
+#include <qdir.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qpair.h>
+#include <qstandardpaths.h>
+#include <qtenvironmentvariables.h>
+#include <qtversionchecks.h>
+#include <unistd.h>
+
+#include "instanceinfo.hpp"
+#include "logcat.hpp"
+
+namespace {
+QS_LOGGING_CATEGORY(logPaths, "quickshell.paths", QtWarningMsg);
+}
+
+QsPaths* QsPaths::instance() {
+	static auto* instance = new QsPaths(); // NOLINT
+	return instance;
+}
+
+void QsPaths::init(QString shellId, QString pathId, QString dataOverride, QString stateOverride) {
+	auto* instance = QsPaths::instance();
+	instance->shellId = std::move(shellId);
+	instance->pathId = std::move(pathId);
+	instance->shellDataOverride = std::move(dataOverride);
+	instance->shellStateOverride = std::move(stateOverride);
+}
+
+QDir QsPaths::crashDir(const QString& id) {
+	auto dir = QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation));
+	dir = QDir(dir.filePath("crashes"));
+	dir = QDir(dir.filePath(id));
+
+	return dir;
+}
+
+QString QsPaths::basePath(const QString& id) {
+	auto path = QsPaths::instance()->baseRunDir()->filePath("by-id");
+	path = QDir(path).filePath(id);
+	return path;
+}
+
+QString QsPaths::ipcPath(const QString& id) {
+	return QDir(QsPaths::basePath(id)).filePath("ipc.sock");
+}
+
+QDir* QsPaths::baseRunDir() {
+	if (this->baseRunState == DirState::Unknown) {
+		auto runtimeDir = qEnvironmentVariable("XDG_RUNTIME_DIR");
+		if (runtimeDir.isEmpty()) {
+			runtimeDir = QString("/run/user/$1").arg(getuid());
+			qCInfo(logPaths) << "XDG_RUNTIME_DIR was not set, defaulting to" << runtimeDir;
+		}
+
+		this->mBaseRunDir = QDir(runtimeDir);
+		this->mBaseRunDir = QDir(this->mBaseRunDir.filePath("quickshell"));
+		qCDebug(logPaths) << "Initialized base runtime path:" << this->mBaseRunDir.path();
+
+		if (!this->mBaseRunDir.mkpath(".")) {
+			qCCritical(logPaths) << "Could not create base runtime directory at"
+			                     << this->mBaseRunDir.path();
+
+			this->baseRunState = DirState::Failed;
+		} else {
+			this->baseRunState = DirState::Ready;
+		}
+	}
+
+	if (this->baseRunState == DirState::Failed) return nullptr;
+	else return &this->mBaseRunDir;
+}
+
+QDir* QsPaths::shellRunDir() {
+	if (this->shellRunState == DirState::Unknown) {
+		if (auto* baseRunDir = this->baseRunDir()) {
+			this->mShellRunDir = QDir(baseRunDir->filePath("by-shell"));
+			this->mShellRunDir = QDir(this->mShellRunDir.filePath(this->shellId));
+
+			qCDebug(logPaths) << "Initialized runtime path:" << this->mShellRunDir.path();
+
+			if (!this->mShellRunDir.mkpath(".")) {
+				qCCritical(logPaths) << "Could not create runtime directory at"
+				                     << this->mShellRunDir.path();
+				this->shellRunState = DirState::Failed;
+			} else {
+				this->shellRunState = DirState::Ready;
+			}
+		} else {
+			qCCritical(logPaths) << "Could not create shell runtime path as it was not possible to "
+			                        "create the base runtime path.";
+
+			this->shellRunState = DirState::Failed;
+		}
+	}
+
+	if (this->shellRunState == DirState::Failed) return nullptr;
+	else return &this->mShellRunDir;
+}
+
+QDir* QsPaths::instanceRunDir() {
+	if (this->instanceRunState == DirState::Unknown) {
+		auto* runDir = this->baseRunDir();
+
+		if (!runDir) {
+			qCCritical(logPaths) << "Cannot create instance runtime directory as main runtim directory "
+			                        "could not be created.";
+			this->instanceRunState = DirState::Failed;
+		} else {
+			auto byIdDir = QDir(runDir->filePath("by-id"));
+
+			this->mInstanceRunDir = byIdDir.filePath(InstanceInfo::CURRENT.instanceId);
+
+			qCDebug(logPaths) << "Initialized instance runtime path:" << this->mInstanceRunDir.path();
+
+			if (!this->mInstanceRunDir.mkpath(".")) {
+				qCCritical(logPaths) << "Could not create instance runtime directory at"
+				                     << this->mInstanceRunDir.path();
+				this->instanceRunState = DirState::Failed;
+			} else {
+				this->instanceRunState = DirState::Ready;
+			}
+		}
+	}
+
+	if (this->shellRunState == DirState::Failed) return nullptr;
+	else return &this->mInstanceRunDir;
+}
+
+QDir* QsPaths::shellVfsDir() {
+	if (this->shellVfsState == DirState::Unknown) {
+		if (auto* baseRunDir = this->baseRunDir()) {
+			this->mShellVfsDir = QDir(baseRunDir->filePath("vfs"));
+			this->mShellVfsDir = QDir(this->mShellVfsDir.filePath(this->shellId));
+
+			qCDebug(logPaths) << "Initialized runtime vfs path:" << this->mShellVfsDir.path();
+
+			if (!this->mShellVfsDir.mkpath(".")) {
+				qCCritical(logPaths) << "Could not create runtime vfs directory at"
+				                     << this->mShellVfsDir.path();
+				this->shellVfsState = DirState::Failed;
+			} else {
+				this->shellVfsState = DirState::Ready;
+			}
+		} else {
+			qCCritical(logPaths) << "Could not create shell runtime vfs path as it was not possible to "
+			                        "create the base runtime path.";
+
+			this->shellVfsState = DirState::Failed;
+		}
+	}
+
+	if (this->shellVfsState == DirState::Failed) return nullptr;
+	else return &this->mShellVfsDir;
+}
+
+void QsPaths::linkRunDir() {
+	if (auto* runDir = this->instanceRunDir()) {
+		auto pidDir = QDir(this->baseRunDir()->filePath("by-pid"));
+		auto* shellDir = this->shellRunDir();
+
+		if (!shellDir) {
+			qCCritical(logPaths
+			) << "Could not create by-id symlink as the shell runtime path could not be created.";
+		} else {
+			auto shellPath = shellDir->filePath(runDir->dirName());
+
+			QFile::remove(shellPath);
+			auto r =
+			    symlinkat(runDir->filesystemCanonicalPath().c_str(), 0, shellPath.toStdString().c_str());
+
+			if (r != 0) {
+				qCCritical(logPaths).nospace()
+				    << "Could not create id symlink to " << runDir->path() << " at " << shellPath
+				    << " with error code " << errno << ": " << qt_error_string();
+			} else {
+				qCDebug(logPaths) << "Created shellid symlink" << shellPath << "to instance runtime path"
+				                  << runDir->path();
+			}
+		}
+
+		if (!pidDir.mkpath(".")) {
+			qCCritical(logPaths) << "Could not create PID symlink directory.";
+		} else {
+			auto pidPath = pidDir.filePath(QString::number(getpid()));
+
+			QFile::remove(pidPath);
+			auto r =
+			    symlinkat(runDir->filesystemCanonicalPath().c_str(), 0, pidPath.toStdString().c_str());
+
+			if (r != 0) {
+				qCCritical(logPaths).nospace()
+				    << "Could not create PID symlink to " << runDir->path() << " at " << pidPath
+				    << " with error code " << errno << ": " << qt_error_string();
+			} else {
+				qCDebug(logPaths) << "Created PID symlink" << pidPath << "to instance runtime path"
+				                  << runDir->path();
+			}
+		}
+	} else {
+		qCCritical(logPaths) << "Could not create PID symlink to runtime directory, as the runtime "
+		                        "directory could not be created.";
+	}
+}
+
+void QsPaths::linkPathDir() {
+	if (auto* runDir = this->shellRunDir()) {
+		auto pathDir = QDir(this->baseRunDir()->filePath("by-path"));
+
+		if (!pathDir.mkpath(".")) {
+			qCCritical(logPaths) << "Could not create path symlink directory.";
+			return;
+		}
+
+		auto linkPath = pathDir.filePath(this->pathId);
+
+		QFile::remove(linkPath);
+		auto r =
+		    symlinkat(runDir->filesystemCanonicalPath().c_str(), 0, linkPath.toStdString().c_str());
+
+		if (r != 0) {
+			qCCritical(logPaths).nospace()
+			    << "Could not create path symlink to " << runDir->path() << " at " << linkPath
+			    << " with error code " << errno << ": " << qt_error_string();
+		} else {
+			qCDebug(logPaths) << "Created path symlink" << linkPath << "to shell runtime path"
+			                  << runDir->path();
+		}
+	} else {
+		qCCritical(logPaths) << "Could not create path symlink to shell runtime directory, as the "
+		                        "shell runtime directory could not be created.";
+	}
+}
+
+QDir QsPaths::shellDataDir() {
+	if (this->shellDataState == DirState::Unknown) {
+		QDir dir;
+		if (this->shellDataOverride.isEmpty()) {
+			dir = QDir(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation));
+			dir = QDir(dir.filePath("by-shell"));
+			dir = QDir(dir.filePath(this->shellId));
+		} else {
+			auto basedir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation);
+			dir = QDir(this->shellDataOverride.replace("$BASE", basedir));
+		}
+
+		this->mShellDataDir = dir;
+
+		qCDebug(logPaths) << "Initialized data path:" << dir.path();
+
+		if (!dir.mkpath(".")) {
+			qCCritical(logPaths) << "Could not create data directory at" << dir.path();
+
+			this->shellDataState = DirState::Failed;
+		} else {
+			this->shellDataState = DirState::Ready;
+		}
+	}
+
+	// Returning no path on fail might result in files being written in unintended locations.
+	return this->mShellDataDir;
+}
+
+QDir QsPaths::shellStateDir() {
+	if (this->shellStateState == DirState::Unknown) {
+#if QT_VERSION < QT_VERSION_CHECK(6, 7, 0)
+		QDir dir;
+		if (qEnvironmentVariableIsSet("XDG_STATE_HOME")) {
+			dir = QDir(qEnvironmentVariable("XDG_STATE_HOME"));
+		} else {
+			auto home = QDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
+			dir = QDir(home.filePath(".local/state"));
+		}
+
+		if (this->shellStateOverride.isEmpty()) {
+			dir = QDir(dir.filePath("quickshell/by-shell"));
+			dir = QDir(dir.filePath(this->shellId));
+		} else {
+			dir = QDir(this->shellStateOverride.replace("$BASE", dir.path()));
+		}
+#else
+		QDir dir;
+		if (this->shellStateOverride.isEmpty()) {
+			dir = QDir(QStandardPaths::writableLocation(QStandardPaths::StateLocation));
+			dir = QDir(dir.filePath("by-shell"));
+			dir = QDir(dir.filePath(this->shellId));
+		} else {
+			auto basedir = QStandardPaths::writableLocation(QStandardPaths::GenericStateLocation);
+			dir = QDir(this->shellStateOverride.replace("$BASE", basedir));
+		}
+#endif
+		this->mShellStateDir = dir;
+
+		qCDebug(logPaths) << "Initialized state path:" << dir.path();
+
+		if (!dir.mkpath(".")) {
+			qCCritical(logPaths) << "Could not create state directory at" << dir.path();
+
+			this->shellStateState = DirState::Failed;
+		} else {
+			this->shellStateState = DirState::Ready;
+		}
+	}
+
+	// Returning no path on fail might result in files being written in unintended locations.
+	return this->mShellStateDir;
+}
+
+QDir QsPaths::shellCacheDir() {
+	if (this->shellCacheState == DirState::Unknown) {
+		auto dir = QDir(QStandardPaths::writableLocation(QStandardPaths::CacheLocation));
+		dir = QDir(dir.filePath("by-shell"));
+		dir = QDir(dir.filePath(this->shellId));
+		this->mShellCacheDir = dir;
+
+		qCDebug(logPaths) << "Initialized cache path:" << dir.path();
+
+		if (!dir.mkpath(".")) {
+			qCCritical(logPaths) << "Could not create cache directory at" << dir.path();
+
+			this->shellCacheState = DirState::Failed;
+		} else {
+			this->shellCacheState = DirState::Ready;
+		}
+	}
+
+	// Returning no path on fail might result in files being written in unintended locations.
+	return this->mShellCacheDir;
+}
+
+void QsPaths::createLock() {
+	if (auto* runDir = this->instanceRunDir()) {
+		auto path = runDir->filePath("instance.lock");
+		auto* file = new QFile(path); // leaked
+
+		if (!file->open(QFile::ReadWrite | QFile::Truncate)) {
+			qCCritical(logPaths) << "Could not create instance lock at" << path;
+			return;
+		}
+
+		auto lock = flock {
+		    .l_type = F_WRLCK,
+		    .l_whence = SEEK_SET,
+		    .l_start = 0,
+		    .l_len = 0,
+		    .l_pid = 0,
+		};
+
+		if (fcntl(file->handle(), F_SETLK, &lock) != 0) { // NOLINT
+			qCCritical(logPaths).nospace() << "Could not lock instance lock at " << path
+			                               << " with error code " << errno << ": " << qt_error_string();
+		} else {
+			auto stream = QDataStream(file);
+			stream << InstanceInfo::CURRENT;
+			file->flush();
+			qCDebug(logPaths) << "Created instance lock at" << path;
+		}
+	} else {
+		qCCritical(logPaths
+		) << "Could not create instance lock, as the instance runtime directory could not be created.";
+	}
+}
+
+bool QsPaths::checkLock(const QString& path, InstanceLockInfo* info, bool allowDead) {
+	auto file = QFile(QDir(path).filePath("instance.lock"));
+	if (!file.open(QFile::ReadOnly)) return false;
+
+	auto lock = flock {
+	    .l_type = F_WRLCK,
+	    .l_whence = SEEK_SET,
+	    .l_start = 0,
+	    .l_len = 0,
+	    .l_pid = 0,
+	};
+
+	fcntl(file.handle(), F_GETLK, &lock); // NOLINT
+	auto isLocked = lock.l_type != F_UNLCK;
+
+	if (!isLocked && !allowDead) return false;
+
+	if (info) {
+		info->pid = isLocked ? lock.l_pid : -1;
+
+		auto stream = QDataStream(&file);
+		stream >> info->instance;
+	}
+
+	return true;
+}
+
+QPair<QVector<InstanceLockInfo>, QVector<InstanceLockInfo>>
+QsPaths::collectInstances(const QString& path) {
+	qCDebug(logPaths) << "Collecting instances from" << path;
+	auto liveInstances = QVector<InstanceLockInfo>();
+	auto deadInstances = QVector<InstanceLockInfo>();
+	auto dir = QDir(path);
+
+	InstanceLockInfo info;
+	for (auto& entry: dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot)) {
+		auto path = dir.filePath(entry);
+
+		if (QsPaths::checkLock(path, &info, true)) {
+			qCDebug(logPaths).nospace() << "Found instance " << info.instance.instanceId << " (pid "
+			                            << info.pid << ") at " << path;
+
+			if (info.pid == -1) {
+				deadInstances.push_back(info);
+			} else {
+				liveInstances.push_back(info);
+			}
+		} else {
+			qCDebug(logPaths) << "Skipped potential instance at" << path;
+		}
+	}
+
+	return qMakePair(liveInstances, deadInstances);
+}
diff --git a/src/core/paths.hpp b/src/core/paths.hpp
new file mode 100644
index 00000000..178bcda1
--- /dev/null
+++ b/src/core/paths.hpp
@@ -0,0 +1,68 @@
+#pragma once
+#include <qdatetime.h>
+#include <qdir.h>
+#include <qpair.h>
+#include <qtypes.h>
+
+#include "instanceinfo.hpp"
+
+struct InstanceLockInfo {
+	pid_t pid = -1;
+	InstanceInfo instance;
+};
+
+QDataStream& operator<<(QDataStream& stream, const InstanceLockInfo& info);
+QDataStream& operator>>(QDataStream& stream, InstanceLockInfo& info);
+
+class QsPaths {
+public:
+	static QsPaths* instance();
+	static void init(QString shellId, QString pathId, QString dataOverride, QString stateOverride);
+	static QDir crashDir(const QString& id);
+	static QString basePath(const QString& id);
+	static QString ipcPath(const QString& id);
+	static bool
+	checkLock(const QString& path, InstanceLockInfo* info = nullptr, bool allowDead = false);
+	static QPair<QVector<InstanceLockInfo>, QVector<InstanceLockInfo>>
+	collectInstances(const QString& path);
+
+	QDir* baseRunDir();
+	QDir* shellRunDir();
+	QDir* shellVfsDir();
+	QDir* instanceRunDir();
+	void linkRunDir();
+	void linkPathDir();
+	void createLock();
+
+	QDir shellDataDir();
+	QDir shellStateDir();
+	QDir shellCacheDir();
+
+private:
+	enum class DirState : quint8 {
+		Unknown = 0,
+		Ready = 1,
+		Failed = 2,
+	};
+
+	QString shellId;
+	QString pathId;
+	QDir mBaseRunDir;
+	QDir mShellRunDir;
+	QDir mShellVfsDir;
+	QDir mInstanceRunDir;
+	DirState baseRunState = DirState::Unknown;
+	DirState shellRunState = DirState::Unknown;
+	DirState shellVfsState = DirState::Unknown;
+	DirState instanceRunState = DirState::Unknown;
+
+	QDir mShellDataDir;
+	QDir mShellStateDir;
+	QDir mShellCacheDir;
+	DirState shellDataState = DirState::Unknown;
+	DirState shellStateState = DirState::Unknown;
+	DirState shellCacheState = DirState::Unknown;
+
+	QString shellDataOverride;
+	QString shellStateOverride;
+};
diff --git a/src/core/platformmenu.cpp b/src/core/platformmenu.cpp
new file mode 100644
index 00000000..427dde08
--- /dev/null
+++ b/src/core/platformmenu.cpp
@@ -0,0 +1,324 @@
+#include "platformmenu.hpp"
+#include <functional>
+#include <utility>
+
+#include <qaction.h>
+#include <qactiongroup.h>
+#include <qapplication.h>
+#include <qcontainerfwd.h>
+#include <qcoreapplication.h>
+#include <qicon.h>
+#include <qlogging.h>
+#include <qmenu.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qpoint.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+#include <qwindow.h>
+
+#include "../window/proxywindow.hpp"
+#include "../window/windowinterface.hpp"
+#include "iconprovider.hpp"
+#include "model.hpp"
+#include "platformmenu_p.hpp"
+#include "popupanchor.hpp"
+#include "qsmenu.hpp"
+
+namespace qs::menu::platform {
+
+namespace {
+QVector<std::function<void(PlatformMenuQMenu*)>> CREATION_HOOKS; // NOLINT
+PlatformMenuQMenu* ACTIVE_MENU = nullptr;                        // NOLINT
+} // namespace
+
+PlatformMenuQMenu::~PlatformMenuQMenu() {
+	if (this == ACTIVE_MENU) {
+		ACTIVE_MENU = nullptr;
+	}
+}
+
+void PlatformMenuQMenu::setVisible(bool visible) {
+	if (visible) {
+		for (auto& hook: CREATION_HOOKS) {
+			hook(this);
+		}
+	} else {
+		if (this == ACTIVE_MENU) {
+			ACTIVE_MENU = nullptr;
+		}
+	}
+
+	this->QMenu::setVisible(visible);
+}
+
+PlatformMenuEntry::PlatformMenuEntry(QsMenuEntry* menu): QObject(menu), menu(menu) {
+	this->relayout();
+
+	// clang-format off
+	QObject::connect(menu, &QsMenuEntry::enabledChanged, this, &PlatformMenuEntry::onEnabledChanged);
+	QObject::connect(menu, &QsMenuEntry::textChanged, this, &PlatformMenuEntry::onTextChanged);
+	QObject::connect(menu, &QsMenuEntry::iconChanged, this, &PlatformMenuEntry::onIconChanged);
+	QObject::connect(menu, &QsMenuEntry::buttonTypeChanged, this, &PlatformMenuEntry::onButtonTypeChanged);
+	QObject::connect(menu, &QsMenuEntry::checkStateChanged, this, &PlatformMenuEntry::onCheckStateChanged);
+	QObject::connect(menu, &QsMenuEntry::hasChildrenChanged, this, &PlatformMenuEntry::relayoutParent);
+	QObject::connect(menu->children(), &UntypedObjectModel::valuesChanged, this, &PlatformMenuEntry::relayout);
+	// clang-format on
+}
+
+PlatformMenuEntry::~PlatformMenuEntry() {
+	this->clearChildren();
+	delete this->qaction;
+	delete this->qmenu;
+}
+
+void PlatformMenuEntry::registerCreationHook(std::function<void(PlatformMenuQMenu*)> hook) {
+	CREATION_HOOKS.push_back(std::move(hook));
+}
+
+bool PlatformMenuEntry::display(QObject* parentWindow, int relativeX, int relativeY) {
+	QWindow* window = nullptr;
+
+	if (qobject_cast<QApplication*>(QCoreApplication::instance()) == nullptr) {
+		qCritical() << "Cannot display PlatformMenuEntry as quickshell was not started in "
+		               "QApplication mode.";
+		qCritical() << "To use platform menus, add `//@ pragma UseQApplication` to the top of your "
+		               "root QML file and restart quickshell.";
+		return false;
+	} else if (this->qmenu == nullptr) {
+		qCritical() << "Cannot display PlatformMenuEntry as it is not a menu.";
+		return false;
+	} else if (parentWindow == nullptr) {
+		qCritical() << "Cannot display PlatformMenuEntry with null parent window.";
+		return false;
+	} else if (auto* proxy = qobject_cast<ProxyWindowBase*>(parentWindow)) {
+		window = proxy->backingWindow();
+	} else if (auto* interface = qobject_cast<WindowInterface*>(parentWindow)) {
+		window = interface->proxyWindow()->backingWindow();
+	} else {
+		qCritical() << "PlatformMenuEntry.display() must be called with a window.";
+		return false;
+	}
+
+	if (window == nullptr) {
+		qCritical() << "Cannot display PlatformMenuEntry from a parent window that is not visible.";
+		return false;
+	}
+
+	if (ACTIVE_MENU && this->qmenu != ACTIVE_MENU) {
+		ACTIVE_MENU->close();
+	}
+
+	ACTIVE_MENU = this->qmenu;
+
+	auto point = window->mapToGlobal(QPoint(relativeX, relativeY));
+
+	this->qmenu->createWinId();
+	this->qmenu->windowHandle()->setTransientParent(window);
+
+	// Skips screen edge repositioning so it can be left to the compositor on wayland.
+	this->qmenu->targetPosition = point;
+	this->qmenu->popup(point);
+
+	return true;
+}
+
+bool PlatformMenuEntry::display(PopupAnchor* anchor) {
+	if (qobject_cast<QApplication*>(QCoreApplication::instance()) == nullptr) {
+		qCritical() << "Cannot display PlatformMenuEntry as quickshell was not started in "
+		               "QApplication mode.";
+		qCritical() << "To use platform menus, add `//@ pragma UseQApplication` to the top of your "
+		               "root QML file and restart quickshell.";
+		return false;
+	} else if (!anchor->backingWindow() || !anchor->backingWindow()->isVisible()) {
+		qCritical() << "Cannot display PlatformMenuEntry on anchor without visible window.";
+		return false;
+	}
+
+	if (ACTIVE_MENU && this->qmenu != ACTIVE_MENU) {
+		ACTIVE_MENU->close();
+	}
+
+	ACTIVE_MENU = this->qmenu;
+
+	this->qmenu->createWinId();
+	this->qmenu->windowHandle()->setTransientParent(anchor->backingWindow());
+
+	// Update the window geometry to the menu's actual dimensions so reposition
+	// can accurately adjust it if applicable for the current platform.
+	this->qmenu->windowHandle()->setGeometry({{0, 0}, this->qmenu->sizeHint()});
+
+	PopupPositioner::instance()->reposition(anchor, this->qmenu->windowHandle(), false);
+
+	// Open the menu at the position determined by the popup positioner.
+	this->qmenu->popup(this->qmenu->windowHandle()->position());
+
+	return true;
+}
+
+void PlatformMenuEntry::relayout() {
+	if (qobject_cast<QApplication*>(QCoreApplication::instance()) == nullptr) {
+		return;
+	}
+
+	if (this->menu->hasChildren()) {
+		delete this->qaction;
+		this->qaction = nullptr;
+
+		if (this->qmenu == nullptr) {
+			this->qmenu = new PlatformMenuQMenu();
+			QObject::connect(this->qmenu, &QMenu::aboutToShow, this, &PlatformMenuEntry::onAboutToShow);
+			QObject::connect(this->qmenu, &QMenu::aboutToHide, this, &PlatformMenuEntry::onAboutToHide);
+		} else {
+			this->clearChildren();
+		}
+
+		this->qmenu->setTitle(this->menu->text());
+
+		auto icon = this->menu->icon();
+		if (!icon.isEmpty()) {
+			this->qmenu->setIcon(getCurrentEngineImageAsIcon(icon));
+		}
+
+		const auto& children = this->menu->children()->valueList();
+		auto len = children.count();
+		for (auto i = 0; i < len; i++) {
+			auto* child = children.at(i);
+
+			auto* instance = new PlatformMenuEntry(child);
+			QObject::connect(instance, &QObject::destroyed, this, &PlatformMenuEntry::onChildDestroyed);
+
+			QObject::connect(
+			    instance,
+			    &PlatformMenuEntry::relayoutParent,
+			    this,
+			    &PlatformMenuEntry::relayout
+			);
+
+			this->childEntries.push_back(instance);
+			instance->addToQMenu(this->qmenu);
+		}
+	} else if (!this->menu->isSeparator()) {
+		this->clearChildren();
+		delete this->qmenu;
+		this->qmenu = nullptr;
+
+		if (this->qaction == nullptr) {
+			this->qaction = new QAction(this);
+
+			QObject::connect(
+			    this->qaction,
+			    &QAction::triggered,
+			    this,
+			    &PlatformMenuEntry::onActionTriggered
+			);
+		}
+
+		this->qaction->setText(this->menu->text());
+
+		auto icon = this->menu->icon();
+		if (!icon.isEmpty()) {
+			this->qaction->setIcon(getCurrentEngineImageAsIcon(icon));
+		}
+
+		this->qaction->setEnabled(this->menu->enabled());
+		this->qaction->setCheckable(this->menu->buttonType() != QsMenuButtonType::None);
+
+		if (this->menu->buttonType() == QsMenuButtonType::RadioButton) {
+			if (!this->qactiongroup) this->qactiongroup = new QActionGroup(this);
+			this->qaction->setActionGroup(this->qactiongroup);
+		}
+
+		this->qaction->setChecked(this->menu->checkState() != Qt::Unchecked);
+	} else {
+		delete this->qmenu;
+		delete this->qaction;
+		this->qmenu = nullptr;
+		this->qaction = nullptr;
+	}
+}
+
+void PlatformMenuEntry::onAboutToShow() { this->menu->ref(); }
+
+void PlatformMenuEntry::onAboutToHide() {
+	this->menu->unref();
+	emit this->closed();
+}
+
+void PlatformMenuEntry::onActionTriggered() {
+	auto* action = qobject_cast<PlatformMenuEntry*>(this->sender()->parent());
+	emit action->menu->triggered();
+}
+
+void PlatformMenuEntry::onChildDestroyed() { this->childEntries.removeOne(this->sender()); }
+
+void PlatformMenuEntry::onEnabledChanged() {
+	if (this->qaction != nullptr) {
+		this->qaction->setEnabled(this->menu->enabled());
+	}
+}
+
+void PlatformMenuEntry::onTextChanged() {
+	if (this->qmenu != nullptr) {
+		this->qmenu->setTitle(this->menu->text());
+	} else if (this->qaction != nullptr) {
+		this->qaction->setText(this->menu->text());
+	}
+}
+
+void PlatformMenuEntry::onIconChanged() {
+	if (this->qmenu == nullptr && this->qaction == nullptr) return;
+
+	auto iconName = this->menu->icon();
+	QIcon icon;
+
+	if (!iconName.isEmpty()) {
+		icon = getCurrentEngineImageAsIcon(iconName);
+	}
+
+	if (this->qmenu != nullptr) {
+		this->qmenu->setIcon(icon);
+	} else if (this->qaction != nullptr) {
+		this->qaction->setIcon(icon);
+	}
+}
+
+void PlatformMenuEntry::onButtonTypeChanged() {
+	if (this->qaction != nullptr) {
+		QActionGroup* group = nullptr;
+
+		if (this->menu->buttonType() == QsMenuButtonType::RadioButton) {
+			if (!this->qactiongroup) this->qactiongroup = new QActionGroup(this);
+			group = this->qactiongroup;
+		}
+
+		this->qaction->setActionGroup(group);
+	}
+}
+
+void PlatformMenuEntry::onCheckStateChanged() {
+	if (this->qaction != nullptr) {
+		this->qaction->setChecked(this->menu->checkState() != Qt::Unchecked);
+	}
+}
+
+void PlatformMenuEntry::clearChildren() {
+	for (auto* child: this->childEntries) {
+		delete child;
+	}
+
+	this->childEntries.clear();
+}
+
+void PlatformMenuEntry::addToQMenu(PlatformMenuQMenu* menu) {
+	if (this->qmenu != nullptr) {
+		menu->addMenu(this->qmenu);
+		this->qmenu->containingMenu = menu;
+	} else if (this->qaction != nullptr) {
+		menu->addAction(this->qaction);
+	} else {
+		menu->addSeparator();
+	}
+}
+
+} // namespace qs::menu::platform
diff --git a/src/core/platformmenu.hpp b/src/core/platformmenu.hpp
new file mode 100644
index 00000000..5979f90e
--- /dev/null
+++ b/src/core/platformmenu.hpp
@@ -0,0 +1,63 @@
+#pragma once
+
+#include <functional>
+
+#include <qaction.h>
+#include <qactiongroup.h>
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qqmllist.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+
+#include "../core/popupanchor.hpp"
+#include "qsmenu.hpp"
+
+namespace qs::menu::platform {
+
+class PlatformMenuQMenu;
+
+class PlatformMenuEntry: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit PlatformMenuEntry(QsMenuEntry* menu);
+	~PlatformMenuEntry() override;
+	Q_DISABLE_COPY_MOVE(PlatformMenuEntry);
+
+	bool display(QObject* parentWindow, int relativeX, int relativeY);
+	bool display(PopupAnchor* anchor);
+
+	static void registerCreationHook(std::function<void(PlatformMenuQMenu*)> hook);
+
+signals:
+	void closed();
+	void relayoutParent();
+
+public slots:
+	void relayout();
+
+private slots:
+	void onAboutToShow();
+	void onAboutToHide();
+	void onActionTriggered();
+	void onChildDestroyed();
+	void onEnabledChanged();
+	void onTextChanged();
+	void onIconChanged();
+	void onButtonTypeChanged();
+	void onCheckStateChanged();
+
+private:
+	void clearChildren();
+	void addToQMenu(PlatformMenuQMenu* menu);
+
+	QsMenuEntry* menu;
+	PlatformMenuQMenu* qmenu = nullptr;
+	QAction* qaction = nullptr;
+	QActionGroup* qactiongroup = nullptr;
+	QVector<PlatformMenuEntry*> childEntries;
+};
+
+} // namespace qs::menu::platform
diff --git a/src/core/platformmenu_p.hpp b/src/core/platformmenu_p.hpp
new file mode 100644
index 00000000..9109959d
--- /dev/null
+++ b/src/core/platformmenu_p.hpp
@@ -0,0 +1,19 @@
+#pragma once
+#include <qmenu.h>
+#include <qpoint.h>
+
+namespace qs::menu::platform {
+
+class PlatformMenuQMenu: public QMenu {
+public:
+	explicit PlatformMenuQMenu() = default;
+	~PlatformMenuQMenu() override;
+	Q_DISABLE_COPY_MOVE(PlatformMenuQMenu);
+
+	void setVisible(bool visible) override;
+
+	PlatformMenuQMenu* containingMenu = nullptr;
+	QPoint targetPosition;
+};
+
+} // namespace qs::menu::platform
diff --git a/src/core/plugin.cpp b/src/core/plugin.cpp
index 21312de1..0eb9a067 100644
--- a/src/core/plugin.cpp
+++ b/src/core/plugin.cpp
@@ -3,31 +3,36 @@
 
 #include <qvector.h> // NOLINT (what??)
 
-static QVector<QuickshellPlugin*> plugins; // NOLINT
+#include "generation.hpp"
 
-void QuickshellPlugin::registerPlugin(QuickshellPlugin& plugin) { plugins.push_back(&plugin); }
+static QVector<QsEnginePlugin*> plugins; // NOLINT
 
-void QuickshellPlugin::initPlugins() {
-	plugins.erase(
-	    std::remove_if(
-	        plugins.begin(),
-	        plugins.end(),
-	        [](QuickshellPlugin* plugin) { return !plugin->applies(); }
-	    ),
-	    plugins.end()
-	);
+void QsEnginePlugin::registerPlugin(QsEnginePlugin& plugin) { plugins.push_back(&plugin); }
 
-	for (QuickshellPlugin* plugin: plugins) {
+void QsEnginePlugin::initPlugins() {
+	plugins.removeIf([](QsEnginePlugin* plugin) { return !plugin->applies(); });
+
+	std::ranges::sort(plugins, [](QsEnginePlugin* a, QsEnginePlugin* b) {
+		return b->dependencies().contains(a->name());
+	});
+
+	for (QsEnginePlugin* plugin: plugins) {
 		plugin->init();
 	}
 
-	for (QuickshellPlugin* plugin: plugins) {
+	for (QsEnginePlugin* plugin: plugins) {
 		plugin->registerTypes();
 	}
 }
 
-void QuickshellPlugin::runOnReload() {
-	for (QuickshellPlugin* plugin: plugins) {
+void QsEnginePlugin::runConstructGeneration(EngineGeneration& generation) {
+	for (QsEnginePlugin* plugin: plugins) {
+		plugin->constructGeneration(generation);
+	}
+}
+
+void QsEnginePlugin::runOnReload() {
+	for (QsEnginePlugin* plugin: plugins) {
 		plugin->onReload();
 	}
 }
diff --git a/src/core/plugin.hpp b/src/core/plugin.hpp
index 8a3719b1..f0c14dce 100644
--- a/src/core/plugin.hpp
+++ b/src/core/plugin.hpp
@@ -2,23 +2,30 @@
 
 #include <qcontainerfwd.h>
 #include <qfunctionpointer.h>
+#include <qlist.h>
 
-class QuickshellPlugin {
+class EngineGeneration;
+
+class QsEnginePlugin {
 public:
-	QuickshellPlugin() = default;
-	virtual ~QuickshellPlugin() = default;
-	QuickshellPlugin(QuickshellPlugin&&) = delete;
-	QuickshellPlugin(const QuickshellPlugin&) = delete;
-	void operator=(QuickshellPlugin&&) = delete;
-	void operator=(const QuickshellPlugin&) = delete;
+	QsEnginePlugin() = default;
+	virtual ~QsEnginePlugin() = default;
+	QsEnginePlugin(QsEnginePlugin&&) = delete;
+	QsEnginePlugin(const QsEnginePlugin&) = delete;
+	void operator=(QsEnginePlugin&&) = delete;
+	void operator=(const QsEnginePlugin&) = delete;
 
+	virtual QString name() { return QString(); }
+	virtual QList<QString> dependencies() { return {}; }
 	virtual bool applies() { return true; }
 	virtual void init() {}
 	virtual void registerTypes() {}
+	virtual void constructGeneration(EngineGeneration& /*unused*/) {} // NOLINT
 	virtual void onReload() {}
 
-	static void registerPlugin(QuickshellPlugin& plugin);
+	static void registerPlugin(QsEnginePlugin& plugin);
 	static void initPlugins();
+	static void runConstructGeneration(EngineGeneration& generation);
 	static void runOnReload();
 };
 
@@ -26,6 +33,6 @@ public:
 #define QS_REGISTER_PLUGIN(clazz)                                                                  \
 	[[gnu::constructor]] void qsInitPlugin() {                                                       \
 		static clazz plugin;                                                                           \
-		QuickshellPlugin::registerPlugin(plugin);                                                      \
+		QsEnginePlugin::registerPlugin(plugin);                                                        \
 	}
 // NOLINTEND
diff --git a/src/core/popupanchor.cpp b/src/core/popupanchor.cpp
new file mode 100644
index 00000000..bbcc3a5f
--- /dev/null
+++ b/src/core/popupanchor.cpp
@@ -0,0 +1,386 @@
+#include "popupanchor.hpp"
+#include <algorithm>
+
+#include <qcontainerfwd.h>
+#include <qlogging.h>
+#include <qobject.h>
+#include <qquickitem.h>
+#include <qsize.h>
+#include <qtmetamacros.h>
+#include <qvectornd.h>
+#include <qwindow.h>
+
+#include "../window/proxywindow.hpp"
+#include "../window/windowinterface.hpp"
+#include "types.hpp"
+
+bool PopupAnchorState::operator==(const PopupAnchorState& other) const {
+	return this->rect == other.rect && this->edges == other.edges && this->gravity == other.gravity
+	    && this->adjustment == other.adjustment && this->anchorpoint == other.anchorpoint
+	    && this->size == other.size;
+}
+
+bool PopupAnchor::isDirty() const {
+	return !this->lastState.has_value() || this->state != this->lastState.value();
+}
+
+void PopupAnchor::markClean() { this->lastState = this->state; }
+void PopupAnchor::markDirty() { this->lastState.reset(); }
+
+QWindow* PopupAnchor::backingWindow() const {
+	return this->mProxyWindow ? this->mProxyWindow->backingWindow() : nullptr;
+}
+
+void PopupAnchor::setWindowInternal(QObject* window) {
+	if (window == this->mWindow) return;
+
+	if (this->mWindow) {
+		QObject::disconnect(this->mWindow, nullptr, this, nullptr);
+		QObject::disconnect(this->mProxyWindow, nullptr, this, nullptr);
+	}
+
+	if (window) {
+		if (auto* proxy = qobject_cast<ProxyWindowBase*>(window)) {
+			this->mProxyWindow = proxy;
+		} else if (auto* interface = qobject_cast<WindowInterface*>(window)) {
+			this->mProxyWindow = interface->proxyWindow();
+		} else {
+			qWarning() << "Tried to set popup anchor window to" << window
+			           << "which is not a quickshell window.";
+			goto setnull;
+		}
+
+		this->mWindow = window;
+
+		QObject::connect(this->mWindow, &QObject::destroyed, this, &PopupAnchor::onWindowDestroyed);
+
+		QObject::connect(
+		    this->mProxyWindow,
+		    &ProxyWindowBase::backerVisibilityChanged,
+		    this,
+		    &PopupAnchor::backingWindowVisibilityChanged
+		);
+
+		emit this->windowChanged();
+		emit this->backingWindowVisibilityChanged();
+
+		return;
+	}
+
+setnull:
+	if (this->mWindow) {
+		this->mWindow = nullptr;
+		this->mProxyWindow = nullptr;
+
+		emit this->windowChanged();
+		emit this->backingWindowVisibilityChanged();
+	}
+}
+
+void PopupAnchor::setWindow(QObject* window) {
+	this->setItem(nullptr);
+	this->setWindowInternal(window);
+}
+
+void PopupAnchor::setItem(QQuickItem* item) {
+	if (item == this->mItem) return;
+
+	if (this->mItem) {
+		QObject::disconnect(this->mItem, nullptr, this, nullptr);
+	}
+
+	this->mItem = item;
+	this->onItemWindowChanged();
+
+	if (item) {
+		QObject::connect(item, &QObject::destroyed, this, &PopupAnchor::onItemDestroyed);
+		QObject::connect(item, &QQuickItem::windowChanged, this, &PopupAnchor::onItemWindowChanged);
+	}
+}
+
+void PopupAnchor::onWindowDestroyed() {
+	this->mWindow = nullptr;
+	this->mProxyWindow = nullptr;
+	emit this->windowChanged();
+	emit this->backingWindowVisibilityChanged();
+}
+
+void PopupAnchor::onItemDestroyed() {
+	this->mItem = nullptr;
+	emit this->itemChanged();
+	this->setWindowInternal(nullptr);
+}
+
+void PopupAnchor::onItemWindowChanged() {
+	if (auto* window = qobject_cast<ProxiedWindow*>(this->mItem->window())) {
+		this->setWindowInternal(window->proxy());
+	} else {
+		this->setWindowInternal(nullptr);
+	}
+}
+
+void PopupAnchor::setRect(Box rect) {
+	if (rect.w <= 0) rect.w = 1;
+	if (rect.h <= 0) rect.h = 1;
+	if (rect == this->mUserRect) return;
+
+	this->mUserRect = rect;
+	emit this->rectChanged();
+
+	this->setWindowRect(rect.qrect().marginsRemoved(this->mMargins.qmargins()));
+}
+
+void PopupAnchor::setMargins(Margins margins) {
+	if (margins == this->mMargins) return;
+
+	this->mMargins = margins;
+	emit this->marginsChanged();
+
+	this->setWindowRect(this->mUserRect.qrect().marginsRemoved(margins.qmargins()));
+}
+
+void PopupAnchor::setWindowRect(QRect rect) {
+	if (rect.width() <= 0) rect.setWidth(1);
+	if (rect.height() <= 0) rect.setHeight(1);
+	if (rect == this->state.rect) return;
+
+	this->state.rect = rect;
+	emit this->windowRectChanged();
+}
+
+void PopupAnchor::resetRect() { this->mUserRect = Box(); }
+
+void PopupAnchor::setEdges(Edges::Flags edges) {
+	if (edges == this->state.edges) return;
+
+	if (Edges::isOpposing(edges)) {
+		qWarning() << "Cannot set opposing edges for anchor edges. Tried to set" << edges;
+		return;
+	}
+
+	this->state.edges = edges;
+	emit this->edgesChanged();
+}
+
+void PopupAnchor::setGravity(Edges::Flags gravity) {
+	if (gravity == this->state.gravity) return;
+
+	if (Edges::isOpposing(gravity)) {
+		qWarning() << "Cannot set opposing edges for anchor gravity. Tried to set" << gravity;
+		return;
+	}
+
+	this->state.gravity = gravity;
+	emit this->gravityChanged();
+}
+
+void PopupAnchor::setAdjustment(PopupAdjustment::Flags adjustment) {
+	if (adjustment == this->state.adjustment) return;
+	this->state.adjustment = adjustment;
+	emit this->adjustmentChanged();
+}
+
+void PopupAnchor::updatePlacement(const QPoint& anchorpoint, const QSize& size) {
+	this->state.anchorpoint = anchorpoint;
+	this->state.size = size;
+}
+
+void PopupAnchor::updateAnchor() {
+	if (this->mItem && this->mProxyWindow) {
+		auto baseRect =
+		    this->mUserRect.isEmpty() ? this->mItem->boundingRect() : this->mUserRect.qrect();
+
+		auto rect = this->mProxyWindow->contentItem()->mapFromItem(
+		    this->mItem,
+		    baseRect.marginsRemoved(this->mMargins.qmargins())
+		);
+
+		if (rect.width() < 1) rect.setWidth(1);
+		if (rect.height() < 1) rect.setHeight(1);
+
+		this->setWindowRect(rect.toRect());
+	}
+
+	emit this->anchoring();
+}
+
+static PopupPositioner* POSITIONER = nullptr; // NOLINT
+
+void PopupPositioner::reposition(PopupAnchor* anchor, QWindow* window, bool onlyIfDirty) {
+	auto* parentWindow = window->transientParent();
+	if (!parentWindow) {
+		qFatal() << "Cannot reposition popup that does not have a transient parent.";
+	}
+
+	auto parentGeometry = parentWindow->geometry();
+	auto windowGeometry = window->geometry();
+
+	anchor->updateAnchor();
+	anchor->updatePlacement(parentGeometry.topLeft(), windowGeometry.size());
+
+	if (onlyIfDirty && !anchor->isDirty()) return;
+	anchor->markClean();
+
+	auto adjustment = anchor->adjustment();
+	auto screenGeometry = parentWindow->screen()->geometry();
+	auto anchorRectGeometry = anchor->windowRect().translated(parentGeometry.topLeft());
+
+	auto anchorEdges = anchor->edges();
+	auto anchorGravity = anchor->gravity();
+
+	auto width = windowGeometry.width();
+	auto height = windowGeometry.height();
+
+	auto anchorX = anchorEdges.testFlag(Edges::Left)  ? anchorRectGeometry.left()
+	             : anchorEdges.testFlag(Edges::Right) ? anchorRectGeometry.right()
+	                                                  : anchorRectGeometry.center().x();
+
+	auto anchorY = anchorEdges.testFlag(Edges::Top)    ? anchorRectGeometry.top()
+	             : anchorEdges.testFlag(Edges::Bottom) ? anchorRectGeometry.bottom()
+	                                                   : anchorRectGeometry.center().y();
+
+	auto calcEffectiveX = [&](Edges::Flags anchorGravity, int anchorX) {
+		auto ex = anchorGravity.testFlag(Edges::Left)  ? anchorX - windowGeometry.width()
+		        : anchorGravity.testFlag(Edges::Right) ? anchorX - 1
+		                                               : anchorX - windowGeometry.width() / 2;
+
+		return ex + 1;
+	};
+
+	auto calcEffectiveY = [&](Edges::Flags anchorGravity, int anchorY) {
+		auto ey = anchorGravity.testFlag(Edges::Top)    ? anchorY - windowGeometry.height()
+		        : anchorGravity.testFlag(Edges::Bottom) ? anchorY - 1
+		                                                : anchorY - windowGeometry.height() / 2;
+
+		return ey + 1;
+	};
+
+	auto calcRemainingWidth = [&](int effectiveX) {
+		auto width = windowGeometry.width();
+		if (effectiveX < screenGeometry.left()) {
+			auto diff = screenGeometry.left() - effectiveX;
+			effectiveX = screenGeometry.left();
+			width -= diff;
+		}
+
+		auto effectiveX2 = effectiveX + width;
+		if (effectiveX2 > screenGeometry.right()) {
+			width -= effectiveX2 - screenGeometry.right() - 1;
+		}
+
+		return QPair<int, int>(effectiveX, width);
+	};
+
+	auto calcRemainingHeight = [&](int effectiveY) {
+		auto height = windowGeometry.height();
+		if (effectiveY < screenGeometry.left()) {
+			auto diff = screenGeometry.top() - effectiveY;
+			effectiveY = screenGeometry.top();
+			height -= diff;
+		}
+
+		auto effectiveY2 = effectiveY + height;
+		if (effectiveY2 > screenGeometry.bottom()) {
+			height -= effectiveY2 - screenGeometry.bottom() - 1;
+		}
+
+		return QPair<int, int>(effectiveY, height);
+	};
+
+	auto effectiveX = calcEffectiveX(anchorGravity, anchorX);
+	auto effectiveY = calcEffectiveY(anchorGravity, anchorY);
+
+	if (adjustment.testFlag(PopupAdjustment::FlipX)) {
+		const bool flip = (anchorGravity.testFlag(Edges::Left) && effectiveX < screenGeometry.left())
+		               || (anchorGravity.testFlag(Edges::Right)
+		                   && effectiveX + windowGeometry.width() > screenGeometry.right());
+
+		if (flip) {
+			auto newAnchorGravity = anchorGravity ^ (Edges::Left | Edges::Right);
+
+			auto newAnchorX = anchorEdges.testFlags(Edges::Left)  ? anchorRectGeometry.right()
+			                : anchorEdges.testFlags(Edges::Right) ? anchorRectGeometry.left()
+			                                                      : anchorX;
+
+			auto newEffectiveX = calcEffectiveX(newAnchorGravity, newAnchorX);
+
+			// TODO IN HL: pick constraint monitor based on anchor rect position in window
+
+			// if the available width when flipped is more than the available width without flipping then flip
+			if (calcRemainingWidth(newEffectiveX).second > calcRemainingWidth(effectiveX).second) {
+				anchorGravity = newAnchorGravity;
+				anchorX = newAnchorX;
+				effectiveX = newEffectiveX;
+			}
+		}
+	}
+
+	if (adjustment.testFlag(PopupAdjustment::FlipY)) {
+		const bool flip = (anchorGravity.testFlag(Edges::Top) && effectiveY < screenGeometry.top())
+		               || (anchorGravity.testFlag(Edges::Bottom)
+		                   && effectiveY + windowGeometry.height() > screenGeometry.bottom());
+
+		if (flip) {
+			auto newAnchorGravity = anchorGravity ^ (Edges::Top | Edges::Bottom);
+
+			auto newAnchorY = anchorEdges.testFlags(Edges::Top)    ? anchorRectGeometry.bottom()
+			                : anchorEdges.testFlags(Edges::Bottom) ? anchorRectGeometry.top()
+			                                                       : anchorY;
+
+			auto newEffectiveY = calcEffectiveY(newAnchorGravity, newAnchorY);
+
+			// if the available width when flipped is more than the available width without flipping then flip
+			if (calcRemainingHeight(newEffectiveY).second > calcRemainingHeight(effectiveY).second) {
+				anchorGravity = newAnchorGravity;
+				anchorY = newAnchorY;
+				effectiveY = newEffectiveY;
+			}
+		}
+	}
+
+	// Slide order is important for the case where the window is too large to fit on screen.
+	if (adjustment.testFlag(PopupAdjustment::SlideX)) {
+		if (effectiveX + windowGeometry.width() > screenGeometry.right()) {
+			effectiveX = screenGeometry.right() - windowGeometry.width() + 1;
+		}
+
+		effectiveX = std::max(effectiveX, screenGeometry.left());
+	}
+
+	if (adjustment.testFlag(PopupAdjustment::SlideY)) {
+		if (effectiveY + windowGeometry.height() > screenGeometry.bottom()) {
+			effectiveY = screenGeometry.bottom() - windowGeometry.height() + 1;
+		}
+
+		effectiveY = std::max(effectiveY, screenGeometry.top());
+	}
+
+	if (adjustment.testFlag(PopupAdjustment::ResizeX)) {
+		auto [newX, newWidth] = calcRemainingWidth(effectiveX);
+		effectiveX = newX;
+		width = newWidth;
+	}
+
+	if (adjustment.testFlag(PopupAdjustment::ResizeY)) {
+		auto [newY, newHeight] = calcRemainingHeight(effectiveY);
+		effectiveY = newY;
+		height = newHeight;
+	}
+
+	window->setGeometry({effectiveX, effectiveY, width, height});
+}
+
+bool PopupPositioner::shouldRepositionOnMove() const { return true; }
+
+PopupPositioner* PopupPositioner::instance() {
+	if (POSITIONER == nullptr) {
+		POSITIONER = new PopupPositioner();
+	}
+
+	return POSITIONER;
+}
+
+void PopupPositioner::setInstance(PopupPositioner* instance) {
+	delete POSITIONER;
+	POSITIONER = instance;
+}
diff --git a/src/core/popupanchor.hpp b/src/core/popupanchor.hpp
new file mode 100644
index 00000000..a9b121ed
--- /dev/null
+++ b/src/core/popupanchor.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <optional>
+
+#include <qflags.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qpoint.h>
+#include <qqmlintegration.h>
+#include <qquickitem.h>
+#include <qsize.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+#include <qvectornd.h>
+#include <qwindow.h>
+
+#include "../window/proxywindow.hpp"
+#include "doc.hpp"
+#include "types.hpp"
+
+///! Adjustment strategy for popups that do not fit on screen.
+/// Adjustment strategy for popups. See @@PopupAnchor.adjustment.
+///
+/// Adjustment flags can be combined with the `|` operator.
+///
+/// `Flip` will be applied first, then `Slide`, then `Resize`.
+namespace PopupAdjustment { // NOLINT
+Q_NAMESPACE;
+QML_ELEMENT;
+
+enum Enum : quint8 {
+	None = 0,
+	/// If the X axis is constrained, the popup will slide along the X axis until it fits onscreen.
+	SlideX = 1,
+	/// If the Y axis is constrained, the popup will slide along the Y axis until it fits onscreen.
+	SlideY = 2,
+	/// Alias for `SlideX | SlideY`.
+	Slide = SlideX | SlideY,
+	/// If the X axis is constrained, the popup will invert its horizontal gravity if any.
+	FlipX = 4,
+	/// If the Y axis is constrained, the popup will invert its vertical gravity if any.
+	FlipY = 8,
+	/// Alias for `FlipX | FlipY`.
+	Flip = FlipX | FlipY,
+	/// If the X axis is constrained, the width of the popup will be reduced to fit on screen.
+	ResizeX = 16,
+	/// If the Y axis is constrained, the height of the popup will be reduced to fit on screen.
+	ResizeY = 32,
+	/// Alias for `ResizeX | ResizeY`
+	Resize = ResizeX | ResizeY,
+	/// Alias for `Flip | Slide | Resize`.
+	All = Slide | Flip | Resize,
+};
+Q_ENUM_NS(Enum);
+Q_DECLARE_FLAGS(Flags, Enum);
+
+} // namespace PopupAdjustment
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(PopupAdjustment::Flags);
+
+struct PopupAnchorState {
+	bool operator==(const PopupAnchorState& other) const;
+
+	QRect rect = {0, 0, 1, 1};
+	Edges::Flags edges = Edges::Top | Edges::Left;
+	Edges::Flags gravity = Edges::Bottom | Edges::Right;
+	PopupAdjustment::Flags adjustment = PopupAdjustment::Slide;
+	QPoint anchorpoint;
+	QSize size;
+};
+
+///! Anchorpoint or positioner for popup windows.
+class PopupAnchor: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// The window to anchor / attach the popup to. Setting this property unsets @@item.
+	Q_PROPERTY(QObject* window READ window WRITE setWindow NOTIFY windowChanged);
+	/// The item to anchor / attach the popup to. Setting this property unsets @@window.
+	///
+	/// The popup's position relative to its parent window is only calculated when it is
+	/// initially shown (directly before @@anchoring(s) is emitted), meaning its anchor
+	/// rectangle will be set relative to the item's position in the window at that time.
+	/// @@updateAnchor() can be called to update the anchor rectangle if the item's position
+	/// has changed.
+	///
+	/// > [!NOTE] If a more flexible way to position a popup relative to an item is needed,
+	/// > set @@window to the item's parent window, and handle the @@anchoring signal to
+	/// > position the popup relative to the window's contentItem.
+	Q_PROPERTY(QQuickItem* item READ item WRITE setItem NOTIFY itemChanged);
+	/// The anchorpoints the popup will attach to, relative to @@item or @@window.
+	/// Which anchors will be used is determined by the @@edges, @@gravity, and @@adjustment.
+	///
+	/// If using @@item, the default anchor rectangle matches the dimensions of the item.
+	///
+	/// If you leave @@edges, @@gravity and @@adjustment at their default values,
+	/// setting more than `x` and `y` does not matter. The anchor rect cannot
+	/// be smaller than 1x1 pixels.
+	///
+	/// [coordinate mapping functions]: https://doc.qt.io/qt-6/qml-qtquick-item.html#mapFromItem-method
+	Q_PROPERTY(Box rect READ rect WRITE setRect RESET resetRect NOTIFY rectChanged);
+	/// A margin applied to the anchor rect.
+	///
+	/// This is most useful when @@item is used and @@rect is left at its default
+	/// value (matching the Item's dimensions).
+	Q_PROPERTY(Margins margins READ margins WRITE setMargins NOTIFY marginsChanged);
+	/// The point on the anchor rectangle the popup should anchor to.
+	/// Opposing edges suchs as `Edges.Left | Edges.Right` are not allowed.
+	///
+	/// Defaults to `Edges.Top | Edges.Left`.
+	Q_PROPERTY(Edges::Flags edges READ edges WRITE setEdges NOTIFY edgesChanged);
+	/// The direction the popup should expand towards, relative to the anchorpoint.
+	/// Opposing edges suchs as `Edges.Left | Edges.Right` are not allowed.
+	///
+	/// Defaults to `Edges.Bottom | Edges.Right`.
+	Q_PROPERTY(Edges::Flags gravity READ gravity WRITE setGravity NOTIFY gravityChanged);
+	/// The strategy used to adjust the popup's position if it would otherwise not fit on screen,
+	/// based on the anchor @@rect, preferred @@edges, and @@gravity.
+	///
+	/// See the documentation for @@PopupAdjustment for details.
+	Q_PROPERTY(PopupAdjustment::Flags adjustment READ adjustment WRITE setAdjustment NOTIFY adjustmentChanged);
+	// clang-format on
+	QML_ELEMENT;
+	QML_UNCREATABLE("");
+
+public:
+	explicit PopupAnchor(QObject* parent): QObject(parent) {}
+
+	/// Update the popup's anchor rect relative to its parent window.
+	///
+	/// If anchored to an item, popups anchors will not automatically follow
+	/// the item if its position changes. This function can be called to
+	/// recalculate the anchors.
+	Q_INVOKABLE void updateAnchor();
+
+	[[nodiscard]] bool isDirty() const;
+	void markClean();
+	void markDirty();
+
+	[[nodiscard]] QObject* window() const { return this->mWindow; }
+	[[nodiscard]] ProxyWindowBase* proxyWindow() const { return this->mProxyWindow; }
+	[[nodiscard]] QWindow* backingWindow() const;
+	void setWindowInternal(QObject* window);
+	void setWindow(QObject* window);
+
+	[[nodiscard]] QQuickItem* item() const { return this->mItem; }
+	void setItem(QQuickItem* item);
+
+	[[nodiscard]] QRect windowRect() const { return this->state.rect; }
+	void setWindowRect(QRect rect);
+
+	[[nodiscard]] Box rect() const { return this->mUserRect; }
+	void setRect(Box rect);
+	void resetRect();
+
+	[[nodiscard]] Margins margins() const { return this->mMargins; }
+	void setMargins(Margins margins);
+
+	[[nodiscard]] Edges::Flags edges() const { return this->state.edges; }
+	void setEdges(Edges::Flags edges);
+
+	[[nodiscard]] Edges::Flags gravity() const { return this->state.gravity; }
+	void setGravity(Edges::Flags gravity);
+
+	[[nodiscard]] PopupAdjustment::Flags adjustment() const { return this->state.adjustment; }
+	void setAdjustment(PopupAdjustment::Flags adjustment);
+
+	void updatePlacement(const QPoint& anchorpoint, const QSize& size);
+
+signals:
+	/// Emitted when this anchor is about to be used. Mostly useful for modifying
+	/// the anchor @@rect using [coordinate mapping functions], which are not reactive.
+	///
+	/// [coordinate mapping functions]: https://doc.qt.io/qt-6/qml-qtquick-item.html#mapFromItem-method
+	void anchoring();
+
+	void windowChanged();
+	void itemChanged();
+	QSDOC_HIDE void backingWindowVisibilityChanged();
+	QSDOC_HIDE void windowRectChanged();
+	void rectChanged();
+	void marginsChanged();
+	void edgesChanged();
+	void gravityChanged();
+	void adjustmentChanged();
+
+private slots:
+	void onWindowDestroyed();
+	void onItemDestroyed();
+	void onItemWindowChanged();
+
+private:
+	QObject* mWindow = nullptr;
+	QQuickItem* mItem = nullptr;
+	ProxyWindowBase* mProxyWindow = nullptr;
+	PopupAnchorState state;
+	Box mUserRect;
+	Margins mMargins;
+	std::optional<PopupAnchorState> lastState;
+};
+
+class PopupPositioner {
+public:
+	explicit PopupPositioner() = default;
+	virtual ~PopupPositioner() = default;
+	Q_DISABLE_COPY_MOVE(PopupPositioner);
+
+	virtual void reposition(PopupAnchor* anchor, QWindow* window, bool onlyIfDirty = true);
+	[[nodiscard]] virtual bool shouldRepositionOnMove() const;
+
+	static PopupPositioner* instance();
+	static void setInstance(PopupPositioner* instance);
+};
diff --git a/src/core/proxywindow.cpp b/src/core/proxywindow.cpp
deleted file mode 100644
index 1c1796ad..00000000
--- a/src/core/proxywindow.cpp
+++ /dev/null
@@ -1,223 +0,0 @@
-#include "proxywindow.hpp"
-
-#include <qobject.h>
-#include <qqmlengine.h>
-#include <qqmllist.h>
-#include <qquickitem.h>
-#include <qquickwindow.h>
-#include <qregion.h>
-#include <qtmetamacros.h>
-#include <qtypes.h>
-#include <qwindow.h>
-
-#include "qmlscreen.hpp"
-#include "region.hpp"
-#include "reload.hpp"
-
-ProxyWindowBase::ProxyWindowBase(QObject* parent)
-    : Reloadable(parent)
-    , mContentItem(new QQuickItem()) {
-	QQmlEngine::setObjectOwnership(this->mContentItem, QQmlEngine::CppOwnership);
-	this->mContentItem->setParent(this);
-
-	QObject::connect(this, &ProxyWindowBase::widthChanged, this, &ProxyWindowBase::onWidthChanged);
-	QObject::connect(this, &ProxyWindowBase::heightChanged, this, &ProxyWindowBase::onHeightChanged);
-}
-
-ProxyWindowBase::~ProxyWindowBase() {
-	if (this->window != nullptr) {
-		this->window->deleteLater();
-	}
-}
-
-void ProxyWindowBase::onReload(QObject* oldInstance) {
-	this->window = this->createWindow(oldInstance);
-	this->setupWindow();
-
-	Reloadable::reloadRecursive(this->mContentItem, oldInstance);
-
-	this->mContentItem->setParentItem(this->window->contentItem());
-	this->mContentItem->setWidth(this->width());
-	this->mContentItem->setHeight(this->height());
-
-	// without this the dangling screen pointer wont be updated to a real screen
-	emit this->screenChanged();
-
-	emit this->windowConnected();
-	this->window->setVisible(this->mVisible);
-}
-
-QQuickWindow* ProxyWindowBase::createWindow(QObject* oldInstance) {
-	auto* old = qobject_cast<ProxyWindowBase*>(oldInstance);
-
-	if (old == nullptr || old->window == nullptr) {
-		return new QQuickWindow();
-	} else {
-		return old->disownWindow();
-	}
-}
-
-void ProxyWindowBase::setupWindow() {
-	// clang-format off
-	QObject::connect(this->window, &QWindow::visibilityChanged, this, &ProxyWindowBase::visibleChanged);
-	QObject::connect(this->window, &QWindow::widthChanged, this, &ProxyWindowBase::widthChanged);
-	QObject::connect(this->window, &QWindow::heightChanged, this, &ProxyWindowBase::heightChanged);
-	QObject::connect(this->window, &QWindow::screenChanged, this, &ProxyWindowBase::screenChanged);
-	QObject::connect(this->window, &QQuickWindow::colorChanged, this, &ProxyWindowBase::colorChanged);
-
-	QObject::connect(this, &ProxyWindowBase::maskChanged, this, &ProxyWindowBase::onMaskChanged);
-	QObject::connect(this, &ProxyWindowBase::widthChanged, this, &ProxyWindowBase::onMaskChanged);
-	QObject::connect(this, &ProxyWindowBase::heightChanged, this, &ProxyWindowBase::onMaskChanged);
-	// clang-format on
-
-	this->window->setScreen(this->mScreen);
-	this->setWidth(this->mWidth);
-	this->setHeight(this->mHeight);
-	this->setColor(this->mColor);
-	this->updateMask();
-}
-
-QQuickWindow* ProxyWindowBase::disownWindow() {
-	QObject::disconnect(this->window, nullptr, this, nullptr);
-
-	this->mContentItem->setParentItem(nullptr);
-
-	auto* window = this->window;
-	this->window = nullptr;
-	return window;
-}
-
-QQuickWindow* ProxyWindowBase::backingWindow() const { return this->window; }
-QQuickItem* ProxyWindowBase::contentItem() const { return this->mContentItem; }
-
-bool ProxyWindowBase::isVisible() const {
-	if (this->window == nullptr) return this->mVisible;
-	else return this->window->isVisible();
-}
-
-void ProxyWindowBase::setVisible(bool visible) {
-	if (this->window == nullptr) {
-		this->mVisible = visible;
-		emit this->visibleChanged();
-	} else this->window->setVisible(visible);
-}
-
-qint32 ProxyWindowBase::width() const {
-	if (this->window == nullptr) return this->mWidth;
-	else return this->window->width();
-}
-
-void ProxyWindowBase::setWidth(qint32 width) {
-	if (this->window == nullptr) {
-		this->mWidth = width;
-		emit this->widthChanged();
-	} else this->window->setWidth(width);
-}
-
-qint32 ProxyWindowBase::height() const {
-	if (this->window == nullptr) return this->mHeight;
-	else return this->window->height();
-}
-
-void ProxyWindowBase::setHeight(qint32 height) {
-	if (this->window == nullptr) {
-		this->mHeight = height;
-		emit this->heightChanged();
-	} else this->window->setHeight(height);
-}
-
-void ProxyWindowBase::setScreen(QuickshellScreenInfo* screen) {
-	if (this->mScreen != nullptr) {
-		QObject::disconnect(this->mScreen, nullptr, this, nullptr);
-	}
-
-	auto* qscreen = screen == nullptr ? nullptr : screen->screen;
-	if (qscreen != nullptr) {
-		QObject::connect(qscreen, &QObject::destroyed, this, &ProxyWindowBase::onScreenDestroyed);
-	}
-
-	if (this->window == nullptr) {
-		this->mScreen = qscreen;
-		emit this->screenChanged();
-	} else this->window->setScreen(qscreen);
-}
-
-void ProxyWindowBase::onScreenDestroyed() { this->mScreen = nullptr; }
-
-QuickshellScreenInfo* ProxyWindowBase::screen() const {
-	QScreen* qscreen = nullptr;
-
-	if (this->window == nullptr) {
-		if (this->mScreen != nullptr) qscreen = this->mScreen;
-	} else {
-		qscreen = this->window->screen();
-	}
-
-	return new QuickshellScreenInfo(
-	    const_cast<ProxyWindowBase*>(this), // NOLINT
-	    qscreen
-	);
-}
-
-QColor ProxyWindowBase::color() const {
-	if (this->window == nullptr) return this->mColor;
-	else return this->window->color();
-}
-
-void ProxyWindowBase::setColor(QColor color) {
-	if (this->window == nullptr) {
-		this->mColor = color;
-		emit this->colorChanged();
-	} else this->window->setColor(color);
-}
-
-PendingRegion* ProxyWindowBase::mask() const { return this->mMask; }
-
-void ProxyWindowBase::setMask(PendingRegion* mask) {
-	if (mask == this->mMask) return;
-
-	if (this->mMask != nullptr) {
-		QObject::disconnect(this->mMask, nullptr, this, nullptr);
-	}
-
-	this->mMask = mask;
-
-	if (mask != nullptr) {
-		mask->setParent(this);
-		QObject::connect(mask, &QObject::destroyed, this, &ProxyWindowBase::onMaskDestroyed);
-		QObject::connect(mask, &PendingRegion::changed, this, &ProxyWindowBase::maskChanged);
-	}
-
-	emit this->maskChanged();
-}
-
-void ProxyWindowBase::onMaskChanged() {
-	if (this->window != nullptr) this->updateMask();
-}
-
-void ProxyWindowBase::onMaskDestroyed() {
-	this->mMask = nullptr;
-	emit this->maskChanged();
-}
-
-void ProxyWindowBase::updateMask() {
-	QRegion mask;
-	if (this->mMask != nullptr) {
-		// if left as the default, dont combine it with the whole window area, leave it as is.
-		if (this->mMask->mIntersection == Intersection::Combine) {
-			mask = this->mMask->build();
-		} else {
-			auto windowRegion = QRegion(QRect(0, 0, this->width(), this->height()));
-			mask = this->mMask->applyTo(windowRegion);
-		}
-	}
-
-	this->window->setMask(mask);
-}
-
-QQmlListProperty<QObject> ProxyWindowBase::data() {
-	return this->mContentItem->property("data").value<QQmlListProperty<QObject>>();
-}
-
-void ProxyWindowBase::onWidthChanged() { this->mContentItem->setWidth(this->width()); }
-void ProxyWindowBase::onHeightChanged() { this->mContentItem->setHeight(this->height()); }
diff --git a/src/core/proxywindow.hpp b/src/core/proxywindow.hpp
deleted file mode 100644
index accd434e..00000000
--- a/src/core/proxywindow.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#pragma once
-
-#include <qcolor.h>
-#include <qcontainerfwd.h>
-#include <qevent.h>
-#include <qnamespace.h>
-#include <qobject.h>
-#include <qqmllist.h>
-#include <qqmlparserstatus.h>
-#include <qquickitem.h>
-#include <qquickwindow.h>
-#include <qtmetamacros.h>
-#include <qtypes.h>
-
-#include "qmlscreen.hpp"
-#include "region.hpp"
-#include "reload.hpp"
-#include "windowinterface.hpp"
-
-// Proxy to an actual window exposing a limited property set with the ability to
-// transfer it to a new window.
-
-///! Base class for reloadable windows
-///
-/// [ShellWindow]: ../shellwindow
-/// [FloatingWindow]: ../floatingwindow
-class ProxyWindowBase: public Reloadable {
-	Q_OBJECT;
-	/// The QtQuick window backing this window.
-	///
-	/// > [!WARNING] Do not expect values set via this property to work correctly.
-	/// > Values set this way will almost certainly misbehave across a reload, possibly
-	/// > even without one.
-	/// >
-	/// > Use **only** if you know what you are doing.
-	Q_PROPERTY(QQuickWindow* _backingWindow READ backingWindow);
-	Q_PROPERTY(QQuickItem* contentItem READ contentItem);
-	Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged);
-	Q_PROPERTY(qint32 width READ width WRITE setWidth NOTIFY widthChanged);
-	Q_PROPERTY(qint32 height READ height WRITE setHeight NOTIFY heightChanged);
-	Q_PROPERTY(QuickshellScreenInfo* screen READ screen WRITE setScreen NOTIFY screenChanged);
-	Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged);
-	Q_PROPERTY(PendingRegion* mask READ mask WRITE setMask NOTIFY maskChanged);
-	Q_PROPERTY(QQmlListProperty<QObject> data READ data);
-	Q_CLASSINFO("DefaultProperty", "data");
-
-public:
-	explicit ProxyWindowBase(QObject* parent = nullptr);
-	~ProxyWindowBase() override;
-
-	ProxyWindowBase(ProxyWindowBase&) = delete;
-	ProxyWindowBase(ProxyWindowBase&&) = delete;
-	void operator=(ProxyWindowBase&) = delete;
-	void operator=(ProxyWindowBase&&) = delete;
-
-	void onReload(QObject* oldInstance) override;
-
-	virtual QQuickWindow* createWindow(QObject* oldInstance);
-	virtual void setupWindow();
-
-	// Disown the backing window and delete all its children.
-	virtual QQuickWindow* disownWindow();
-
-	[[nodiscard]] QQuickWindow* backingWindow() const;
-	[[nodiscard]] QQuickItem* contentItem() const;
-
-	[[nodiscard]] virtual bool isVisible() const;
-	virtual void setVisible(bool visible);
-
-	[[nodiscard]] virtual qint32 width() const;
-	virtual void setWidth(qint32 width);
-
-	[[nodiscard]] virtual qint32 height() const;
-	virtual void setHeight(qint32 height);
-
-	[[nodiscard]] virtual QuickshellScreenInfo* screen() const;
-	virtual void setScreen(QuickshellScreenInfo* screen);
-
-	[[nodiscard]] QColor color() const;
-	virtual void setColor(QColor color);
-
-	[[nodiscard]] PendingRegion* mask() const;
-	virtual void setMask(PendingRegion* mask);
-
-	[[nodiscard]] QQmlListProperty<QObject> data();
-
-signals:
-	void windowConnected();
-	void visibleChanged();
-	void widthChanged();
-	void heightChanged();
-	void screenChanged();
-	void colorChanged();
-	void maskChanged();
-
-protected slots:
-	virtual void onWidthChanged();
-	virtual void onHeightChanged();
-	void onMaskChanged();
-	void onMaskDestroyed();
-	void onScreenDestroyed();
-
-protected:
-	bool mVisible = true;
-	qint32 mWidth = 100;
-	qint32 mHeight = 100;
-	QScreen* mScreen = nullptr;
-	QColor mColor = Qt::white;
-	PendingRegion* mMask = nullptr;
-	QQuickWindow* window = nullptr;
-	QQuickItem* mContentItem = nullptr;
-
-private:
-	void updateMask();
-};
diff --git a/src/core/qmlglobal.cpp b/src/core/qmlglobal.cpp
index 99f25631..07238f61 100644
--- a/src/core/qmlglobal.cpp
+++ b/src/core/qmlglobal.cpp
@@ -1,25 +1,44 @@
 #include "qmlglobal.hpp"
 #include <utility>
 
+#include <qclipboard.h>
 #include <qcontainerfwd.h>
 #include <qcoreapplication.h>
 #include <qdir.h>
 #include <qguiapplication.h>
+#include <qicon.h>
 #include <qjsengine.h>
+#include <qlist.h>
 #include <qlogging.h>
 #include <qobject.h>
+#include <qprocess.h>
 #include <qqmlcontext.h>
 #include <qqmlengine.h>
 #include <qqmllist.h>
+#include <qscreen.h>
 #include <qtenvironmentvariables.h>
 #include <qtmetamacros.h>
 #include <qtypes.h>
 #include <qvariant.h>
+#include <qwindowdefs.h>
 #include <unistd.h>
 
+#include "../io/processcore.hpp"
+#include "generation.hpp"
+#include "iconimageprovider.hpp"
+#include "paths.hpp"
 #include "qmlscreen.hpp"
 #include "rootwrapper.hpp"
 
+QuickshellSettings::QuickshellSettings() {
+	QObject::connect(
+	    static_cast<QGuiApplication*>(QGuiApplication::instance()), // NOLINT
+	    &QGuiApplication::lastWindowClosed,
+	    this,
+	    &QuickshellSettings::lastWindowClosed
+	);
+}
+
 QuickshellSettings* QuickshellSettings::instance() {
 	static QuickshellSettings* instance = nullptr; // NOLINT
 	if (instance == nullptr) {
@@ -48,37 +67,96 @@ void QuickshellSettings::setWatchFiles(bool watchFiles) {
 	emit this->watchFilesChanged();
 }
 
-QuickshellGlobal::QuickshellGlobal(QObject* parent): QObject(parent) {
-	// clang-format off
-	QObject::connect(QuickshellSettings::instance(), &QuickshellSettings::workingDirectoryChanged, this, &QuickshellGlobal::workingDirectoryChanged);
-	QObject::connect(QuickshellSettings::instance(), &QuickshellSettings::watchFilesChanged, this, &QuickshellGlobal::watchFilesChanged);
-	// clang-format on
-
+QuickshellTracked::QuickshellTracked() {
 	auto* app = QCoreApplication::instance();
 	auto* guiApp = qobject_cast<QGuiApplication*>(app);
 
 	if (guiApp != nullptr) {
 		// clang-format off
-		QObject::connect(guiApp, &QGuiApplication::primaryScreenChanged, this, &QuickshellGlobal::updateScreens);
-		QObject::connect(guiApp, &QGuiApplication::screenAdded, this, &QuickshellGlobal::updateScreens);
-		QObject::connect(guiApp, &QGuiApplication::screenRemoved, this, &QuickshellGlobal::updateScreens);
+		QObject::connect(guiApp, &QGuiApplication::primaryScreenChanged, this, &QuickshellTracked::updateScreens);
+		QObject::connect(guiApp, &QGuiApplication::screenAdded, this, &QuickshellTracked::updateScreens);
+		QObject::connect(guiApp, &QGuiApplication::screenRemoved, this, &QuickshellTracked::updateScreens);
 		// clang-format on
 
 		this->updateScreens();
 	}
 }
 
+QuickshellScreenInfo* QuickshellTracked::screenInfo(QScreen* screen) const {
+	for (auto* info: this->screens) {
+		if (info->screen == screen) return info;
+	}
+
+	return nullptr;
+}
+
+QuickshellTracked* QuickshellTracked::instance() {
+	static QuickshellTracked* instance = nullptr; // NOLINT
+	if (instance == nullptr) {
+		QJSEngine::setObjectOwnership(instance, QJSEngine::CppOwnership);
+		instance = new QuickshellTracked();
+	}
+	return instance;
+}
+
+void QuickshellTracked::updateScreens() {
+	auto screens = QGuiApplication::screens();
+	auto newScreens = QList<QuickshellScreenInfo*>();
+
+	for (auto* newScreen: screens) {
+		for (auto i = 0; i < this->screens.length(); i++) {
+			auto* oldScreen = this->screens[i];
+			if (newScreen == oldScreen->screen) {
+				newScreens.push_back(oldScreen);
+				this->screens.remove(i);
+				goto next;
+			}
+		}
+
+		{
+			auto* si = new QuickshellScreenInfo(this, newScreen);
+			QQmlEngine::setObjectOwnership(si, QQmlEngine::CppOwnership);
+			newScreens.push_back(si);
+		}
+	next:;
+	}
+
+	for (auto* oldScreen: this->screens) {
+		oldScreen->deleteLater();
+	}
+
+	this->screens = newScreens;
+	emit this->screensChanged();
+}
+
+QuickshellGlobal::QuickshellGlobal(QObject* parent): QObject(parent) {
+	// clang-format off
+	QObject::connect(QuickshellSettings::instance(), &QuickshellSettings::workingDirectoryChanged, this, &QuickshellGlobal::workingDirectoryChanged);
+	QObject::connect(QuickshellSettings::instance(), &QuickshellSettings::watchFilesChanged, this, &QuickshellGlobal::watchFilesChanged);
+	QObject::connect(QuickshellSettings::instance(), &QuickshellSettings::lastWindowClosed, this, &QuickshellGlobal::lastWindowClosed);
+
+	QObject::connect(QuickshellTracked::instance(), &QuickshellTracked::screensChanged, this, &QuickshellGlobal::screensChanged);
+	// clang-format on
+
+	QObject::connect(
+	    static_cast<QGuiApplication*>(QGuiApplication::instance())->clipboard(), // NOLINT
+	    &QClipboard::changed,
+	    this,
+	    &QuickshellGlobal::onClipboardChanged
+	);
+}
+
 qint32 QuickshellGlobal::processId() const { // NOLINT
 	return getpid();
 }
 
-qsizetype QuickshellGlobal::screensCount(QQmlListProperty<QuickshellScreenInfo>* prop) {
-	return static_cast<QuickshellGlobal*>(prop->object)->mScreens.size(); // NOLINT
+qsizetype QuickshellGlobal::screensCount(QQmlListProperty<QuickshellScreenInfo>* /*unused*/) {
+	return QuickshellTracked::instance()->screens.size();
 }
 
 QuickshellScreenInfo*
-QuickshellGlobal::screenAt(QQmlListProperty<QuickshellScreenInfo>* prop, qsizetype i) {
-	return static_cast<QuickshellGlobal*>(prop->object)->mScreens.at(i); // NOLINT
+QuickshellGlobal::screenAt(QQmlListProperty<QuickshellScreenInfo>* /*unused*/, qsizetype i) {
+	return QuickshellTracked::instance()->screens.at(i);
 }
 
 QQmlListProperty<QuickshellScreenInfo> QuickshellGlobal::screens() {
@@ -91,8 +169,8 @@ QQmlListProperty<QuickshellScreenInfo> QuickshellGlobal::screens() {
 }
 
 void QuickshellGlobal::reload(bool hard) {
-	auto* rootobj = QQmlEngine::contextForObject(this)->engine()->parent();
-	auto* root = qobject_cast<RootWrapper*>(rootobj);
+	auto* generation = EngineGeneration::findObjectGeneration(this);
+	auto* root = generation == nullptr ? nullptr : generation->wrapper;
 
 	if (root == nullptr) {
 		qWarning() << "cannot find RootWrapper for reload, ignoring request";
@@ -118,20 +196,68 @@ void QuickshellGlobal::setWatchFiles(bool watchFiles) { // NOLINT
 	QuickshellSettings::instance()->setWatchFiles(watchFiles);
 }
 
-void QuickshellGlobal::updateScreens() {
-	auto screens = QGuiApplication::screens();
-	this->mScreens.resize(screens.size());
+QString QuickshellGlobal::clipboardText() {
+	return static_cast<QGuiApplication*>(QGuiApplication::instance())->clipboard()->text(); // NOLINT
+}
 
-	for (auto i = 0; i < screens.size(); i++) {
-		if (this->mScreens[i] != nullptr) {
-			this->mScreens[i]->screen = nullptr;
-			this->mScreens[i]->setParent(nullptr); // delete if not owned by the js engine
-		}
+void QuickshellGlobal::setClipboardText(const QString& text) {
+	return static_cast<QGuiApplication*>(QGuiApplication::instance()) // NOLINT
+	    ->clipboard()
+	    ->setText(text);
+}
 
-		this->mScreens[i] = new QuickshellScreenInfo(this, screens[i]);
-	}
+void QuickshellGlobal::onClipboardChanged(QClipboard::Mode mode) {
+	if (mode == QClipboard::Clipboard) emit this->clipboardTextChanged();
+}
 
-	emit this->screensChanged();
+QString QuickshellGlobal::shellDir() const {
+	return EngineGeneration::findObjectGeneration(this)->rootPath.path();
+}
+
+QString QuickshellGlobal::configDir() const {
+	qWarning() << "Quickshell.configDir is deprecated and may be removed in a future release. Use "
+	              "Quickshell.shellDir.";
+	return this->shellDir();
+}
+
+QString QuickshellGlobal::shellRoot() const {
+	qWarning() << "Quickshell.shellRoot is deprecated and may be removed in a future release. Use "
+	              "Quickshell.shellDir.";
+	return this->shellDir();
+}
+
+QString QuickshellGlobal::dataDir() const { // NOLINT
+	return QsPaths::instance()->shellDataDir().path();
+}
+
+QString QuickshellGlobal::stateDir() const { // NOLINT
+	return QsPaths::instance()->shellStateDir().path();
+}
+
+QString QuickshellGlobal::cacheDir() const { // NOLINT
+	return QsPaths::instance()->shellCacheDir().path();
+}
+
+QString QuickshellGlobal::shellPath(const QString& path) const {
+	return this->shellDir() % '/' % path;
+}
+
+QString QuickshellGlobal::configPath(const QString& path) const {
+	qWarning() << "Quickshell.configPath() is deprecated and may be removed in a future release. Use "
+	              "Quickshell.shellPath().";
+	return this->shellPath(path);
+}
+
+QString QuickshellGlobal::dataPath(const QString& path) const {
+	return this->dataDir() % '/' % path;
+}
+
+QString QuickshellGlobal::statePath(const QString& path) const {
+	return this->stateDir() % '/' % path;
+}
+
+QString QuickshellGlobal::cachePath(const QString& path) const {
+	return this->cacheDir() % '/' % path;
 }
 
 QVariant QuickshellGlobal::env(const QString& variable) { // NOLINT
@@ -140,3 +266,60 @@ QVariant QuickshellGlobal::env(const QString& variable) { // NOLINT
 
 	return qEnvironmentVariable(vstr.data());
 }
+
+void QuickshellGlobal::execDetached(QList<QString> command) {
+	QuickshellGlobal::execDetached(qs::io::process::ProcessContext(std::move(command)));
+}
+
+void QuickshellGlobal::execDetached(const qs::io::process::ProcessContext& context) {
+	if (context.command.isEmpty()) {
+		qWarning() << "Cannot start process as command is empty.";
+		return;
+	}
+
+	const auto& cmd = context.command.first();
+	auto args = context.command.sliced(1);
+
+	QProcess process;
+	qs::io::process::setupProcessEnvironment(&process, context.clearEnvironment, context.environment);
+
+	if (!context.workingDirectory.isEmpty()) {
+		process.setWorkingDirectory(context.workingDirectory);
+	}
+
+	process.setProgram(cmd);
+	process.setArguments(args);
+
+	process.setStandardInputFile(QProcess::nullDevice());
+
+	if (context.unbindStdout) {
+		process.setStandardOutputFile(QProcess::nullDevice());
+		process.setStandardErrorFile(QProcess::nullDevice());
+	}
+
+	process.startDetached();
+}
+
+QString QuickshellGlobal::iconPath(const QString& icon) {
+	return IconImageProvider::requestString(icon);
+}
+
+QString QuickshellGlobal::iconPath(const QString& icon, bool check) {
+	if (check && QIcon::fromTheme(icon).isNull()) return "";
+	return IconImageProvider::requestString(icon);
+}
+
+QString QuickshellGlobal::iconPath(const QString& icon, const QString& fallback) {
+	return IconImageProvider::requestString(icon, "", fallback);
+}
+
+QuickshellGlobal* QuickshellGlobal::create(QQmlEngine* engine, QJSEngine* /*unused*/) {
+	auto* qsg = new QuickshellGlobal();
+	auto* generation = EngineGeneration::findEngineGeneration(engine);
+
+	if (generation->qsgInstance == nullptr) {
+		generation->qsgInstance = qsg;
+	}
+
+	return qsg;
+}
diff --git a/src/core/qmlglobal.hpp b/src/core/qmlglobal.hpp
index 8dceea14..9d88591e 100644
--- a/src/core/qmlglobal.hpp
+++ b/src/core/qmlglobal.hpp
@@ -1,15 +1,22 @@
 #pragma once
 
+#include <qclipboard.h>
 #include <qcontainerfwd.h>
+#include <qhash.h>
 #include <qjsengine.h>
+#include <qlist.h>
 #include <qobject.h>
 #include <qqmlengine.h>
 #include <qqmlintegration.h>
 #include <qqmllist.h>
+#include <qscreen.h>
 #include <qtmetamacros.h>
 #include <qtypes.h>
 #include <qvariant.h>
+#include <qwindowdefs.h>
 
+#include "../io/processcore.hpp"
+#include "doc.hpp"
 #include "qmlscreen.hpp"
 
 ///! Accessor for some options under the Quickshell type.
@@ -26,16 +33,26 @@ class QuickshellSettings: public QObject {
 	QML_UNCREATABLE("singleton");
 
 public:
+	QuickshellSettings();
+
 	[[nodiscard]] QString workingDirectory() const;
 	void setWorkingDirectory(QString workingDirectory);
 
 	[[nodiscard]] bool watchFiles() const;
 	void setWatchFiles(bool watchFiles);
 
+	[[nodiscard]] bool quitOnLastClosed() const;
+	void setQuitOnLastClosed(bool exitOnLastClosed);
+
 	static QuickshellSettings* instance();
 	static void reset();
 
 signals:
+	/// Sent when the last window is closed.
+	///
+	/// To make the application exit when the last window is closed run `Qt.quit()`.
+	void lastWindowClosed();
+
 	void workingDirectoryChanged();
 	void watchFilesChanged();
 
@@ -43,6 +60,24 @@ private:
 	bool mWatchFiles = true;
 };
 
+class QuickshellTracked: public QObject {
+	Q_OBJECT;
+
+public:
+	QuickshellTracked();
+
+	QVector<QuickshellScreenInfo*> screens;
+	QuickshellScreenInfo* screenInfo(QScreen* screen) const;
+
+	static QuickshellTracked* instance();
+
+private slots:
+	void updateScreens();
+
+signals:
+	void screensChanged();
+};
+
 class QuickshellGlobal: public QObject {
 	Q_OBJECT;
 	// clang-format off
@@ -56,12 +91,12 @@ class QuickshellGlobal: public QObject {
 	/// ```qml
 	/// ShellRoot {
 	///   Variants {
-	///     ShellWindow {
-	///       // ...
-	///     }
-	///
 	///     // see Variants for details
-	///     variants: Quickshell.screens.map(screen => ({ screen }))
+	///     variants: Quickshell.screens
+	///     PanelWindow {
+	///       property var modelData
+	///       screen: modelData
+	///     }
 	///   }
 	/// }
 	/// ```
@@ -69,11 +104,42 @@ class QuickshellGlobal: public QObject {
 	/// This creates an instance of your window once on every screen.
 	/// As screens are added or removed your window will be created or destroyed on those screens.
 	Q_PROPERTY(QQmlListProperty<QuickshellScreenInfo> screens READ screens NOTIFY screensChanged);
+	/// The full path to the root directory of your shell.
+	///
+	/// The root directory is the folder containing the entrypoint to your shell, often referred
+	/// to as `shell.qml`.
+	Q_PROPERTY(QString shellDir READ shellDir CONSTANT);
+	/// > [!WARNING] Deprecated: Renamed to @@shellDir for clarity.
+	Q_PROPERTY(QString configDir READ configDir CONSTANT);
+	/// > [!WARNING] Deprecated: Renamed to @@shellDir for consistency.
+	Q_PROPERTY(QString shellRoot READ shellRoot CONSTANT);
 	/// Quickshell's working directory. Defaults to whereever quickshell was launched from.
 	Q_PROPERTY(QString workingDirectory READ workingDirectory WRITE setWorkingDirectory NOTIFY workingDirectoryChanged);
 	/// If true then the configuration will be reloaded whenever any files change.
 	/// Defaults to true.
 	Q_PROPERTY(bool watchFiles READ watchFiles WRITE setWatchFiles NOTIFY watchFilesChanged);
+	/// The system clipboard.
+	///
+	/// > [!WARNING] Under wayland the clipboard will be empty unless a quickshell window is focused.
+	Q_PROPERTY(QString clipboardText READ clipboardText WRITE setClipboardText NOTIFY clipboardTextChanged);
+	/// The per-shell data directory.
+	///
+	/// Usually `~/.local/share/quickshell/by-shell/<shell-id>`
+	///
+	/// Can be overridden using `//@ pragma DataDir $BASE/path` in the root qml file, where `$BASE`
+	/// corrosponds to `$XDG_DATA_HOME` (usually `~/.local/share`).
+	Q_PROPERTY(QString dataDir READ dataDir CONSTANT);
+	/// The per-shell state directory.
+	///
+	/// Usually `~/.local/state/quickshell/by-shell/<shell-id>`
+	///
+	/// Can be overridden using `//@ pragma StateDir $BASE/path` in the root qml file, where `$BASE`
+	/// corrosponds to `$XDG_STATE_HOME` (usually `~/.local/state`).
+	Q_PROPERTY(QString stateDir READ stateDir CONSTANT);
+	/// The per-shell cache directory.
+	///
+	/// Usually `~/.cache/quickshell/by-shell/<shell-id>`
+	Q_PROPERTY(QString cacheDir READ cacheDir CONSTANT);
 	// clang-format on
 	QML_SINGLETON;
 	QML_NAMED_ELEMENT(Quickshell);
@@ -81,40 +147,119 @@ class QuickshellGlobal: public QObject {
 public:
 	[[nodiscard]] qint32 processId() const;
 
-	QuickshellGlobal(QObject* parent = nullptr);
-
 	QQmlListProperty<QuickshellScreenInfo> screens();
 
-	/// Reload the shell from the [ShellRoot].
+	/// Reload the shell.
 	///
 	/// `hard` - perform a hard reload. If this is false, Quickshell will attempt to reuse windows
 	/// that already exist. If true windows will be recreated.
 	///
-	/// See [Reloadable] for more information on what can be reloaded and how.
-	///
-	/// [Reloadable]: ../reloadable
+	/// See @@Reloadable for more information on what can be reloaded and how.
 	Q_INVOKABLE void reload(bool hard);
 
 	/// Returns the string value of an environment variable or null if it is not set.
 	Q_INVOKABLE QVariant env(const QString& variable);
 
+	// MUST be before execDetached(ctx) or the other will be called with a default constructed obj.
+	QSDOC_HIDE Q_INVOKABLE static void execDetached(QList<QString> command);
+	/// Launch a process detached from Quickshell.
+	///
+	/// The context parameter can either be a list of command arguments or a JS object with the following fields:
+	/// - `command`: A list containing the command and all its arguments. See @@Quickshell.Io.Process.command.
+	/// - `environment`: Changes to make to the process environment. See @@Quickshell.Io.Process.environment.
+	/// - `clearEnvironment`: Removes all variables from the environment if true.
+	/// - `workingDirectory`: The working directory the command should run in.
+	///
+	/// > [!WARNING] This does not run command in a shell. All arguments to the command
+	/// > must be in separate values in the list, e.g. `["echo", "hello"]`
+	/// > and not `["echo hello"]`.
+	/// >
+	/// > Additionally, shell scripts must be run by your shell,
+	/// > e.g. `["sh", "script.sh"]` instead of `["script.sh"]` unless the script
+	/// > has a shebang.
+	///
+	/// > [!INFO] You can use `["sh", "-c", <your command>]` to execute your command with
+	/// > the system shell.
+	///
+	/// This function is equivalent to @@Quickshell.Io.Process.startDetached().
+	Q_INVOKABLE static void execDetached(const qs::io::process::ProcessContext& context);
+
+	/// Returns a string usable for a @@QtQuick.Image.source for a given system icon.
+	///
+	/// > [!INFO] By default, icons are loaded from the theme selected by the qt platform theme,
+	/// > which means they should match with all other qt applications on your system.
+	/// >
+	/// > If you want to use a different icon theme, you can put `//@ pragma IconTheme <name>`
+	/// > at the top of your root config file or set the `QS_ICON_THEME` variable to the name
+	/// > of your icon theme.
+	Q_INVOKABLE static QString iconPath(const QString& icon);
+	/// Setting the `check` parameter of `iconPath` to true will return an empty string
+	/// if the icon does not exist, instead of an image showing a missing texture.
+	Q_INVOKABLE static QString iconPath(const QString& icon, bool check);
+	/// Setting the `fallback` parameter of `iconPath` will attempt to load the fallback
+	/// icon if the requested one could not be loaded.
+	Q_INVOKABLE static QString iconPath(const QString& icon, const QString& fallback);
+	/// Equivalent to `${Quickshell.configDir}/${path}`
+	Q_INVOKABLE [[nodiscard]] QString shellPath(const QString& path) const;
+	/// > [!WARNING] Deprecated: Renamed to @@shellPath() for clarity.
+	Q_INVOKABLE [[nodiscard]] QString configPath(const QString& path) const;
+	/// Equivalent to `${Quickshell.dataDir}/${path}`
+	Q_INVOKABLE [[nodiscard]] QString dataPath(const QString& path) const;
+	/// Equivalent to `${Quickshell.stateDir}/${path}`
+	Q_INVOKABLE [[nodiscard]] QString statePath(const QString& path) const;
+	/// Equivalent to `${Quickshell.cacheDir}/${path}`
+	Q_INVOKABLE [[nodiscard]] QString cachePath(const QString& path) const;
+	/// When called from @@reloadCompleted() or @@reloadFailed(), prevents the
+	/// default reload popup from displaying.
+	///
+	/// The popup can also be blocked by setting `QS_NO_RELOAD_POPUP=1`.
+	Q_INVOKABLE void inhibitReloadPopup() { this->mInhibitReloadPopup = true; }
+
+	void clearReloadPopupInhibit() { this->mInhibitReloadPopup = false; }
+	[[nodiscard]] bool isReloadPopupInhibited() const { return this->mInhibitReloadPopup; }
+
+	[[nodiscard]] QString shellDir() const;
+	[[nodiscard]] QString configDir() const;
+	[[nodiscard]] QString shellRoot() const;
+
 	[[nodiscard]] QString workingDirectory() const;
 	void setWorkingDirectory(QString workingDirectory);
 
 	[[nodiscard]] bool watchFiles() const;
 	void setWatchFiles(bool watchFiles);
 
+	[[nodiscard]] static QString clipboardText();
+	static void setClipboardText(const QString& text);
+
+	[[nodiscard]] QString dataDir() const;
+	[[nodiscard]] QString stateDir() const;
+	[[nodiscard]] QString cacheDir() const;
+
+	static QuickshellGlobal* create(QQmlEngine* engine, QJSEngine* /*unused*/);
+
 signals:
+	/// Sent when the last window is closed.
+	///
+	/// To make the application exit when the last window is closed run `Qt.quit()`.
+	void lastWindowClosed();
+	/// The reload sequence has completed successfully.
+	void reloadCompleted();
+	/// The reload sequence has failed.
+	void reloadFailed(QString errorString);
+
 	void screensChanged();
 	void workingDirectoryChanged();
 	void watchFilesChanged();
+	void clipboardTextChanged();
 
-public slots:
-	void updateScreens();
+private slots:
+	void onClipboardChanged(QClipboard::Mode mode);
 
 private:
+	QuickshellGlobal(QObject* parent = nullptr);
+
+	bool mInhibitReloadPopup = false;
+
 	static qsizetype screensCount(QQmlListProperty<QuickshellScreenInfo>* prop);
 	static QuickshellScreenInfo* screenAt(QQmlListProperty<QuickshellScreenInfo>* prop, qsizetype i);
-
-	QVector<QuickshellScreenInfo*> mScreens;
 };
diff --git a/src/core/qmlscreen.cpp b/src/core/qmlscreen.cpp
index 05e01185..105b4f01 100644
--- a/src/core/qmlscreen.cpp
+++ b/src/core/qmlscreen.cpp
@@ -42,6 +42,42 @@ QString QuickshellScreenInfo::name() const {
 	return this->screen->name();
 }
 
+QString QuickshellScreenInfo::model() const {
+	if (this->screen == nullptr) {
+		this->warnDangling();
+		return "{ NULL SCREEN }";
+	}
+
+	return this->screen->model();
+}
+
+QString QuickshellScreenInfo::serialNumber() const {
+	if (this->screen == nullptr) {
+		this->warnDangling();
+		return "{ NULL SCREEN }";
+	}
+
+	return this->screen->serialNumber();
+}
+
+qint32 QuickshellScreenInfo::x() const {
+	if (this->screen == nullptr) {
+		this->warnDangling();
+		return 0;
+	}
+
+	return this->screen->geometry().x();
+}
+
+qint32 QuickshellScreenInfo::y() const {
+	if (this->screen == nullptr) {
+		this->warnDangling();
+		return 0;
+	}
+
+	return this->screen->geometry().y();
+}
+
 qint32 QuickshellScreenInfo::width() const {
 	if (this->screen == nullptr) {
 		this->warnDangling();
@@ -109,3 +145,21 @@ void QuickshellScreenInfo::screenDestroyed() {
 	this->screen = nullptr;
 	this->dangling = true;
 }
+
+QDebug operator<<(QDebug debug, const QuickshellScreenInfo* screen) {
+	if (screen == nullptr) {
+		debug.nospace() << "QuickshellScreenInfo(nullptr)";
+		return debug;
+	}
+
+	debug.nospace() << screen->metaObject()->className() << '(' << static_cast<const void*>(screen)
+	                << ", screen=" << screen->screen << ')';
+
+	return debug;
+}
+
+QString QuickshellScreenInfo::toString() const {
+	QString str;
+	QDebug(&str) << this;
+	return str;
+}
diff --git a/src/core/qmlscreen.hpp b/src/core/qmlscreen.hpp
index e499dfae..5e978bc0 100644
--- a/src/core/qmlscreen.hpp
+++ b/src/core/qmlscreen.hpp
@@ -1,25 +1,25 @@
 #pragma once
 
+#include <qdebug.h>
 #include <qnamespace.h>
 #include <qobject.h>
+#include <qqmlinfo.h>
 #include <qqmlintegration.h>
 #include <qscreen.h>
+#include <qtclasshelpermacros.h>
 #include <qtmetamacros.h>
 #include <qtypes.h>
 
 // unfortunately QQuickScreenInfo is private.
 
-/// Monitor object useful for setting the monitor for a [ShellWindow]
+/// Monitor object useful for setting the monitor for a @@QsWindow
 /// or querying information about the monitor.
 ///
 /// > [!WARNING] If the monitor is disconnected than any stored copies of its ShellMonitor will
 /// > be marked as dangling and all properties will return default values.
 /// > Reconnecting the monitor will not reconnect it to the ShellMonitor object.
 ///
-/// Due to some technical limitations, it was not possible to reuse the native qml [Screen] type.
-///
-/// [ShellWindow]: ../shellwindow
-/// [Screen]: https://doc.qt.io/qt-6/qml-qtquick-screen.html
+/// Due to some technical limitations, it was not possible to reuse the native qml @@QtQuick.Screen type.
 class QuickshellScreenInfo: public QObject {
 	Q_OBJECT;
 	QML_NAMED_ELEMENT(ShellScreen);
@@ -29,6 +29,12 @@ class QuickshellScreenInfo: public QObject {
 	///
 	/// Usually something like `DP-1`, `HDMI-1`, `eDP-1`.
 	Q_PROPERTY(QString name READ name CONSTANT);
+	/// The model of the screen as seen by the operating system.
+	Q_PROPERTY(QString model READ model CONSTANT);
+	/// The serial number of the screen as seen by the operating system.
+	Q_PROPERTY(QString serialNumber READ serialNumber CONSTANT);
+	Q_PROPERTY(qint32 x READ x NOTIFY geometryChanged);
+	Q_PROPERTY(qint32 y READ y NOTIFY geometryChanged);
 	Q_PROPERTY(qint32 width READ width NOTIFY geometryChanged);
 	Q_PROPERTY(qint32 height READ height NOTIFY geometryChanged);
 	/// The number of physical pixels per millimeter.
@@ -38,7 +44,7 @@ class QuickshellScreenInfo: public QObject {
 	/// The ratio between physical pixels and device-independent (scaled) pixels.
 	Q_PROPERTY(qreal devicePixelRatio READ devicePixelRatio NOTIFY physicalPixelDensityChanged);
 	Q_PROPERTY(Qt::ScreenOrientation orientation READ orientation NOTIFY orientationChanged);
-	Q_PROPERTY(Qt::ScreenOrientation primatyOrientation READ primaryOrientation NOTIFY primaryOrientationChanged);
+	Q_PROPERTY(Qt::ScreenOrientation primaryOrientation READ primaryOrientation NOTIFY primaryOrientationChanged);
 	// clang-format on
 
 public:
@@ -47,6 +53,10 @@ public:
 	bool operator==(QuickshellScreenInfo& other) const;
 
 	[[nodiscard]] QString name() const;
+	[[nodiscard]] QString model() const;
+	[[nodiscard]] QString serialNumber() const;
+	[[nodiscard]] qint32 x() const;
+	[[nodiscard]] qint32 y() const;
 	[[nodiscard]] qint32 width() const;
 	[[nodiscard]] qint32 height() const;
 	[[nodiscard]] qreal physicalPixelDensity() const;
@@ -55,6 +65,8 @@ public:
 	[[nodiscard]] Qt::ScreenOrientation orientation() const;
 	[[nodiscard]] Qt::ScreenOrientation primaryOrientation() const;
 
+	[[nodiscard]] Q_INVOKABLE QString toString() const;
+
 	QScreen* screen;
 
 private:
@@ -71,3 +83,5 @@ signals:
 private slots:
 	void screenDestroyed();
 };
+
+QDebug operator<<(QDebug debug, const QuickshellScreenInfo* screen);
diff --git a/src/core/qsintercept.cpp b/src/core/qsintercept.cpp
new file mode 100644
index 00000000..6687681b
--- /dev/null
+++ b/src/core/qsintercept.cpp
@@ -0,0 +1,131 @@
+#include "qsintercept.hpp"
+#include <cstring>
+
+#include <qdir.h>
+#include <qhash.h>
+#include <qiodevice.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qminmax.h>
+#include <qnetworkaccessmanager.h>
+#include <qnetworkrequest.h>
+#include <qobject.h>
+#include <qqmlabstracturlinterceptor.h>
+#include <qstring.h>
+#include <qtypes.h>
+#include <qurl.h>
+
+#include "logcat.hpp"
+
+QS_LOGGING_CATEGORY(logQsIntercept, "quickshell.interceptor", QtWarningMsg);
+
+QUrl QsUrlInterceptor::intercept(
+    const QUrl& originalUrl,
+    QQmlAbstractUrlInterceptor::DataType type
+) {
+	auto url = originalUrl;
+
+	if (url.scheme() == "root") {
+		url.setScheme("qs");
+
+		auto path = url.path();
+		if (path.startsWith('/')) path = path.sliced(1);
+		url.setPath("@/qs/" % path);
+
+		qCDebug(logQsIntercept) << "Rewrote root intercept" << originalUrl << "to" << url;
+	}
+
+	if (url.scheme() == "qs") {
+		auto path = url.path();
+
+		// Our import path is on "qs:@/".
+		// We want to blackhole any import resolution outside of the config folder as it breaks Qt
+		// but NOT file lookups that might be on "qs:/" due to a missing "file:/" prefix.
+		if (path.startsWith("@/qs/")) {
+			path = this->configRoot.filePath(path.sliced(5));
+		} else if (!path.startsWith("/")) {
+			qCDebug(logQsIntercept) << "Blackholed import URL" << url;
+			return QUrl("qrc:/qs-blackhole");
+		}
+
+		// Some types such as Image take into account where they are loading from, and force
+		// asynchronous loading over a network. qs: is considered to be over a network.
+		// In those cases we want to return a file:// url so asynchronous loading is not forced.
+		if (type == QQmlAbstractUrlInterceptor::DataType::UrlString) {
+			// Qt.resolvedUrl and context->resolvedUrl can use this on qml files, in which
+			// case we want to keep the intercept, otherwise objects created from those paths
+			// will not be able to use singletons.
+			if (path.endsWith(".qml")) return url;
+
+			auto newUrl = url;
+			newUrl.setScheme("file");
+			// above check asserts path starts with /qs/
+			newUrl.setPath(path);
+			qCDebug(logQsIntercept) << "Rewrote intercept" << url << "to" << newUrl;
+			return newUrl;
+		}
+	}
+
+	return url;
+}
+
+QsInterceptDataReply::QsInterceptDataReply(const QString& data, QObject* parent)
+    : QNetworkReply(parent)
+    , content(data.toUtf8()) {
+	this->setOpenMode(QIODevice::ReadOnly);
+	this->setFinished(true);
+}
+
+qint64 QsInterceptDataReply::readData(char* data, qint64 maxSize) {
+	auto size = qMin(maxSize, this->content.length() - this->offset);
+	if (size == 0) return -1;
+	memcpy(data, this->content.constData() + this->offset, size); // NOLINT
+	this->offset += size;
+	return size;
+}
+
+QsInterceptNetworkAccessManager::QsInterceptNetworkAccessManager(
+    const QDir& configRoot,
+    const QHash<QString, QString>& fileIntercepts,
+    QObject* parent
+)
+    : QNetworkAccessManager(parent)
+    , configRoot(configRoot)
+    , fileIntercepts(fileIntercepts) {}
+
+QNetworkReply* QsInterceptNetworkAccessManager::createRequest(
+    QNetworkAccessManager::Operation op,
+    const QNetworkRequest& req,
+    QIODevice* outgoingData
+) {
+	auto url = req.url();
+
+	if (url.scheme() == "qs") {
+		auto path = url.path();
+
+		if (path.startsWith("@/qs/")) path = this->configRoot.filePath(path.sliced(5));
+		// otherwise pass through to fs
+
+		qCDebug(logQsIntercept) << "Got intercept for" << path << "contains"
+		                        << this->fileIntercepts.value(path);
+
+		if (auto data = this->fileIntercepts.value(path); !data.isEmpty()) {
+			return new QsInterceptDataReply(data, this);
+		}
+
+		auto fileReq = req;
+		auto fileUrl = req.url();
+		fileUrl.setScheme("file");
+		fileUrl.setPath(path);
+		qCDebug(logQsIntercept) << "Passing through intercept" << url << "to" << fileUrl;
+
+		fileReq.setUrl(fileUrl);
+		return this->QNetworkAccessManager::createRequest(op, fileReq, outgoingData);
+	}
+
+	return this->QNetworkAccessManager::createRequest(op, req, outgoingData);
+}
+
+QNetworkAccessManager* QsInterceptNetworkAccessManagerFactory::create(QObject* parent) {
+	return new QsInterceptNetworkAccessManager(this->configRoot, this->fileIntercepts, parent);
+}
diff --git a/src/core/qsintercept.hpp b/src/core/qsintercept.hpp
new file mode 100644
index 00000000..c3d8b552
--- /dev/null
+++ b/src/core/qsintercept.hpp
@@ -0,0 +1,78 @@
+#pragma once
+
+#include <qdir.h>
+#include <qhash.h>
+#include <qloggingcategory.h>
+#include <qnetworkaccessmanager.h>
+#include <qnetworkreply.h>
+#include <qnetworkrequest.h>
+#include <qqmlabstracturlinterceptor.h>
+#include <qqmlnetworkaccessmanagerfactory.h>
+#include <qurl.h>
+
+#include "logcat.hpp"
+
+QS_DECLARE_LOGGING_CATEGORY(logQsIntercept);
+
+class QsUrlInterceptor: public QQmlAbstractUrlInterceptor {
+public:
+	explicit QsUrlInterceptor(const QDir& configRoot): configRoot(configRoot) {}
+
+	QUrl intercept(const QUrl& originalUrl, QQmlAbstractUrlInterceptor::DataType type) override;
+
+private:
+	QDir configRoot;
+};
+
+class QsInterceptDataReply: public QNetworkReply {
+	Q_OBJECT;
+
+public:
+	QsInterceptDataReply(const QString& data, QObject* parent = nullptr);
+
+	qint64 readData(char* data, qint64 maxSize) override;
+
+private slots:
+	void abort() override {}
+
+private:
+	qint64 offset = 0;
+	QByteArray content;
+};
+
+class QsInterceptNetworkAccessManager: public QNetworkAccessManager {
+	Q_OBJECT;
+
+public:
+	QsInterceptNetworkAccessManager(
+	    const QDir& configRoot,
+	    const QHash<QString, QString>& fileIntercepts,
+	    QObject* parent = nullptr
+	);
+
+protected:
+	QNetworkReply* createRequest(
+	    QNetworkAccessManager::Operation op,
+	    const QNetworkRequest& req,
+	    QIODevice* outgoingData = nullptr
+	) override;
+
+private:
+	QDir configRoot;
+	const QHash<QString, QString>& fileIntercepts;
+};
+
+class QsInterceptNetworkAccessManagerFactory: public QQmlNetworkAccessManagerFactory {
+public:
+	QsInterceptNetworkAccessManagerFactory(
+	    const QDir& configRoot,
+	    const QHash<QString, QString>& fileIntercepts
+	)
+	    : configRoot(configRoot)
+	    , fileIntercepts(fileIntercepts) {}
+	QNetworkAccessManager* create(QObject* parent) override;
+
+private:
+	QDir configRoot;
+	const QHash<QString, QString>& fileIntercepts;
+};
diff --git a/src/core/qsmenu.cpp b/src/core/qsmenu.cpp
new file mode 100644
index 00000000..760f7e76
--- /dev/null
+++ b/src/core/qsmenu.cpp
@@ -0,0 +1,110 @@
+#include "qsmenu.hpp"
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+
+#include "model.hpp"
+#include "platformmenu.hpp"
+
+using namespace qs::menu::platform;
+
+namespace qs::menu {
+
+QString QsMenuButtonType::toString(QsMenuButtonType::Enum value) {
+	switch (value) {
+	case QsMenuButtonType::None: return "None";
+	case QsMenuButtonType::CheckBox: return "CheckBox";
+	case QsMenuButtonType::RadioButton: return "RadioButton";
+	default: return "Invalid button type";
+	}
+}
+
+QsMenuEntry* QsMenuEntry::menu() { return this; }
+
+void QsMenuEntry::display(QObject* parentWindow, int relativeX, int relativeY) {
+	auto* platform = new PlatformMenuEntry(this);
+
+	QObject::connect(platform, &PlatformMenuEntry::closed, platform, [=]() {
+		platform->deleteLater();
+	});
+
+	auto success = platform->display(parentWindow, relativeX, relativeY);
+	if (!success) delete platform;
+}
+
+void QsMenuEntry::ref() {
+	this->refcount++;
+	if (this->refcount == 1) emit this->opened();
+}
+
+void QsMenuEntry::unref() {
+	this->refcount--;
+	if (this->refcount == 0) emit this->closed();
+}
+
+ObjectModel<QsMenuEntry>* QsMenuEntry::children() {
+	return ObjectModel<QsMenuEntry>::emptyInstance();
+}
+
+QsMenuOpener::~QsMenuOpener() {
+	if (this->mMenu) {
+		if (this->mMenu->menu()) this->mMenu->menu()->unref();
+		this->mMenu->unrefHandle();
+	}
+}
+
+QsMenuHandle* QsMenuOpener::menu() const { return this->mMenu; }
+
+void QsMenuOpener::setMenu(QsMenuHandle* menu) {
+	if (menu == this->mMenu) return;
+
+	if (this->mMenu != nullptr) {
+		QObject::disconnect(this->mMenu, nullptr, this, nullptr);
+
+		if (this->mMenu->menu()) {
+			QObject::disconnect(this->mMenu->menu(), nullptr, this, nullptr);
+			this->mMenu->menu()->unref();
+		}
+
+		this->mMenu->unrefHandle();
+	}
+
+	this->mMenu = menu;
+
+	if (menu != nullptr) {
+		auto onMenuChanged = [this, menu]() {
+			if (menu->menu()) {
+				menu->menu()->ref();
+			}
+
+			emit this->childrenChanged();
+		};
+
+		QObject::connect(menu, &QObject::destroyed, this, &QsMenuOpener::onMenuDestroyed);
+		QObject::connect(menu, &QsMenuHandle::menuChanged, this, onMenuChanged);
+
+		if (menu->menu()) onMenuChanged();
+		menu->refHandle();
+	}
+
+	emit this->menuChanged();
+	emit this->childrenChanged();
+}
+
+void QsMenuOpener::onMenuDestroyed() {
+	this->mMenu = nullptr;
+	emit this->menuChanged();
+	emit this->childrenChanged();
+}
+
+ObjectModel<QsMenuEntry>* QsMenuOpener::children() {
+	if (this->mMenu && this->mMenu->menu()) {
+		return this->mMenu->menu()->children();
+	} else {
+		return ObjectModel<QsMenuEntry>::emptyInstance();
+	}
+}
+
+} // namespace qs::menu
diff --git a/src/core/qsmenu.hpp b/src/core/qsmenu.hpp
new file mode 100644
index 00000000..90df8b9a
--- /dev/null
+++ b/src/core/qsmenu.hpp
@@ -0,0 +1,163 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "doc.hpp"
+#include "model.hpp"
+
+namespace qs::menu {
+
+///! Button type associated with a QsMenuEntry.
+/// See @@QsMenuEntry.buttonType.
+class QsMenuButtonType: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		/// This menu item does not have a checkbox or a radiobutton associated with it.
+		None = 0,
+		/// This menu item should draw a checkbox.
+		CheckBox = 1,
+		/// This menu item should draw a radiobutton.
+		RadioButton = 2,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(qs::menu::QsMenuButtonType::Enum value);
+};
+
+class QsMenuEntry;
+
+///! Menu handle for QsMenuOpener
+/// See @@QsMenuOpener.
+class QsMenuHandle: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_UNCREATABLE("");
+
+public:
+	explicit QsMenuHandle(QObject* parent): QObject(parent) {}
+
+	virtual void refHandle() {}
+	virtual void unrefHandle() {}
+
+	[[nodiscard]] virtual QsMenuEntry* menu() = 0;
+
+signals:
+	void menuChanged();
+};
+
+class QsMenuEntry: public QsMenuHandle {
+	Q_OBJECT;
+	/// If this menu item should be rendered as a separator between other items.
+	///
+	/// No other properties have a meaningful value when @@isSeparator is true.
+	Q_PROPERTY(bool isSeparator READ isSeparator NOTIFY isSeparatorChanged);
+	Q_PROPERTY(bool enabled READ enabled NOTIFY enabledChanged);
+	/// Text of the menu item.
+	Q_PROPERTY(QString text READ text NOTIFY textChanged);
+	/// Url of the menu item's icon or `""` if it doesn't have one.
+	///
+	/// This can be passed to [Image.source](https://doc.qt.io/qt-6/qml-qtquick-image.html#source-prop)
+	/// as shown below.
+	///
+	/// ```qml
+	/// Image {
+	///   source: menuItem.icon
+	///   // To get the best image quality, set the image source size to the same size
+	///   // as the rendered image.
+	///   sourceSize.width: width
+	///   sourceSize.height: height
+	/// }
+	/// ```
+	Q_PROPERTY(QString icon READ icon NOTIFY iconChanged);
+	/// If this menu item has an associated checkbox or radiobutton.
+	Q_PROPERTY(qs::menu::QsMenuButtonType::Enum buttonType READ buttonType NOTIFY buttonTypeChanged);
+	/// The check state of the checkbox or radiobutton if applicable, as a
+	/// [Qt.CheckState](https://doc.qt.io/qt-6/qt.html#CheckState-enum).
+	Q_PROPERTY(Qt::CheckState checkState READ checkState NOTIFY checkStateChanged);
+	/// If this menu item has children that can be accessed through a @@QsMenuOpener$.
+	Q_PROPERTY(bool hasChildren READ hasChildren NOTIFY hasChildrenChanged);
+	QML_ELEMENT;
+	QML_UNCREATABLE("QsMenuEntry cannot be directly created");
+
+public:
+	explicit QsMenuEntry(QObject* parent): QsMenuHandle(parent) {}
+
+	[[nodiscard]] QsMenuEntry* menu() override;
+
+	/// Display a platform menu at the given location relative to the parent window.
+	Q_INVOKABLE void display(QObject* parentWindow, qint32 relativeX, qint32 relativeY);
+
+	[[nodiscard]] virtual bool isSeparator() const { return false; }
+	[[nodiscard]] virtual bool enabled() const { return true; }
+	[[nodiscard]] virtual QString text() const { return ""; }
+	[[nodiscard]] virtual QString icon() const { return ""; }
+	[[nodiscard]] virtual QsMenuButtonType::Enum buttonType() const { return QsMenuButtonType::None; }
+	[[nodiscard]] virtual Qt::CheckState checkState() const { return Qt::Unchecked; }
+	[[nodiscard]] virtual bool hasChildren() const { return false; }
+
+	void ref();
+	void unref();
+
+	[[nodiscard]] virtual ObjectModel<QsMenuEntry>* children();
+
+signals:
+	/// Send a trigger/click signal to the menu entry.
+	void triggered();
+
+	QSDOC_HIDE void opened();
+	QSDOC_HIDE void closed();
+
+	void isSeparatorChanged();
+	void enabledChanged();
+	void textChanged();
+	void iconChanged();
+	void buttonTypeChanged();
+	void checkStateChanged();
+	void hasChildrenChanged();
+
+private:
+	qsizetype refcount = 0;
+};
+
+///! Provides access to children of a QsMenuEntry
+class QsMenuOpener: public QObject {
+	Q_OBJECT;
+	/// The menu to retrieve children from.
+	Q_PROPERTY(qs::menu::QsMenuHandle* menu READ menu WRITE setMenu NOTIFY menuChanged);
+	/// The children of the given menu.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::menu::QsMenuEntry>*);
+	Q_PROPERTY(UntypedObjectModel* children READ children NOTIFY childrenChanged);
+	QML_ELEMENT;
+
+public:
+	explicit QsMenuOpener(QObject* parent = nullptr): QObject(parent) {}
+	~QsMenuOpener() override;
+	Q_DISABLE_COPY_MOVE(QsMenuOpener);
+
+	[[nodiscard]] QsMenuHandle* menu() const;
+	void setMenu(QsMenuHandle* menu);
+
+	[[nodiscard]] ObjectModel<QsMenuEntry>* children();
+
+signals:
+	void menuChanged();
+	void childrenChanged();
+
+private slots:
+	void onMenuDestroyed();
+
+private:
+	QsMenuHandle* mMenu = nullptr;
+};
+
+} // namespace qs::menu
diff --git a/src/core/qsmenuanchor.cpp b/src/core/qsmenuanchor.cpp
new file mode 100644
index 00000000..ded8ad05
--- /dev/null
+++ b/src/core/qsmenuanchor.cpp
@@ -0,0 +1,125 @@
+#include "qsmenuanchor.hpp"
+
+#include <qapplication.h>
+#include <qcoreapplication.h>
+#include <qlogging.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+#include "platformmenu.hpp"
+#include "popupanchor.hpp"
+#include "qsmenu.hpp"
+
+using qs::menu::platform::PlatformMenuEntry;
+
+namespace qs::menu {
+
+QsMenuAnchor::~QsMenuAnchor() { this->onClosed(); }
+
+void QsMenuAnchor::open() {
+	if (qobject_cast<QApplication*>(QCoreApplication::instance()) == nullptr) {
+		qCritical() << "Cannot call QsMenuAnchor.open() as quickshell was not started in "
+		               "QApplication mode.";
+		qCritical() << "To use platform menus, add `//@ pragma UseQApplication` to the top of your "
+		               "root QML file and restart quickshell.";
+		return;
+	}
+
+	if (this->mOpen) {
+		qCritical() << "Cannot call QsMenuAnchor.open() as it is already open.";
+		return;
+	}
+
+	if (!this->mMenu) {
+		qCritical() << "Cannot open QsMenuAnchor with no menu attached.";
+		return;
+	}
+
+	this->mOpen = true;
+
+	if (this->mMenu->menu()) this->onMenuChanged();
+	QObject::connect(this->mMenu, &QsMenuHandle::menuChanged, this, &QsMenuAnchor::onMenuChanged);
+	this->mMenu->refHandle();
+
+	emit this->visibleChanged();
+}
+
+void QsMenuAnchor::onMenuChanged() {
+	// close menu if the path changes
+	if (this->platformMenu || !this->mMenu->menu()) {
+		this->onClosed();
+		return;
+	}
+
+	this->platformMenu = new PlatformMenuEntry(this->mMenu->menu());
+	QObject::connect(this->platformMenu, &PlatformMenuEntry::closed, this, &QsMenuAnchor::onClosed);
+
+	auto success = this->platformMenu->display(&this->mAnchor);
+	if (!success) this->onClosed();
+	else emit this->opened();
+}
+
+void QsMenuAnchor::close() {
+	if (!this->mOpen) {
+		qCritical() << "Cannot close QsMenuAnchor as it isn't open.";
+		return;
+	}
+
+	this->onClosed();
+}
+
+void QsMenuAnchor::onClosed() {
+	if (!this->mOpen) return;
+
+	this->mOpen = false;
+
+	if (this->platformMenu) {
+		this->platformMenu->deleteLater();
+		this->platformMenu = nullptr;
+	}
+
+	if (this->mMenu) {
+		QObject::disconnect(
+		    this->mMenu,
+		    &QsMenuHandle::menuChanged,
+		    this,
+		    &QsMenuAnchor::onMenuChanged
+		);
+
+		this->mMenu->unrefHandle();
+	}
+
+	emit this->closed();
+	emit this->visibleChanged();
+}
+
+PopupAnchor* QsMenuAnchor::anchor() { return &this->mAnchor; }
+
+QsMenuHandle* QsMenuAnchor::menu() const { return this->mMenu; }
+
+void QsMenuAnchor::setMenu(QsMenuHandle* menu) {
+	if (menu == this->mMenu) return;
+
+	if (this->mMenu != nullptr) {
+		if (this->platformMenu != nullptr) this->platformMenu->deleteLater();
+		QObject::disconnect(this->mMenu, nullptr, this, nullptr);
+	}
+
+	this->mMenu = menu;
+
+	if (menu != nullptr) {
+		QObject::connect(menu, &QObject::destroyed, this, &QsMenuAnchor::onMenuDestroyed);
+	}
+
+	emit this->menuChanged();
+}
+
+bool QsMenuAnchor::isVisible() const { return this->mOpen; }
+
+void QsMenuAnchor::onMenuDestroyed() {
+	this->mMenu = nullptr;
+	this->onClosed();
+	emit this->menuChanged();
+}
+
+} // namespace qs::menu
diff --git a/src/core/qsmenuanchor.hpp b/src/core/qsmenuanchor.hpp
new file mode 100644
index 00000000..14e06c63
--- /dev/null
+++ b/src/core/qsmenuanchor.hpp
@@ -0,0 +1,86 @@
+#pragma once
+
+#include <qqmlintegration.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+
+#include "platformmenu.hpp"
+#include "popupanchor.hpp"
+#include "qsmenu.hpp"
+
+namespace qs::menu {
+
+///! Display anchor for platform menus.
+class QsMenuAnchor: public QObject {
+	Q_OBJECT;
+	/// The menu's anchor / positioner relative to another window. The menu will not be
+	/// shown until it has a valid anchor.
+	///
+	/// > [!INFO] *The following is subject to change and NOT a guarantee of future behavior.*
+	/// >
+	/// > A snapshot of the anchor at the time @@opened(s) is emitted will be
+	/// > used to position the menu. Additional changes to the anchor after this point
+	/// > will not affect the placement of the menu.
+	///
+	/// You can set properties of the anchor like so:
+	/// ```qml
+	/// QsMenuAnchor {
+	///   anchor.window: parentwindow
+	///   // or
+	///   anchor {
+	///     window: parentwindow
+	///   }
+	/// }
+	/// ```
+	Q_PROPERTY(PopupAnchor* anchor READ anchor CONSTANT);
+	/// The menu that should be displayed on this anchor.
+	///
+	/// See also: @@Quickshell.Services.SystemTray.SystemTrayItem.menu.
+	Q_PROPERTY(qs::menu::QsMenuHandle* menu READ menu WRITE setMenu NOTIFY menuChanged);
+	/// If the menu is currently open and visible.
+	///
+	/// See also: @@open(), @@close().
+	Q_PROPERTY(bool visible READ isVisible NOTIFY visibleChanged);
+	QML_ELEMENT;
+
+public:
+	explicit QsMenuAnchor(QObject* parent = nullptr): QObject(parent) {}
+	~QsMenuAnchor() override;
+	Q_DISABLE_COPY_MOVE(QsMenuAnchor);
+
+	/// Open the given menu on this menu Requires that @@anchor is valid.
+	Q_INVOKABLE void open();
+	/// Close the open menu.
+	Q_INVOKABLE void close();
+
+	[[nodiscard]] PopupAnchor* anchor();
+
+	[[nodiscard]] QsMenuHandle* menu() const;
+	void setMenu(QsMenuHandle* menu);
+
+	[[nodiscard]] bool isVisible() const;
+
+signals:
+	/// Sent when the menu is displayed onscreen which may be after @@visible
+	/// becomes true.
+	void opened();
+	/// Sent when the menu is closed.
+	void closed();
+
+	void menuChanged();
+	void visibleChanged();
+
+private slots:
+	void onMenuChanged();
+	void onMenuDestroyed();
+
+private:
+	void onClosed();
+
+	PopupAnchor mAnchor {this};
+	QsMenuHandle* mMenu = nullptr;
+	bool mOpen = false;
+	platform::PlatformMenuEntry* platformMenu = nullptr;
+};
+
+} // namespace qs::menu
diff --git a/src/core/region.cpp b/src/core/region.cpp
index 9826dbd5..11892d6d 100644
--- a/src/core/region.cpp
+++ b/src/core/region.cpp
@@ -7,6 +7,8 @@
 #include <qquickitem.h>
 #include <qregion.h>
 #include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvectornd.h>
 
 PendingRegion::PendingRegion(QObject* parent): QObject(parent) {
 	QObject::connect(this, &PendingRegion::shapeChanged, this, &PendingRegion::changed);
@@ -20,30 +22,39 @@ PendingRegion::PendingRegion(QObject* parent): QObject(parent) {
 }
 
 void PendingRegion::setItem(QQuickItem* item) {
+	if (item == this->mItem) return;
+
 	if (this->mItem != nullptr) {
 		QObject::disconnect(this->mItem, nullptr, this, nullptr);
 	}
 
 	this->mItem = item;
 
-	QObject::connect(this->mItem, &QQuickItem::xChanged, this, &PendingRegion::itemChanged);
-	QObject::connect(this->mItem, &QQuickItem::yChanged, this, &PendingRegion::itemChanged);
-	QObject::connect(this->mItem, &QQuickItem::widthChanged, this, &PendingRegion::itemChanged);
-	QObject::connect(this->mItem, &QQuickItem::heightChanged, this, &PendingRegion::itemChanged);
+	if (item != nullptr) {
+		QObject::connect(this->mItem, &QObject::destroyed, this, &PendingRegion::onItemDestroyed);
+		QObject::connect(this->mItem, &QQuickItem::xChanged, this, &PendingRegion::itemChanged);
+		QObject::connect(this->mItem, &QQuickItem::yChanged, this, &PendingRegion::itemChanged);
+		QObject::connect(this->mItem, &QQuickItem::widthChanged, this, &PendingRegion::itemChanged);
+		QObject::connect(this->mItem, &QQuickItem::heightChanged, this, &PendingRegion::itemChanged);
+	}
+
+	emit this->itemChanged();
 }
 
 void PendingRegion::onItemDestroyed() { this->mItem = nullptr; }
 
+void PendingRegion::onChildDestroyed() { this->mRegions.removeAll(this->sender()); }
+
 QQmlListProperty<PendingRegion> PendingRegion::regions() {
 	return QQmlListProperty<PendingRegion>(
 	    this,
 	    nullptr,
-	    PendingRegion::regionsAppend,
-	    nullptr,
-	    nullptr,
-	    nullptr,
-	    nullptr,
-	    nullptr
+	    &PendingRegion::regionsAppend,
+	    &PendingRegion::regionsCount,
+	    &PendingRegion::regionAt,
+	    &PendingRegion::regionsClear,
+	    &PendingRegion::regionsReplace,
+	    &PendingRegion::regionsRemoveLast
 	);
 }
 
@@ -97,11 +108,67 @@ QRegion PendingRegion::applyTo(QRegion& region) const {
 	return region;
 }
 
+QRegion PendingRegion::applyTo(const QRect& rect) const {
+	// if left as the default, dont combine it with the whole rect area, leave it as is.
+	if (this->mIntersection == Intersection::Combine) {
+		return this->build();
+	} else {
+		auto baseRegion = QRegion(rect);
+		return this->applyTo(baseRegion);
+	}
+}
+
 void PendingRegion::regionsAppend(QQmlListProperty<PendingRegion>* prop, PendingRegion* region) {
 	auto* self = static_cast<PendingRegion*>(prop->object); // NOLINT
-	region->setParent(self);
+	if (!region) return;
+
+	QObject::connect(region, &QObject::destroyed, self, &PendingRegion::onChildDestroyed);
+	QObject::connect(region, &PendingRegion::changed, self, &PendingRegion::childrenChanged);
+
 	self->mRegions.append(region);
 
-	QObject::connect(region, &PendingRegion::changed, self, &PendingRegion::childrenChanged);
+	emit self->childrenChanged();
+}
+
+PendingRegion* PendingRegion::regionAt(QQmlListProperty<PendingRegion>* prop, qsizetype i) {
+	return static_cast<PendingRegion*>(prop->object)->mRegions.at(i); // NOLINT
+}
+
+void PendingRegion::regionsClear(QQmlListProperty<PendingRegion>* prop) {
+	auto* self = static_cast<PendingRegion*>(prop->object); // NOLINT
+
+	for (auto* region: self->mRegions) {
+		QObject::disconnect(region, nullptr, self, nullptr);
+	}
+
+	self->mRegions.clear(); // NOLINT
+	emit self->childrenChanged();
+}
+
+qsizetype PendingRegion::regionsCount(QQmlListProperty<PendingRegion>* prop) {
+	return static_cast<PendingRegion*>(prop->object)->mRegions.length(); // NOLINT
+}
+
+void PendingRegion::regionsRemoveLast(QQmlListProperty<PendingRegion>* prop) {
+	auto* self = static_cast<PendingRegion*>(prop->object); // NOLINT
+
+	auto* last = self->mRegions.last();
+	if (last != nullptr) QObject::disconnect(last, nullptr, self, nullptr);
+
+	self->mRegions.removeLast();
+	emit self->childrenChanged();
+}
+
+void PendingRegion::regionsReplace(
+    QQmlListProperty<PendingRegion>* prop,
+    qsizetype i,
+    PendingRegion* region
+) {
+	auto* self = static_cast<PendingRegion*>(prop->object); // NOLINT
+
+	auto* old = self->mRegions.at(i);
+	if (old != nullptr) QObject::disconnect(old, nullptr, self, nullptr);
+
+	self->mRegions.replace(i, region);
 	emit self->childrenChanged();
 }
diff --git a/src/core/region.hpp b/src/core/region.hpp
index 06654ca9..6637d7bd 100644
--- a/src/core/region.hpp
+++ b/src/core/region.hpp
@@ -9,12 +9,13 @@
 #include <qtmetamacros.h>
 #include <qtypes.h>
 
-/// Shape of a Region.
+///! Shape of a Region.
+/// See @@Region.shape.
 namespace RegionShape { // NOLINT
 Q_NAMESPACE;
 QML_ELEMENT;
 
-enum Enum {
+enum Enum : quint8 {
 	Rect = 0,
 	Ellipse = 1,
 };
@@ -23,11 +24,12 @@ Q_ENUM_NS(Enum);
 } // namespace RegionShape
 
 ///! Intersection strategy for Regions.
+/// See @@Region.intersection.
 namespace Intersection { // NOLINT
 Q_NAMESPACE;
 QML_ELEMENT;
 
-enum Enum {
+enum Enum : quint8 {
 	/// Combine this region, leaving a union of this and the other region. (opposite of `Subtract`)
 	Combine = 0,
 	/// Subtract this region, cutting this region out of the other. (opposite of `Combine`)
@@ -44,6 +46,7 @@ Q_ENUM_NS(Enum);
 } // namespace Intersection
 
 ///! A composable region used as a mask.
+/// See @@QsWindow.mask.
 class PendingRegion: public QObject {
 	Q_OBJECT;
 	/// Defaults to `Rect`.
@@ -52,16 +55,16 @@ class PendingRegion: public QObject {
 	Q_PROPERTY(Intersection::Enum intersection MEMBER mIntersection NOTIFY intersectionChanged);
 
 	/// The item that determines the geometry of the region.
-	/// `item` overrides `x`, `y`, `width` and `height`.
+	/// `item` overrides @@x, @@y, @@width and @@height.
 	Q_PROPERTY(QQuickItem* item MEMBER mItem WRITE setItem NOTIFY itemChanged);
 
-	/// Defaults to 0. Does nothing if `item` is set.
+	/// Defaults to 0. Does nothing if @@item is set.
 	Q_PROPERTY(qint32 x MEMBER mX NOTIFY xChanged);
-	/// Defaults to 0. Does nothing if `item` is set.
+	/// Defaults to 0. Does nothing if @@item is set.
 	Q_PROPERTY(qint32 y MEMBER mY NOTIFY yChanged);
-	/// Defaults to 0. Does nothing if `item` is set.
+	/// Defaults to 0. Does nothing if @@item is set.
 	Q_PROPERTY(qint32 width MEMBER mWidth NOTIFY widthChanged);
-	/// Defaults to 0. Does nothing if `item` is set.
+	/// Defaults to 0. Does nothing if @@item is set.
 	Q_PROPERTY(qint32 height MEMBER mHeight NOTIFY heightChanged);
 
 	/// Regions to apply on top of this region.
@@ -93,6 +96,7 @@ public:
 	[[nodiscard]] bool empty() const;
 	[[nodiscard]] QRegion build() const;
 	[[nodiscard]] QRegion applyTo(QRegion& region) const;
+	[[nodiscard]] QRegion applyTo(const QRect& rect) const;
 
 	RegionShape::Enum mShape = RegionShape::Rect;
 	Intersection::Enum mIntersection = Intersection::Combine;
@@ -106,13 +110,25 @@ signals:
 	void widthChanged();
 	void heightChanged();
 	void childrenChanged();
+
+	/// Triggered when the region's geometry changes.
+	///
+	/// In some cases the region does not update automatically.
+	/// In those cases you can emit this signal manually.
 	void changed();
 
 private slots:
 	void onItemDestroyed();
+	void onChildDestroyed();
 
 private:
 	static void regionsAppend(QQmlListProperty<PendingRegion>* prop, PendingRegion* region);
+	static PendingRegion* regionAt(QQmlListProperty<PendingRegion>* prop, qsizetype i);
+	static void regionsClear(QQmlListProperty<PendingRegion>* prop);
+	static qsizetype regionsCount(QQmlListProperty<PendingRegion>* prop);
+	static void regionsRemoveLast(QQmlListProperty<PendingRegion>* prop);
+	static void
+	regionsReplace(QQmlListProperty<PendingRegion>* prop, qsizetype i, PendingRegion* region);
 
 	QQuickItem* mItem = nullptr;
 
diff --git a/src/core/reload.cpp b/src/core/reload.cpp
index 8768dc74..ea2abbf6 100644
--- a/src/core/reload.cpp
+++ b/src/core/reload.cpp
@@ -3,6 +3,56 @@
 #include <qcontainerfwd.h>
 #include <qobject.h>
 #include <qqmllist.h>
+#include <qtimer.h>
+
+#include "generation.hpp"
+
+void Reloadable::componentComplete() {
+	this->engineGeneration = EngineGeneration::findObjectGeneration(this);
+
+	if (this->engineGeneration != nullptr) {
+		// When called this way there is no chance a reload will have old data,
+		// but this will at least help prevent weird behaviors due to never getting a reload.
+		if (this->engineGeneration->reloadComplete) {
+			// Delayed due to Component.onCompleted running after QQmlParserStatus::componentComplete.
+			QTimer::singleShot(0, this, &Reloadable::onReloadFinished);
+
+			// This only matters for preventing the above timer from UAFing the generation,
+			// so it isn't connected anywhere else.
+			QObject::connect(
+			    this->engineGeneration,
+			    &QObject::destroyed,
+			    this,
+			    &Reloadable::onGenerationDestroyed
+			);
+		} else {
+			QObject::connect(
+			    this->engineGeneration,
+			    &EngineGeneration::reloadFinished,
+			    this,
+			    &Reloadable::onReloadFinished
+			);
+		}
+	}
+}
+
+void Reloadable::reload(QObject* oldInstance) {
+	if (this->reloadComplete) return;
+	this->onReload(oldInstance);
+	this->reloadComplete = true;
+
+	if (this->engineGeneration != nullptr) {
+		QObject::disconnect(
+		    this->engineGeneration,
+		    &EngineGeneration::reloadFinished,
+		    this,
+		    &Reloadable::onReloadFinished
+		);
+	}
+}
+
+void Reloadable::onReloadFinished() { this->reload(nullptr); }
+void Reloadable::onGenerationDestroyed() { this->engineGeneration = nullptr; }
 
 void ReloadPropagator::onReload(QObject* oldInstance) {
 	auto* old = qobject_cast<ReloadPropagator*>(oldInstance);
@@ -13,7 +63,7 @@ void ReloadPropagator::onReload(QObject* oldInstance) {
 			auto* oldChild = old == nullptr || old->mChildren.length() <= i
 			                   ? nullptr
 			                   : qobject_cast<Reloadable*>(old->mChildren.at(i));
-			newChild->onReload(oldChild);
+			newChild->reload(oldChild);
 		} else {
 			Reloadable::reloadRecursive(newChild, oldInstance);
 		}
@@ -49,7 +99,7 @@ void Reloadable::reloadRecursive(QObject* newObj, QObject* oldRoot) {
 
 		// pass handling to the child's onReload, which should call back into reloadRecursive,
 		// with its oldInstance becoming the new oldRoot.
-		reloadable->onReload(oldInstance);
+		reloadable->reload(oldInstance);
 	} else if (newObj != nullptr) {
 		Reloadable::reloadChildrenRecursive(newObj, oldRoot);
 	}
@@ -76,12 +126,21 @@ QObject* Reloadable::getChildByReloadId(QObject* parent, const QString& reloadId
 	return nullptr;
 }
 
-void PostReloadHook::postReloadTree(QObject* root) {
-	for (auto* child: root->children()) {
-		PostReloadHook::postReloadTree(child);
-	}
-
-	if (auto* self = dynamic_cast<PostReloadHook*>(root)) {
-		self->onPostReload();
+void PostReloadHook::componentComplete() {
+	auto* engineGeneration = EngineGeneration::findObjectGeneration(this);
+	if (!engineGeneration || engineGeneration->reloadComplete) this->postReload();
+	else {
+		// disconnected by EngineGeneration::postReload
+		QObject::connect(
+		    engineGeneration,
+		    &EngineGeneration::firePostReload,
+		    this,
+		    &PostReloadHook::postReload
+		);
 	}
 }
+
+void PostReloadHook::postReload() {
+	this->isPostReload = true;
+	this->onPostReload();
+}
diff --git a/src/core/reload.hpp b/src/core/reload.hpp
index 2ae459a3..ae5d7c92 100644
--- a/src/core/reload.hpp
+++ b/src/core/reload.hpp
@@ -7,12 +7,11 @@
 #include <qqmlparserstatus.h>
 #include <qtmetamacros.h>
 
+class EngineGeneration;
+
 ///! The base class of all types that can be reloaded.
 /// Reloadables will attempt to take specific state from previous config revisions if possible.
-/// Some examples are [ProxyWindowBase] and [PersistentProperties]
-///
-/// [ProxyWindowBase]: ../proxywindowbase
-/// [PersistentProperties]: ../persistentproperties
+/// Some examples are @@ProxyWindowBase and @@PersistentProperties
 class Reloadable
     : public QObject
     , public QQmlParserStatus {
@@ -26,7 +25,7 @@ class Reloadable
 	/// this object in the current revision, and facilitate smoother reloading.
 	///
 	/// Note that identifiers are scoped, and will try to do the right thing in context.
-	/// For example if you have a `Variants` wrapping an object with an identified element inside,
+	/// For example if you have a @@Variants wrapping an object with an identified element inside,
 	/// a scope is created at the variant level.
 	///
 	/// ```qml
@@ -56,14 +55,10 @@ class Reloadable
 public:
 	explicit Reloadable(QObject* parent = nullptr): QObject(parent) {}
 
-	// Called unconditionally in the reload phase, with nullptr if no source could be determined.
-	// If non null the old instance may or may not be of the same type, and should be checked
-	// by `onReload`.
-	virtual void onReload(QObject* oldInstance) = 0;
+	void reload(QObject* oldInstance = nullptr);
 
-	// TODO: onReload runs after initialization for reloadable objects created late
 	void classBegin() override {}
-	void componentComplete() override {}
+	void componentComplete() override;
 
 	// Reload objects in the parent->child graph recursively.
 	static void reloadRecursive(QObject* newObj, QObject* oldRoot);
@@ -71,16 +66,27 @@ public:
 	static void reloadChildrenRecursive(QObject* newRoot, QObject* oldRoot);
 
 	QString mReloadableId;
+	bool reloadComplete = false;
+	EngineGeneration* engineGeneration = nullptr;
+
+private slots:
+	void onReloadFinished();
+	void onGenerationDestroyed();
+
+protected:
+	// Called unconditionally in the reload phase, with nullptr if no source could be determined.
+	// If non null the old instance may or may not be of the same type, and should be checked
+	// by `onReload`.
+	virtual void onReload(QObject* oldInstance) = 0;
 
 private:
 	static QObject* getChildByReloadId(QObject* parent, const QString& reloadId);
 };
 
 ///! Scope that propagates reloads to child items in order.
-/// Convenience type equivalent to setting `reloadableId` on properties in a
-/// QtObject instance.
+/// Convenience type equivalent to setting @@Reloadable.reloadableId for all children.
 ///
-/// Note that this does not work for visible `Item`s (all widgets).
+/// Note that this does not work for visible @@QtQuick.Item$s (all widgets).
 ///
 /// ```qml
 /// ShellRoot {
@@ -113,16 +119,23 @@ private:
 };
 
 /// Hook that runs after the old widget tree is dropped during a reload.
-class PostReloadHook {
+class PostReloadHook
+    : public QObject
+    , public QQmlParserStatus {
+	Q_OBJECT;
+	QML_ANONYMOUS;
+	Q_INTERFACES(QQmlParserStatus);
+
 public:
-	PostReloadHook() = default;
-	virtual ~PostReloadHook() = default;
-	PostReloadHook(PostReloadHook&&) = default;
-	PostReloadHook(const PostReloadHook&) = default;
-	PostReloadHook& operator=(PostReloadHook&&) = default;
-	PostReloadHook& operator=(const PostReloadHook&) = default;
+	PostReloadHook(QObject* parent = nullptr): QObject(parent) {}
+	void classBegin() override {}
+	void componentComplete() override;
 
 	virtual void onPostReload() = 0;
 
-	static void postReloadTree(QObject* root);
+public slots:
+	void postReload();
+
+protected:
+	bool isPostReload = false;
 };
diff --git a/src/core/retainable.cpp b/src/core/retainable.cpp
new file mode 100644
index 00000000..4e77e051
--- /dev/null
+++ b/src/core/retainable.cpp
@@ -0,0 +1,163 @@
+#include "retainable.hpp"
+
+#include <qlogging.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qvariant.h>
+
+RetainableHook* RetainableHook::getHook(QObject* object, bool create) {
+	auto v = object->property("__qs_retainable");
+
+	if (v.canConvert<RetainableHook*>()) {
+		return v.value<RetainableHook*>();
+	} else if (create) {
+		auto* retainable = dynamic_cast<Retainable*>(object);
+		if (!retainable) return nullptr;
+
+		auto* hook = new RetainableHook(object);
+		hook->retainableFacet = retainable;
+		retainable->hook = hook;
+
+		object->setProperty("__qs_retainable", QVariant::fromValue(hook));
+
+		return hook;
+	} else return nullptr;
+}
+
+RetainableHook* RetainableHook::qmlAttachedProperties(QObject* object) {
+	return RetainableHook::getHook(object, true);
+}
+
+void RetainableHook::ref() { this->refcount++; }
+
+void RetainableHook::unref() {
+	this->refcount--;
+	if (this->refcount == 0) this->unlocked();
+}
+
+void RetainableHook::lock() {
+	this->explicitRefcount++;
+	this->ref();
+}
+
+void RetainableHook::unlock() {
+	if (this->explicitRefcount < 1) {
+		qWarning() << "Retainable object" << this->parent()
+		           << "unlocked more times than it was locked!";
+	} else {
+		this->explicitRefcount--;
+		this->unref();
+	}
+}
+
+void RetainableHook::forceUnlock() { this->unlocked(); }
+
+bool RetainableHook::isRetained() const { return !this->inactive; }
+
+void RetainableHook::unlocked() {
+	if (this->inactive) return;
+
+	emit this->aboutToDestroy();
+	this->retainableFacet->retainFinished();
+}
+
+void Retainable::retainedDestroy() {
+	this->retaining = true;
+
+	auto* hook = RetainableHook::getHook(dynamic_cast<QObject*>(this), false);
+
+	if (hook) {
+		// let all signal handlers run before acting on changes
+		emit hook->dropped();
+		hook->inactive = false;
+
+		if (hook->refcount == 0) hook->unlocked();
+		else emit hook->retainedChanged();
+	} else {
+		this->retainFinished();
+	}
+}
+
+bool Retainable::isRetained() const { return this->retaining; }
+
+void Retainable::retainFinished() {
+	// a normal delete tends to cause deref errors in a listview.
+	dynamic_cast<QObject*>(this)->deleteLater();
+}
+
+RetainableLock::~RetainableLock() {
+	if (this->mEnabled && this->mObject) {
+		this->hook->unref();
+	}
+}
+
+QObject* RetainableLock::object() const { return this->mObject; }
+
+void RetainableLock::setObject(QObject* object) {
+	if (object == this->mObject) return;
+
+	if (this->mObject) {
+		QObject::disconnect(this->mObject, nullptr, this, nullptr);
+		if (this->hook->isRetained()) emit this->retainedChanged();
+		this->hook->unref();
+	}
+
+	this->mObject = nullptr;
+	this->hook = nullptr;
+
+	if (object) {
+		if (auto* hook = RetainableHook::getHook(object, true)) {
+			this->mObject = object;
+			this->hook = hook;
+
+			QObject::connect(object, &QObject::destroyed, this, &RetainableLock::onObjectDestroyed);
+			QObject::connect(hook, &RetainableHook::dropped, this, &RetainableLock::dropped);
+			QObject::connect(
+			    hook,
+			    &RetainableHook::aboutToDestroy,
+			    this,
+			    &RetainableLock::aboutToDestroy
+			);
+			QObject::connect(
+			    hook,
+			    &RetainableHook::retainedChanged,
+			    this,
+			    &RetainableLock::retainedChanged
+			);
+			if (hook->isRetained()) emit this->retainedChanged();
+
+			hook->ref();
+		} else {
+			qCritical() << "Tried to set non retainable object" << object << "as the target of" << this;
+		}
+	}
+
+	emit this->objectChanged();
+}
+
+void RetainableLock::onObjectDestroyed() {
+	this->mObject = nullptr;
+	this->hook = nullptr;
+
+	emit this->objectChanged();
+}
+
+bool RetainableLock::locked() const { return this->mEnabled; }
+
+void RetainableLock::setLocked(bool locked) {
+	if (locked == this->mEnabled) return;
+
+	this->mEnabled = locked;
+
+	if (this->mObject) {
+		if (locked) this->hook->ref();
+		else {
+			if (this->hook->isRetained()) emit this->retainedChanged();
+			this->hook->unref();
+		}
+	}
+
+	emit this->lockedChanged();
+}
+
+bool RetainableLock::isRetained() const { return this->mObject && this->hook->isRetained(); }
diff --git a/src/core/retainable.hpp b/src/core/retainable.hpp
new file mode 100644
index 00000000..dfe2e794
--- /dev/null
+++ b/src/core/retainable.hpp
@@ -0,0 +1,162 @@
+#pragma once
+
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+
+class Retainable;
+
+///! Attached object for types that can have delayed destruction.
+/// Retainable works as an attached property that allows objects to be
+/// kept around (retained) after they would normally be destroyed, which
+/// is especially useful for things like exit transitions.
+///
+/// An object that is retainable will have @@Retainable as an attached property.
+/// All retainable objects will say that they are retainable on their respective
+/// typeinfo pages.
+///
+/// > [!INFO] Working directly with @@Retainable is often overly complicated and
+/// > error prone. For this reason @@RetainableLock should
+/// > usually be used instead.
+class RetainableHook: public QObject {
+	Q_OBJECT;
+	/// If the object is currently in a retained state.
+	Q_PROPERTY(bool retained READ isRetained NOTIFY retainedChanged);
+	QML_ATTACHED(RetainableHook);
+	QML_NAMED_ELEMENT(Retainable);
+	QML_UNCREATABLE("Retainable can only be used as an attached object.");
+
+public:
+	static RetainableHook* getHook(QObject* object, bool create = false);
+
+	void destroyOnRelease();
+
+	void ref();
+	void unref();
+
+	/// Hold a lock on the object so it cannot be destroyed.
+	///
+	/// A counter is used to ensure you can lock the object from multiple places
+	/// and it will not be unlocked until the same number of unlocks as locks have occurred.
+	///
+	/// > [!WARNING] It is easy to forget to unlock a locked object.
+	/// > Doing so will create what is effectively a memory leak.
+	/// >
+	/// > Using @@RetainableLock is recommended as it will help
+	/// > avoid this scenario and make misuse more obvious.
+	Q_INVOKABLE void lock();
+	/// Remove a lock on the object. See @@lock() for more information.
+	Q_INVOKABLE void unlock();
+	/// Forcibly remove all locks, destroying the object.
+	///
+	/// @@unlock() should usually be preferred.
+	Q_INVOKABLE void forceUnlock();
+
+	[[nodiscard]] bool isRetained() const;
+
+	static RetainableHook* qmlAttachedProperties(QObject* object);
+
+signals:
+	/// This signal is sent when the object would normally be destroyed.
+	///
+	/// If all signal handlers return and no locks are in place, the object will be destroyed.
+	/// If at least one lock is present the object will be retained until all are removed.
+	void dropped();
+	/// This signal is sent immediately before the object is destroyed.
+	/// At this point destruction cannot be interrupted.
+	void aboutToDestroy();
+
+	void retainedChanged();
+
+private:
+	explicit RetainableHook(QObject* parent): QObject(parent) {}
+
+	void unlocked();
+
+	uint refcount = 0;
+	// tracked separately so a warning can be given when unlock is called too many times,
+	// without affecting other lock sources such as RetainableLock.
+	uint explicitRefcount = 0;
+	Retainable* retainableFacet = nullptr;
+	bool inactive = true;
+
+	friend class Retainable;
+};
+
+class Retainable {
+public:
+	Retainable() = default;
+	virtual ~Retainable() = default;
+	Q_DISABLE_COPY_MOVE(Retainable);
+
+	void retainedDestroy();
+	[[nodiscard]] bool isRetained() const;
+
+protected:
+	virtual void retainFinished();
+
+private:
+	RetainableHook* hook = nullptr;
+	bool retaining = false;
+
+	friend class RetainableHook;
+};
+
+///! A helper for easily using Retainable.
+/// A RetainableLock provides extra safety and ease of use for locking
+/// @@Retainable objects. A retainable object can be locked by multiple
+/// locks at once, and each lock re-exposes relevant properties
+/// of the retained objects.
+///
+/// #### Example
+/// The code below will keep a retainable object alive for as long as the
+/// RetainableLock exists.
+///
+/// ```qml
+/// RetainableLock {
+///   object: aRetainableObject
+///   locked: true
+/// }
+/// ```
+class RetainableLock: public QObject {
+	Q_OBJECT;
+	/// The object to lock. Must be @@Retainable.
+	Q_PROPERTY(QObject* object READ object WRITE setObject NOTIFY objectChanged);
+	/// If the object should be locked.
+	Q_PROPERTY(bool locked READ locked WRITE setLocked NOTIFY lockedChanged);
+	/// If the object is currently in a retained state.
+	Q_PROPERTY(bool retained READ isRetained NOTIFY retainedChanged);
+	QML_ELEMENT;
+
+public:
+	explicit RetainableLock(QObject* parent = nullptr): QObject(parent) {}
+	~RetainableLock() override;
+	Q_DISABLE_COPY_MOVE(RetainableLock);
+
+	[[nodiscard]] QObject* object() const;
+	void setObject(QObject* object);
+
+	[[nodiscard]] bool locked() const;
+	void setLocked(bool locked);
+
+	[[nodiscard]] bool isRetained() const;
+
+signals:
+	/// Rebroadcast of the object's @@Retainable.dropped(s).
+	void dropped();
+	/// Rebroadcast of the object's @@Retainable.aboutToDestroy(s).
+	void aboutToDestroy();
+	void retainedChanged();
+
+	void objectChanged();
+	void lockedChanged();
+
+private slots:
+	void onObjectDestroyed();
+
+private:
+	QObject* mObject = nullptr;
+	RetainableHook* hook = nullptr;
+	bool mEnabled = false;
+};
diff --git a/src/core/ringbuf.hpp b/src/core/ringbuf.hpp
new file mode 100644
index 00000000..a50a56da
--- /dev/null
+++ b/src/core/ringbuf.hpp
@@ -0,0 +1,169 @@
+#pragma once
+
+#include <new>
+#include <tuple>
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qhashfunctions.h>
+#include <qtclasshelpermacros.h>
+#include <qtypes.h>
+
+// NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+
+// capacity 0 buffer cannot be inserted into, only replaced with =
+// this is NOT exception safe for constructors
+template <typename T>
+class RingBuffer {
+public:
+	explicit RingBuffer() = default;
+	explicit RingBuffer(qsizetype capacity): mCapacity(capacity) {
+		if (capacity > 0) this->createData();
+	}
+
+	~RingBuffer() { this->deleteData(); }
+
+	Q_DISABLE_COPY(RingBuffer);
+
+	explicit RingBuffer(RingBuffer&& other) noexcept { *this = std::move(other); }
+
+	RingBuffer& operator=(RingBuffer&& other) noexcept {
+		this->deleteData();
+		this->data = other.data;
+		this->head = other.head;
+		this->mSize = other.mSize;
+		this->mCapacity = other.mCapacity;
+		other.data = nullptr;
+		other.head = -1;
+		return *this;
+	}
+
+	// undefined if capacity is 0
+	template <typename... Args>
+	T& emplace(Args&&... args) {
+		auto i = (this->head + 1) % this->mCapacity;
+
+		if (this->indexIsAllocated(i)) {
+			this->data[i].~T();
+		}
+
+		auto* slot = &this->data[i];
+		new (&this->data[i]) T(std::forward<Args>(args)...);
+
+		this->head = i;
+		if (this->mSize != this->mCapacity) this->mSize = i + 1;
+
+		return *slot;
+	}
+
+	void clear() {
+		if (this->head == -1) return;
+
+		auto i = this->head;
+
+		do {
+			i = (i + 1) % this->mSize;
+			this->data[i].~T();
+		} while (i != this->head);
+
+		this->mSize = 0;
+		this->head = -1;
+	}
+
+	// negative indexes and >size indexes are undefined
+	[[nodiscard]] T& at(qsizetype i) {
+		auto bufferI = (this->head - i) % this->mCapacity;
+		if (bufferI < 0) bufferI += this->mCapacity;
+		return this->data[bufferI];
+	}
+
+	[[nodiscard]] const T& at(qsizetype i) const {
+		return const_cast<RingBuffer<T>*>(this)->at(i); // NOLINT
+	}
+
+	[[nodiscard]] qsizetype size() const { return this->mSize; }
+	[[nodiscard]] qsizetype capacity() const { return this->mCapacity; }
+
+private:
+	void createData() {
+		if (this->data != nullptr) return;
+		this->data =
+		    static_cast<T*>(::operator new(this->mCapacity * sizeof(T), std::align_val_t {alignof(T)}));
+	}
+
+	void deleteData() {
+		this->clear();
+		::operator delete(this->data, std::align_val_t {alignof(T)});
+		this->data = nullptr;
+	}
+
+	bool indexIsAllocated(qsizetype index) {
+		return this->mSize == this->mCapacity || index <= this->head;
+	}
+
+	T* data = nullptr;
+	qsizetype mCapacity = 0;
+	qsizetype head = -1;
+	qsizetype mSize = 0;
+};
+
+// ring buffer with the ability to look up elements by hash (single bucket)
+template <typename T>
+class HashBuffer {
+public:
+	explicit HashBuffer() = default;
+	explicit HashBuffer(qsizetype capacity): ring(capacity) {}
+	~HashBuffer() = default;
+
+	Q_DISABLE_COPY(HashBuffer);
+	explicit HashBuffer(HashBuffer&& other) noexcept: ring(other.ring) {}
+
+	HashBuffer& operator=(HashBuffer&& other) noexcept {
+		this->ring = other.ring;
+		return *this;
+	}
+
+	// returns the index of the given value or -1 if missing
+	[[nodiscard]] qsizetype indexOf(const T& value, T** slot = nullptr) {
+		auto hash = qHash(value);
+
+		for (auto i = 0; i < this->size(); i++) {
+			auto& v = this->ring.at(i);
+			if (hash == v.first && value == v.second) {
+				if (slot != nullptr) *slot = &v.second;
+				return i;
+			}
+		}
+
+		return -1;
+	}
+
+	[[nodiscard]] qsizetype indexOf(const T& value, T const** slot = nullptr) const {
+		return const_cast<HashBuffer<T>*>(this)->indexOf(value, slot); // NOLINT
+	}
+
+	template <typename... Args>
+	T& emplace(Args&&... args) {
+		auto& entry = this->ring.emplace(
+		    std::piecewise_construct,
+		    std::forward_as_tuple(0),
+		    std::forward_as_tuple(std::forward<Args>(args)...)
+		);
+
+		entry.first = qHash(entry.second);
+		return entry.second;
+	}
+
+	void clear() { this->ring.clear(); }
+
+	// negative indexes and >size indexes are undefined
+	[[nodiscard]] T& at(qsizetype i) { return this->ring.at(i).second; }
+	[[nodiscard]] const T& at(qsizetype i) const { return this->ring.at(i).second; }
+	[[nodiscard]] qsizetype size() const { return this->ring.size(); }
+	[[nodiscard]] qsizetype capacity() const { return this->ring.capacity(); }
+
+private:
+	RingBuffer<std::pair<size_t, T>> ring;
+};
+
+// NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic)
diff --git a/src/core/rootwrapper.cpp b/src/core/rootwrapper.cpp
index 16941f5a..25c46ccd 100644
--- a/src/core/rootwrapper.cpp
+++ b/src/core/rootwrapper.cpp
@@ -2,114 +2,190 @@
 #include <cstdlib>
 #include <utility>
 
-#include <qcoreapplication.h>
 #include <qdir.h>
 #include <qfileinfo.h>
+#include <qfilesystemwatcher.h>
 #include <qlogging.h>
 #include <qobject.h>
 #include <qqmlcomponent.h>
 #include <qqmlengine.h>
-#include <qtimer.h>
+#include <qquickitem.h>
+#include <qtmetamacros.h>
 #include <qurl.h>
 
-#include "plugin.hpp"
+#include "../ui/reload_popup.hpp"
+#include "../window/floatingwindow.hpp"
+#include "generation.hpp"
+#include "instanceinfo.hpp"
 #include "qmlglobal.hpp"
-#include "reload.hpp"
-#include "shell.hpp"
-#include "watcher.hpp"
+#include "scan.hpp"
+#include "toolsupport.hpp"
 
-RootWrapper::RootWrapper(QString rootPath)
+RootWrapper::RootWrapper(QString rootPath, QString shellId)
     : QObject(nullptr)
     , rootPath(std::move(rootPath))
-    , engine(this)
+    , shellId(std::move(shellId))
     , originalWorkingDirectory(QDir::current().absolutePath()) {
-	auto* app = QCoreApplication::instance();
-	QObject::connect(&this->engine, &QQmlEngine::quit, app, &QCoreApplication::quit);
-	QObject::connect(&this->engine, &QQmlEngine::exit, app, &QCoreApplication::exit);
+	QObject::connect(
+	    QuickshellSettings::instance(),
+	    &QuickshellSettings::watchFilesChanged,
+	    this,
+	    &RootWrapper::onWatchFilesChanged
+	);
 
-	// clang-format off
-	QObject::connect(QuickshellSettings::instance(), &QuickshellSettings::watchFilesChanged, this, &RootWrapper::onWatchFilesChanged);
-	// clang-format on
+	QObject::connect(
+	    &this->configDirWatcher,
+	    &QFileSystemWatcher::directoryChanged,
+	    this,
+	    &RootWrapper::updateTooling
+	);
 
 	this->reloadGraph(true);
 
-	if (this->root == nullptr) {
-		qCritical() << "could not create scene graph, exiting";
+	if (this->generation == nullptr) {
 		exit(-1); // NOLINT
 	}
 }
 
 RootWrapper::~RootWrapper() {
 	// event loop may no longer be running so deleteLater is not an option
-	delete this->root;
+	if (this->generation != nullptr) {
+		this->generation->shutdown();
+	}
 }
 
 void RootWrapper::reloadGraph(bool hard) {
-	if (this->root != nullptr) {
+	auto rootFile = QFileInfo(this->rootPath);
+	auto rootPath = rootFile.dir();
+	auto scanner = QmlScanner(rootPath);
+	scanner.scanQmlRoot(this->rootPath);
+
+	qs::core::QmlToolingSupport::updateTooling(rootPath, scanner);
+	this->configDirWatcher.addPath(rootPath.path());
+
+	auto* generation = new EngineGeneration(rootPath, std::move(scanner));
+	generation->wrapper = this;
+
+	// todo: move into EngineGeneration
+	if (this->generation != nullptr) {
+		qInfo() << "Reloading configuration...";
 		QuickshellSettings::reset();
-		this->engine.clearComponentCache();
 	}
 
 	QDir::setCurrent(this->originalWorkingDirectory);
 
-	auto component = QQmlComponent(&this->engine, QUrl::fromLocalFile(this->rootPath));
+	QUrl url;
+	url.setScheme("qs");
+	url.setPath("@/qs/" % rootFile.fileName());
+	auto component = QQmlComponent(generation->engine, url);
 
-	auto* obj = component.beginCreate(this->engine.rootContext());
+	if (!component.isReady()) {
+		qCritical() << "Failed to load configuration";
+		QString errorString = "Failed to load configuration";
+
+		auto errors = component.errors();
+		for (auto& error: errors) {
+			const auto& url = error.url();
+			auto rel = url.scheme() == "qs" && url.path().startsWith("@/qs/") ? "@" % url.path().sliced(5)
+			                                                                  : url.toString();
+			auto msg = "  caused by " % rel % '[' % QString::number(error.line()) % ':'
+			         % QString::number(error.column()) % "]: " % error.description();
+			errorString += '\n' % msg;
+			qCritical().noquote() << msg;
+		}
+
+		auto newFiles = generation->scanner.scannedFiles;
+		generation->destroy();
+
+		if (this->generation != nullptr) {
+			if (this->generation->setExtraWatchedFiles(newFiles)) {
+				qInfo() << "Watching additional files picked up in reload for changes...";
+			}
+
+			auto showPopup = true;
+			if (this->generation->qsgInstance != nullptr) {
+				this->generation->qsgInstance->clearReloadPopupInhibit();
+				emit this->generation->qsgInstance->reloadFailed(errorString);
+				showPopup = !this->generation->qsgInstance->isReloadPopupInhibited();
+			}
+
+			if (showPopup)
+				qs::ui::ReloadPopup::spawnPopup(InstanceInfo::CURRENT.instanceId, true, errorString);
+		}
+
+		if (this->generation != nullptr && this->generation->qsgInstance != nullptr) {
+			emit this->generation->qsgInstance->reloadFailed(errorString);
+		}
 
-	if (obj == nullptr) {
-		qWarning() << component.errorString().toStdString().c_str();
-		qWarning() << "failed to create root component";
 		return;
 	}
 
-	auto* newRoot = qobject_cast<ShellRoot*>(obj);
-	if (newRoot == nullptr) {
-		qWarning() << "root component was not a Quickshell.ShellRoot";
-		delete obj;
-		return;
+	auto* newRoot = component.beginCreate(generation->engine->rootContext());
+
+	if (auto* item = qobject_cast<QQuickItem*>(newRoot)) {
+		auto* window = new FloatingWindowInterface();
+		item->setParent(window);
+		item->setParentItem(window->contentItem());
+		window->setWidth(static_cast<int>(item->width()));
+		window->setHeight(static_cast<int>(item->height()));
+		newRoot = window;
 	}
 
+	generation->root = newRoot;
+
 	component.completeCreate();
 
-	auto* oldRoot = this->root;
-	this->root = newRoot;
-
-	this->root->onReload(hard ? nullptr : oldRoot);
-
-	if (oldRoot != nullptr) {
-		oldRoot->deleteLater();
-
-		QTimer::singleShot(0, [this, newRoot]() {
-			if (this->root == newRoot) {
-				QuickshellPlugin::runOnReload();
-				PostReloadHook::postReloadTree(this->root);
-			}
-		});
-	} else {
-		PostReloadHook::postReloadTree(newRoot);
-		QuickshellPlugin::runOnReload();
+	if (this->generation) {
+		QObject::disconnect(this->generation, nullptr, this, nullptr);
 	}
 
+	auto isReload = this->generation != nullptr;
+	generation->onReload(hard ? nullptr : this->generation);
+
+	if (hard && this->generation) {
+		this->generation->destroy();
+	}
+
+	this->generation = generation;
+
+	qInfo() << "Configuration Loaded";
+
+	QObject::connect(this->generation, &QObject::destroyed, this, &RootWrapper::generationDestroyed);
+	QObject::connect(
+	    this->generation,
+	    &EngineGeneration::filesChanged,
+	    this,
+	    &RootWrapper::onWatchedFilesChanged
+	);
+
 	this->onWatchFilesChanged();
+
+	if (isReload) {
+		auto showPopup = true;
+
+		if (this->generation->qsgInstance != nullptr) {
+			this->generation->qsgInstance->clearReloadPopupInhibit();
+			emit this->generation->qsgInstance->reloadCompleted();
+			showPopup = !this->generation->qsgInstance->isReloadPopupInhibited();
+		}
+
+		if (showPopup) qs::ui::ReloadPopup::spawnPopup(InstanceInfo::CURRENT.instanceId, false, "");
+	}
 }
 
+void RootWrapper::generationDestroyed() { this->generation = nullptr; }
+
 void RootWrapper::onWatchFilesChanged() {
 	auto watchFiles = QuickshellSettings::instance()->watchFiles();
-
-	if (watchFiles && this->configWatcher == nullptr) {
-		this->configWatcher = new FiletreeWatcher();
-		this->configWatcher->addPath(QFileInfo(this->rootPath).dir().path());
-
-		QObject::connect(
-		    this->configWatcher,
-		    &FiletreeWatcher::fileChanged,
-		    this,
-		    &RootWrapper::onWatchedFilesChanged
-		);
-	} else if (!watchFiles && this->configWatcher != nullptr) {
-		this->configWatcher->deleteLater();
-		this->configWatcher = nullptr;
+	if (this->generation != nullptr) {
+		this->generation->setWatchingFiles(watchFiles);
 	}
 }
 
 void RootWrapper::onWatchedFilesChanged() { this->reloadGraph(false); }
+
+void RootWrapper::updateTooling() {
+	if (!this->generation) return;
+	auto configDir = QFileInfo(this->rootPath).dir();
+	qs::core::QmlToolingSupport::updateTooling(configDir, this->generation->scanner);
+}
diff --git a/src/core/rootwrapper.hpp b/src/core/rootwrapper.hpp
index 6174c7b1..1425d177 100644
--- a/src/core/rootwrapper.hpp
+++ b/src/core/rootwrapper.hpp
@@ -1,32 +1,34 @@
 #pragma once
 
+#include <qfilesystemwatcher.h>
 #include <qobject.h>
 #include <qqmlengine.h>
 #include <qtclasshelpermacros.h>
 #include <qtmetamacros.h>
 #include <qurl.h>
 
-#include "shell.hpp"
-#include "watcher.hpp"
+#include "generation.hpp"
 
 class RootWrapper: public QObject {
 	Q_OBJECT;
 
 public:
-	explicit RootWrapper(QString rootPath);
+	explicit RootWrapper(QString rootPath, QString shellId);
 	~RootWrapper() override;
 	Q_DISABLE_COPY_MOVE(RootWrapper);
 
 	void reloadGraph(bool hard);
 
 private slots:
+	void generationDestroyed();
 	void onWatchFilesChanged();
 	void onWatchedFilesChanged();
+	void updateTooling();
 
 private:
 	QString rootPath;
-	QQmlEngine engine;
-	ShellRoot* root = nullptr;
-	FiletreeWatcher* configWatcher = nullptr;
+	QString shellId;
+	EngineGeneration* generation = nullptr;
 	QString originalWorkingDirectory;
+	QFileSystemWatcher configDirWatcher;
 };
diff --git a/src/core/scan.cpp b/src/core/scan.cpp
new file mode 100644
index 00000000..4306de73
--- /dev/null
+++ b/src/core/scan.cpp
@@ -0,0 +1,287 @@
+#include "scan.hpp"
+#include <cmath>
+
+#include <qcontainerfwd.h>
+#include <qdir.h>
+#include <qfileinfo.h>
+#include <qjsonarray.h>
+#include <qjsondocument.h>
+#include <qjsonobject.h>
+#include <qjsonvalue.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qpair.h>
+#include <qstring.h>
+#include <qstringliteral.h>
+#include <qtextstream.h>
+
+#include "logcat.hpp"
+
+QS_LOGGING_CATEGORY(logQmlScanner, "quickshell.qmlscanner", QtWarningMsg);
+
+void QmlScanner::scanDir(const QString& path) {
+	if (this->scannedDirs.contains(path)) return;
+	this->scannedDirs.push_back(path);
+
+	qCDebug(logQmlScanner) << "Scanning directory" << path;
+	auto dir = QDir(path);
+
+	struct Entry {
+		QString name;
+		bool singleton = false;
+		bool internal = false;
+	};
+
+	bool seenQmldir = false;
+	auto entries = QVector<Entry>();
+
+	for (auto& name: dir.entryList(QDir::Files | QDir::NoDotAndDotDot)) {
+		if (name == "qmldir") {
+			qCDebug(logQmlScanner
+			) << "Found qmldir file, qmldir synthesization will be disabled for directory"
+			  << path;
+			seenQmldir = true;
+		} else if (name.at(0).isUpper() && name.endsWith(".qml")) {
+			auto& entry = entries.emplaceBack();
+
+			if (this->scanQmlFile(dir.filePath(name), entry.singleton, entry.internal)) {
+				entry.name = name;
+			} else {
+				entries.pop_back();
+			}
+		} else if (name.at(0).isUpper() && name.endsWith(".qml.json")) {
+			if (this->scanQmlJson(dir.filePath(name))) {
+				entries.push_back({
+				    .name = name.first(name.length() - 5),
+				    .singleton = true,
+				});
+			}
+		}
+	}
+
+	if (!seenQmldir) {
+		qCDebug(logQmlScanner) << "Synthesizing qmldir for directory" << path;
+
+		QString qmldir;
+		auto stream = QTextStream(&qmldir);
+
+		// cant derive a module name if not in shell path
+		if (path.startsWith(this->rootPath.path())) {
+			auto end = path.sliced(this->rootPath.path().length());
+
+			// verify we have a valid module name.
+			for (auto& c: end) {
+				if (c == '/') c = '.';
+				else if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')
+				         || c == '_')
+				{
+				} else {
+					qCWarning(logQmlScanner) << "Module path contains invalid characters for a module name: "
+					                         << path.sliced(this->rootPath.path().length());
+					goto skipadd;
+				}
+			}
+
+			stream << "module qs" << end << '\n';
+		skipadd:;
+		} else {
+			qCWarning(logQmlScanner) << "Module path" << path << "is outside of the config folder.";
+		}
+
+		for (const auto& entry: entries) {
+			if (entry.internal) stream << "internal ";
+			if (entry.singleton) stream << "singleton ";
+			stream << entry.name.sliced(0, entry.name.length() - 4) << " 1.0 " << entry.name << '\n';
+		}
+
+		qCDebug(logQmlScanner) << "Synthesized qmldir for" << path << qPrintable("\n" + qmldir);
+		this->fileIntercepts.insert(QDir(path).filePath("qmldir"), qmldir);
+	}
+}
+
+bool QmlScanner::scanQmlFile(const QString& path, bool& singleton, bool& internal) {
+	if (this->scannedFiles.contains(path)) return false;
+	this->scannedFiles.push_back(path);
+
+	qCDebug(logQmlScanner) << "Scanning qml file" << path;
+
+	auto file = QFile(path);
+	if (!file.open(QFile::ReadOnly | QFile::Text)) {
+		qCWarning(logQmlScanner) << "Failed to open file" << path;
+		return false;
+	}
+
+	auto stream = QTextStream(&file);
+	auto imports = QVector<QString>();
+
+	while (!stream.atEnd()) {
+		auto line = stream.readLine().trimmed();
+		if (!singleton && line == "pragma Singleton") {
+			singleton = true;
+		} else if (!internal && line == "//@ pragma Internal") {
+			internal = true;
+		} else if (line.startsWith("import")) {
+			// we dont care about "import qs" as we always load the root folder
+			if (auto importCursor = line.indexOf(" qs."); importCursor != -1) {
+				importCursor += 4;
+				QString path;
+
+				while (importCursor != line.length()) {
+					auto c = line.at(importCursor);
+					if (c == '.') c = '/';
+					else if (c == ' ') break;
+					else if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9')
+					         || c == '_')
+					{
+					} else {
+						qCWarning(logQmlScanner) << "Import line contains invalid characters: " << line;
+						goto next;
+					}
+
+					path.append(c);
+					importCursor += 1;
+				}
+
+				imports.append(this->rootPath.filePath(path));
+			} else if (auto startQuot = line.indexOf('"');
+			           startQuot != -1 && line.length() >= startQuot + 3)
+			{
+				auto endQuot = line.indexOf('"', startQuot + 1);
+				if (endQuot == -1) continue;
+
+				auto name = line.sliced(startQuot + 1, endQuot - startQuot - 1);
+				imports.push_back(name);
+			}
+		} else if (line.contains('{')) break;
+
+	next:;
+	}
+
+	file.close();
+
+	if (logQmlScanner().isDebugEnabled() && !imports.isEmpty()) {
+		qCDebug(logQmlScanner) << "Found imports" << imports;
+	}
+
+	auto currentdir = QDir(QFileInfo(path).canonicalPath());
+
+	// the root can never be a singleton so it dosent matter if we skip it
+	this->scanDir(currentdir.path());
+
+	for (auto& import: imports) {
+		QString ipath;
+		if (import.startsWith("root:")) {
+			auto path = import.sliced(5);
+			if (path.startsWith('/')) path = path.sliced(1);
+			ipath = this->rootPath.filePath(path);
+		} else {
+			ipath = currentdir.filePath(import);
+		}
+
+		auto pathInfo = QFileInfo(ipath);
+		auto cpath = pathInfo.canonicalFilePath();
+
+		if (cpath.isEmpty()) {
+			qCWarning(logQmlScanner) << "Ignoring unresolvable import" << ipath << "from" << path;
+			continue;
+		}
+
+		if (!pathInfo.isDir()) {
+			qCDebug(logQmlScanner) << "Ignoring non-directory import" << ipath << "from" << path;
+			continue;
+		}
+
+		if (import.endsWith(".js")) this->scannedFiles.push_back(cpath);
+		else this->scanDir(cpath);
+	}
+
+	return true;
+}
+
+void QmlScanner::scanQmlRoot(const QString& path) {
+	bool singleton = false;
+	bool internal = false;
+	this->scanQmlFile(path, singleton, internal);
+}
+
+bool QmlScanner::scanQmlJson(const QString& path) {
+	qCDebug(logQmlScanner) << "Scanning qml.json file" << path;
+
+	auto file = QFile(path);
+	if (!file.open(QFile::ReadOnly | QFile::Text)) {
+		qCWarning(logQmlScanner) << "Failed to open file" << path;
+		return false;
+	}
+
+	auto data = file.readAll();
+
+	// Importing this makes CI builds fail for some reason.
+	QJsonParseError error; // NOLINT (misc-include-cleaner)
+	auto json = QJsonDocument::fromJson(data, &error);
+
+	if (error.error != QJsonParseError::NoError) {
+		qCCritical(logQmlScanner).nospace()
+		    << "Failed to parse qml.json file at " << path << ": " << error.errorString();
+		return false;
+	}
+
+	const QString body =
+	    "pragma Singleton\nimport QtQuick as Q\n\n" % QmlScanner::jsonToQml(json.object()).second;
+
+	qCDebug(logQmlScanner) << "Synthesized qml file for" << path << qPrintable("\n" + body);
+
+	this->fileIntercepts.insert(path.first(path.length() - 5), body);
+	this->scannedFiles.push_back(path);
+	return true;
+}
+
+QPair<QString, QString> QmlScanner::jsonToQml(const QJsonValue& value, int indent) {
+	if (value.isObject()) {
+		const auto& object = value.toObject();
+
+		auto valIter = object.constBegin();
+
+		QString accum = "Q.QtObject {\n";
+		for (const auto& key: object.keys()) {
+			const auto& val = *valIter++;
+			auto [type, repr] = QmlScanner::jsonToQml(val, indent + 2);
+			accum += QString(' ').repeated(indent + 2) % "readonly property " % type % ' ' % key % ": "
+			       % repr % ";\n";
+		}
+
+		accum += QString(' ').repeated(indent) % '}';
+		return qMakePair(QStringLiteral("Q.QtObject"), accum);
+	} else if (value.isArray()) {
+		return qMakePair(
+		    QStringLiteral("var"),
+		    QJsonDocument(value.toArray()).toJson(QJsonDocument::Compact)
+		);
+	} else if (value.isString()) {
+		const auto& str = value.toString();
+
+		if (str.startsWith('#') && (str.length() == 4 || str.length() == 7 || str.length() == 9)) {
+			for (auto c: str.sliced(1)) {
+				if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) {
+					goto noncolor;
+				}
+			}
+
+			return qMakePair(QStringLiteral("Q.color"), '"' % str % '"');
+		}
+
+	noncolor:
+		return qMakePair(QStringLiteral("string"), '"' % QString(str).replace("\"", "\\\"") % '"');
+	} else if (value.isDouble()) {
+		auto num = value.toDouble();
+		double whole = 0;
+		if (std::modf(num, &whole) == 0.0) {
+			return qMakePair(QStringLiteral("int"), QString::number(static_cast<int>(whole)));
+		} else {
+			return qMakePair(QStringLiteral("real"), QString::number(num));
+		}
+	} else if (value.isBool()) {
+		return qMakePair(QStringLiteral("bool"), value.toBool() ? "true" : "false");
+	} else {
+		return qMakePair(QStringLiteral("var"), "null");
+	}
+}
diff --git a/src/core/scan.hpp b/src/core/scan.hpp
new file mode 100644
index 00000000..1d3be850
--- /dev/null
+++ b/src/core/scan.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qdir.h>
+#include <qhash.h>
+#include <qloggingcategory.h>
+#include <qvector.h>
+
+#include "logcat.hpp"
+
+QS_DECLARE_LOGGING_CATEGORY(logQmlScanner);
+
+// expects canonical paths
+class QmlScanner {
+public:
+	QmlScanner() = default;
+	QmlScanner(const QDir& rootPath): rootPath(rootPath) {}
+
+	// path must be canonical
+	void scanDir(const QString& path);
+
+	void scanQmlRoot(const QString& path);
+
+	QVector<QString> scannedDirs;
+	QVector<QString> scannedFiles;
+	QHash<QString, QString> fileIntercepts;
+
+private:
+	QDir rootPath;
+
+	bool scanQmlFile(const QString& path, bool& singleton, bool& internal);
+	bool scanQmlJson(const QString& path);
+	[[nodiscard]] static QPair<QString, QString> jsonToQml(const QJsonValue& value, int indent = 0);
+};
diff --git a/src/core/scriptmodel.cpp b/src/core/scriptmodel.cpp
new file mode 100644
index 00000000..6837c4ab
--- /dev/null
+++ b/src/core/scriptmodel.cpp
@@ -0,0 +1,182 @@
+#include "scriptmodel.hpp"
+#include <algorithm>
+#include <iterator>
+
+#include <qabstractitemmodel.h>
+#include <qcontainerfwd.h>
+#include <qlist.h>
+#include <qnamespace.h>
+#include <qtmetamacros.h>
+#include <qtversionchecks.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+void ScriptModel::updateValuesUnique(const QVariantList& newValues) {
+	this->hasActiveIterators = true;
+	this->mValues.reserve(newValues.size());
+
+	auto iter = this->mValues.begin();
+	auto newIter = newValues.begin();
+
+	// TODO: cache this
+	auto getCmpKey = [&](const QVariant& v) {
+		if (v.canConvert<QVariantMap>()) {
+			auto vMap = v.value<QVariantMap>();
+			if (vMap.contains(this->cmpKey)) {
+				return vMap.value(this->cmpKey);
+			}
+		}
+
+		return v;
+	};
+
+	auto variantCmp = [&](const QVariant& a, const QVariant& b) {
+		if (!this->cmpKey.isEmpty()) return getCmpKey(a) == getCmpKey(b);
+		else return a == b;
+	};
+
+	auto eqPredicate = [&](const QVariant& b) {
+		return [&](const QVariant& a) { return variantCmp(a, b); };
+	};
+
+	while (true) {
+		if (newIter == newValues.end()) {
+			if (iter == this->mValues.end()) break;
+
+			auto startIndex = static_cast<qint32>(newValues.length());
+			auto endIndex = static_cast<qint32>(this->mValues.length() - 1);
+
+			this->beginRemoveRows(QModelIndex(), startIndex, endIndex);
+			this->mValues.erase(iter, this->mValues.end());
+			this->endRemoveRows();
+
+			break;
+		} else if (iter == this->mValues.end()) {
+			// Prior branch ensures length is at least 1.
+			auto startIndex = static_cast<qint32>(this->mValues.length());
+			auto endIndex = static_cast<qint32>(newValues.length() - 1);
+
+			this->beginInsertRows(QModelIndex(), startIndex, endIndex);
+			this->mValues.append(newValues.sliced(startIndex));
+			this->endInsertRows();
+
+			break;
+		} else if (!variantCmp(*newIter, *iter)) {
+			auto oldIter = std::find_if(iter, this->mValues.end(), eqPredicate(*newIter));
+
+			if (oldIter != this->mValues.end()) {
+				if (std::find_if(newIter, newValues.end(), eqPredicate(*iter)) == newValues.end()) {
+					// Remove any entries we would otherwise move around that aren't in the new list.
+					auto startIter = iter;
+
+					do {
+						++iter;
+					} while (iter != this->mValues.end()
+					         && std::find_if(newIter, newValues.end(), eqPredicate(*iter)) == newValues.end()
+					);
+
+					auto index = static_cast<qint32>(std::distance(this->mValues.begin(), iter));
+					auto startIndex = static_cast<qint32>(std::distance(this->mValues.begin(), startIter));
+
+					this->beginRemoveRows(QModelIndex(), startIndex, index - 1);
+					iter = this->mValues.erase(startIter, iter);
+					this->endRemoveRows();
+				} else {
+					// Advance iters to capture a whole move sequence as a single operation if possible.
+					auto oldStartIter = oldIter;
+					do {
+						++oldIter;
+						++newIter;
+					} while (oldIter != this->mValues.end() && newIter != newValues.end()
+					         && variantCmp(*oldIter, *newIter));
+
+					auto index = static_cast<qint32>(std::distance(this->mValues.begin(), iter));
+					auto oldStartIndex =
+					    static_cast<qint32>(std::distance(this->mValues.begin(), oldStartIter));
+					auto oldIndex = static_cast<qint32>(std::distance(this->mValues.begin(), oldIter));
+					auto len = oldIndex - oldStartIndex;
+
+					this->beginMoveRows(QModelIndex(), oldStartIndex, oldIndex - 1, QModelIndex(), index);
+
+					// While it is possible to optimize this further, it is currently not worth the time.
+					for (auto i = 0; i != len; i++) {
+						this->mValues.move(oldStartIndex + i, index + i);
+					}
+
+					iter = this->mValues.begin() + (index + len);
+					this->endMoveRows();
+				}
+			} else {
+				auto startNewIter = newIter;
+
+				do {
+					newIter++;
+				} while (newIter != newValues.end()
+				         && std::find_if(iter, this->mValues.end(), eqPredicate(*newIter))
+				                == this->mValues.end());
+
+				auto index = static_cast<qint32>(std::distance(this->mValues.begin(), iter));
+				auto newIndex = static_cast<qint32>(std::distance(newValues.begin(), newIter));
+				auto startNewIndex = static_cast<qint32>(std::distance(newValues.begin(), startNewIter));
+				auto len = newIndex - startNewIndex;
+
+				this->beginInsertRows(QModelIndex(), index, index + len - 1);
+#if QT_VERSION <= QT_VERSION_CHECK(6, 8, 0)
+				this->mValues.resize(this->mValues.length() + len);
+#else
+				this->mValues.resizeForOverwrite(this->mValues.length() + len);
+#endif
+				iter = this->mValues.begin() + index; // invalidated
+				std::move_backward(iter, this->mValues.end() - len, this->mValues.end());
+				iter = std::copy(startNewIter, newIter, iter);
+				this->endInsertRows();
+			}
+		} else if (*newIter != *iter) {
+			auto first = static_cast<qint32>(std::distance(this->mValues.begin(), iter));
+			auto index = first;
+
+			do {
+				this->mValues.replace(index, *newIter);
+				++iter;
+				++newIter;
+				++index;
+			} while (iter != this->mValues.end() && newIter != newValues.end() && *newIter != *iter);
+
+			this->dataChanged(
+			    this->index(first, 0, QModelIndex()),
+			    this->index(index - 1, 0, QModelIndex()),
+			    {Qt::UserRole}
+			);
+		} else {
+			++iter;
+			++newIter;
+		}
+	}
+
+	this->hasActiveIterators = false;
+}
+
+void ScriptModel::setValues(const QVariantList& newValues) {
+	if (newValues == this->mValues) return;
+	this->updateValuesUnique(newValues);
+	emit this->valuesChanged();
+}
+
+void ScriptModel::setObjectProp(const QString& objectProp) {
+	if (objectProp == this->cmpKey) return;
+	this->cmpKey = objectProp;
+	this->updateValuesUnique(this->mValues);
+	emit this->objectPropChanged();
+}
+
+qint32 ScriptModel::rowCount(const QModelIndex& parent) const {
+	if (parent != QModelIndex()) return 0;
+	return static_cast<qint32>(this->mValues.length());
+}
+
+QVariant ScriptModel::data(const QModelIndex& index, qint32 role) const {
+	if (role != Qt::UserRole) return QVariant();
+	return this->mValues.at(index.row());
+}
+
+QHash<int, QByteArray> ScriptModel::roleNames() const { return {{Qt::UserRole, "modelData"}}; }
diff --git a/src/core/scriptmodel.hpp b/src/core/scriptmodel.hpp
new file mode 100644
index 00000000..10916f6c
--- /dev/null
+++ b/src/core/scriptmodel.hpp
@@ -0,0 +1,106 @@
+#pragma once
+
+#include <qabstractitemmodel.h>
+#include <qcontainerfwd.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+
+///! QML model reflecting a javascript expression
+/// ScriptModel is a QML [Data Model] that generates model operations based on changes
+/// to a javascript expression attached to @@values.
+///
+/// ### When should I use this
+/// ScriptModel should be used when you would otherwise use a javascript expression as a model,
+/// [QAbstractItemModel] is accepted, and the data is likely to change over the lifetime of the program.
+///
+/// When directly using a javascript expression as a model, types like @@QtQuick.Repeater or @@QtQuick.ListView
+/// will destroy all created delegates, and re-create the entire list. In the case of @@QtQuick.ListView this
+/// will also prevent animations from working. If you wrap your expression with ScriptModel, only new items
+/// will be created, and ListView animations will work as expected.
+///
+/// ### Example
+/// ```qml
+/// // Will cause all delegates to be re-created every time filterText changes.
+/// @@QtQuick.Repeater {
+///   model: myList.filter(entry => entry.name.startsWith(filterText))
+///   delegate: // ...
+/// }
+///
+/// // Will add and remove delegates only when required.
+/// @@QtQuick.Repeater {
+///   model: ScriptModel {
+///     values: myList.filter(entry => entry.name.startsWith(filterText))
+///   }
+///
+///   delegate: // ...
+/// }
+/// ```
+/// [QAbstractItemModel]: https://doc.qt.io/qt-6/qabstractitemmodel.html
+/// [Data Model]: https://doc.qt.io/qt-6/qtquick-modelviewsdata-modelview.html#qml-data-models
+class ScriptModel: public QAbstractListModel {
+	Q_OBJECT;
+	/// The list of values to reflect in the model.
+	/// > [!WARNING] ScriptModel currently only works with lists of *unique* values.
+	/// > There must not be any duplicates in the given list, or behavior of the model is undefined.
+	///
+	/// > [!TIP] @@ObjectModel$s supplied by Quickshell types will only contain unique values,
+	/// > and can be used like so:
+	/// >
+	/// > ```qml
+	/// > ScriptModel {
+	/// >   values: DesktopEntries.applications.values.filter(...)
+	/// > }
+	/// > ```
+	/// >
+	/// > Note that we are using @@ObjectModel.values because it will cause @@ScriptModel.values
+	/// > to receive an update on change.
+	///
+	/// > [!TIP] Most lists exposed by Quickshell are read-only. Some operations like `sort()`
+	/// > act on a list in-place and cannot be used directly on a list exposed by Quickshell.
+	/// > You can copy a list using spread syntax: `[...variable]` instead of `variable`.
+	/// >
+	/// > For example:
+	/// > ```qml
+	/// > ScriptModel {
+	/// >   values: [...DesktopEntries.applications.values].sort(...)
+	/// > }
+	/// > ```
+	Q_PROPERTY(QVariantList values READ values WRITE setValues NOTIFY valuesChanged);
+	/// The property that javascript objects passed into the model will be compared with.
+	///
+	/// For example, if `objectProp` is `"myprop"` then `{ myprop: "a", other: "y" }` and
+	/// `{ myprop: "a", other: "z" }` will be considered equal.
+	///
+	/// Defaults to `""`, meaning no key.
+	Q_PROPERTY(QString objectProp READ objectProp WRITE setObjectProp NOTIFY objectPropChanged);
+	QML_ELEMENT;
+
+public:
+	[[nodiscard]] QVariantList values() const {
+		auto values = this->mValues;
+		// If not detached, the QML engine will invalidate iterators in updateValuesUnique.
+		if (this->hasActiveIterators) values.detach();
+		return values;
+	}
+
+	void setValues(const QVariantList& newValues);
+
+	[[nodiscard]] QString objectProp() const { return this->cmpKey; }
+	void setObjectProp(const QString& objectProp);
+
+	[[nodiscard]] qint32 rowCount(const QModelIndex& parent) const override;
+	[[nodiscard]] QVariant data(const QModelIndex& index, qint32 role) const override;
+	[[nodiscard]] QHash<int, QByteArray> roleNames() const override;
+
+signals:
+	void valuesChanged();
+	void objectPropChanged();
+
+private:
+	QVariantList mValues;
+	QString cmpKey;
+	bool hasActiveIterators = false;
+
+	void updateValuesUnique(const QVariantList& newValues);
+};
diff --git a/src/core/shell.hpp b/src/core/shell.hpp
index 807f0275..66b6ef6a 100644
--- a/src/core/shell.hpp
+++ b/src/core/shell.hpp
@@ -8,7 +8,7 @@
 #include "qmlglobal.hpp"
 #include "reload.hpp"
 
-///! Root config element
+///! Optional root config element, allowing some settings to be specified inline.
 class ShellRoot: public ReloadPropagator {
 	Q_OBJECT;
 	Q_PROPERTY(QuickshellSettings* settings READ settings CONSTANT);
diff --git a/src/core/singleton.cpp b/src/core/singleton.cpp
new file mode 100644
index 00000000..15668c98
--- /dev/null
+++ b/src/core/singleton.cpp
@@ -0,0 +1,53 @@
+#include "singleton.hpp"
+
+#include <qhash.h>
+#include <qlogging.h>
+#include <qobject.h>
+#include <qqmlcontext.h>
+#include <qqmlengine.h>
+
+#include "generation.hpp"
+#include "reload.hpp"
+
+void Singleton::componentComplete() {
+	auto* context = QQmlEngine::contextForObject(this);
+
+	if (context == nullptr) {
+		qWarning() << "Not registering singleton not created in the qml context:" << this;
+		return;
+	}
+
+	auto url = context->baseUrl();
+
+	if (this->parent() != nullptr || context->contextObject() != this) {
+		qWarning() << "Tried to register singleton" << this
+		           << "which is not the root component of its file" << url;
+		return;
+	}
+
+	auto* generation = EngineGeneration::findObjectGeneration(this);
+
+	if (generation == nullptr) {
+		qWarning() << "Tried to register singleton" << this
+		           << "which has no associated engine generation" << url;
+		return;
+	}
+
+	generation->singletonRegistry.registerSingleton(url, this);
+	this->ReloadPropagator::componentComplete();
+}
+
+void SingletonRegistry::registerSingleton(const QUrl& url, Singleton* singleton) {
+	if (this->registry.contains(url)) {
+		qWarning() << "Tried to register singleton twice for the same file" << url;
+		return;
+	}
+
+	this->registry.insert(url, singleton);
+}
+
+void SingletonRegistry::onReload(SingletonRegistry* old) {
+	for (auto [url, singleton]: this->registry.asKeyValueRange()) {
+		singleton->reload(old == nullptr ? nullptr : old->registry.value(url));
+	}
+}
diff --git a/src/core/singleton.hpp b/src/core/singleton.hpp
new file mode 100644
index 00000000..200c97f1
--- /dev/null
+++ b/src/core/singleton.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <qhash.h>
+#include <qobject.h>
+#include <qqmlengine.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qurl.h>
+
+#include "reload.hpp"
+
+///! The root component for reloadable singletons.
+/// All singletons should inherit from this type.
+class Singleton: public ReloadPropagator {
+	Q_OBJECT;
+	QML_ELEMENT;
+
+public:
+	void componentComplete() override;
+};
+
+class SingletonRegistry {
+public:
+	SingletonRegistry() = default;
+
+	void registerSingleton(const QUrl& url, Singleton* singleton);
+	void onReload(SingletonRegistry* old);
+
+private:
+	QHash<QUrl, Singleton*> registry;
+};
diff --git a/src/core/stacklist.hpp b/src/core/stacklist.hpp
new file mode 100644
index 00000000..41dc58ee
--- /dev/null
+++ b/src/core/stacklist.hpp
@@ -0,0 +1,173 @@
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <vector>
+
+#include <qlist.h>
+#include <qtypes.h>
+
+template <class T, size_t N>
+class StackList {
+public:
+	T& operator[](size_t i) {
+		if (i < N) {
+			return this->array[i];
+		} else {
+			return this->vec[i - N];
+		}
+	}
+
+	const T& operator[](size_t i) const {
+		return const_cast<StackList<T, N>*>(this)->operator[](i); // NOLINT
+	}
+
+	void push(const T& value) {
+		if (this->size < N) {
+			this->array[this->size] = value;
+		} else {
+			this->vec.push_back(value);
+		}
+
+		++this->size;
+	}
+
+	[[nodiscard]] size_t length() const { return this->size; }
+	[[nodiscard]] bool isEmpty() const { return this->size == 0; }
+
+	[[nodiscard]] bool operator==(const StackList<T, N>& other) const {
+		if (other.size != this->size) return false;
+
+		for (size_t i = 0; i != this->size; ++i) {
+			if (this->operator[](i) != other[i]) return false;
+		}
+
+		return true;
+	}
+
+	[[nodiscard]] QList<T> toList() const {
+		QList<T> list;
+		list.reserve(this->size);
+
+		for (const auto& entry: *this) {
+			list.push_back(entry);
+		}
+
+		return list;
+	}
+
+	template <typename Self, typename ListPtr, typename IT>
+	struct BaseIterator {
+		using iterator_category = std::bidirectional_iterator_tag;
+		using difference_type = int64_t;
+		using value_type = IT;
+		using pointer = IT*;
+		using reference = IT&;
+
+		BaseIterator() = default;
+		explicit BaseIterator(ListPtr list, size_t i): list(list), i(i) {}
+
+		reference operator*() const { return this->list->operator[](this->i); }
+		pointer operator->() const { return &**this; }
+
+		Self& operator++() {
+			++this->i;
+			return *static_cast<Self*>(this);
+		}
+
+		Self& operator--() {
+			--this->i;
+			return *static_cast<Self*>(this);
+		}
+
+		Self operator++(int) {
+			auto v = *this;
+			this->operator++();
+			return v;
+		}
+
+		Self operator--(int) {
+			auto v = *this;
+			this->operator--();
+			return v;
+		}
+
+		difference_type operator-(const Self& other) {
+			return static_cast<int64_t>(this->i) - static_cast<int64_t>(other.i);
+		}
+
+		Self& operator+(difference_type offset) {
+			return Self(this->list, static_cast<int64_t>(this->i) + offset);
+		}
+
+		[[nodiscard]] bool operator==(const Self& other) const {
+			return this->list == other.list && this->i == other.i;
+		}
+
+		[[nodiscard]] bool operator!=(const Self& other) const { return !(*this == other); }
+
+	private:
+		ListPtr list = nullptr;
+		size_t i = 0;
+	};
+
+	struct Iterator: public BaseIterator<Iterator, StackList<T, N>*, T> {
+		Iterator() = default;
+		Iterator(StackList<T, N>* list, size_t i)
+		    : BaseIterator<Iterator, StackList<T, N>*, T>(list, i) {}
+	};
+
+	struct ConstIterator: public BaseIterator<ConstIterator, const StackList<T, N>*, const T> {
+		ConstIterator() = default;
+		ConstIterator(const StackList<T, N>* list, size_t i)
+		    : BaseIterator<ConstIterator, const StackList<T, N>*, const T>(list, i) {}
+	};
+
+	[[nodiscard]] Iterator begin() { return Iterator(this, 0); }
+	[[nodiscard]] Iterator end() { return Iterator(this, this->size); }
+
+	[[nodiscard]] ConstIterator begin() const { return ConstIterator(this, 0); }
+	[[nodiscard]] ConstIterator end() const { return ConstIterator(this, this->size); }
+
+	[[nodiscard]] bool isContiguous() const { return this->vec.empty(); }
+	[[nodiscard]] const T* pArray() const { return this->array.data(); }
+	[[nodiscard]] size_t dataLength() const { return this->size * sizeof(T); }
+
+	const T* populateAlloc(void* alloc) const {
+		auto arraylen = std::min(this->size, N) * sizeof(T);
+		memcpy(alloc, this->array.data(), arraylen);
+
+		if (!this->vec.empty()) {
+			memcpy(
+			    static_cast<char*>(alloc) + arraylen, // NOLINT
+			    this->vec.data(),
+			    this->vec.size() * sizeof(T)
+			);
+		}
+
+		return static_cast<T*>(alloc);
+	}
+
+private:
+	std::array<T, N> array {};
+	std::vector<T> vec;
+	size_t size = 0;
+};
+
+// might be incorrectly aligned depending on type
+// #define STACKLIST_ALLOCA_VIEW(list) ((list).isContiguous() ? (list).pArray() : (list).populateAlloc(alloca((list).dataLength())))
+
+// NOLINTBEGIN
+#define STACKLIST_VLA_VIEW(type, list, var)                                                        \
+	const type* var;                                                                                 \
+	type var##Data[(list).length()];                                                                 \
+	if ((list).isContiguous()) {                                                                     \
+		(var) = (list).pArray();                                                                       \
+	} else {                                                                                         \
+		(list).populateAlloc(var##Data);                                                               \
+		(var) = var##Data;                                                                             \
+	}
+// NOLINTEND
diff --git a/src/core/test/CMakeLists.txt b/src/core/test/CMakeLists.txt
new file mode 100644
index 00000000..4e66c627
--- /dev/null
+++ b/src/core/test/CMakeLists.txt
@@ -0,0 +1,10 @@
+function (qs_test name)
+	add_executable(${name} ${ARGN})
+	target_link_libraries(${name} PRIVATE Qt::Quick Qt::Test quickshell-core quickshell-window quickshell-ui quickshell-io)
+	add_test(NAME ${name} WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" COMMAND $<TARGET_FILE:${name}>)
+endfunction()
+
+qs_test(transformwatcher transformwatcher.cpp)
+qs_test(ringbuffer ringbuf.cpp)
+qs_test(scriptmodel scriptmodel.cpp)
+qs_test(stacklist stacklist.cpp)
diff --git a/src/core/test/popupwindow.hpp b/src/core/test/popupwindow.hpp
new file mode 100644
index 00000000..e69de29b
diff --git a/src/core/test/ringbuf.cpp b/src/core/test/ringbuf.cpp
new file mode 100644
index 00000000..4f114796
--- /dev/null
+++ b/src/core/test/ringbuf.cpp
@@ -0,0 +1,125 @@
+#include "ringbuf.hpp"
+#include <utility>
+
+#include <qlogging.h>
+#include <qtest.h>
+#include <qtestcase.h>
+#include <qtypes.h>
+
+#include "../ringbuf.hpp"
+
+TestObject::TestObject(quint32* count): count(count) {
+	(*this->count)++;
+	qDebug() << "Created TestObject" << this << "- count is now" << *this->count;
+}
+
+TestObject::~TestObject() {
+	(*this->count)--;
+	qDebug() << "Destroyed TestObject" << this << "- count is now" << *this->count;
+}
+
+void TestRingBuffer::fill() {
+	quint32 counter = 0;
+	auto rb = RingBuffer<TestObject>(3);
+	QCOMPARE(rb.capacity(), 3);
+
+	qInfo() << "adding test objects";
+	auto* n1 = &rb.emplace(&counter);
+	auto* n2 = &rb.emplace(&counter);
+	auto* n3 = &rb.emplace(&counter);
+	QCOMPARE(counter, 3);
+	QCOMPARE(rb.size(), 3);
+	QCOMPARE(&rb.at(0), n3);
+	QCOMPARE(&rb.at(1), n2);
+	QCOMPARE(&rb.at(2), n1);
+
+	qInfo() << "replacing last object with new one";
+	auto* n4 = &rb.emplace(&counter);
+	QCOMPARE(counter, 3);
+	QCOMPARE(rb.size(), 3);
+	QCOMPARE(&rb.at(0), n4);
+	QCOMPARE(&rb.at(1), n3);
+	QCOMPARE(&rb.at(2), n2);
+
+	qInfo() << "replacing the rest";
+	auto* n5 = &rb.emplace(&counter);
+	auto* n6 = &rb.emplace(&counter);
+	QCOMPARE(counter, 3);
+	QCOMPARE(rb.size(), 3);
+	QCOMPARE(&rb.at(0), n6);
+	QCOMPARE(&rb.at(1), n5);
+	QCOMPARE(&rb.at(2), n4);
+
+	qInfo() << "clearing buffer";
+	rb.clear();
+	QCOMPARE(counter, 0);
+	QCOMPARE(rb.size(), 0);
+}
+
+void TestRingBuffer::clearPartial() {
+	quint32 counter = 0;
+	auto rb = RingBuffer<TestObject>(2);
+
+	qInfo() << "adding object to buffer";
+	auto* n1 = &rb.emplace(&counter);
+	QCOMPARE(counter, 1);
+	QCOMPARE(rb.size(), 1);
+	QCOMPARE(&rb.at(0), n1);
+
+	qInfo() << "clearing buffer";
+	rb.clear();
+	QCOMPARE(counter, 0);
+	QCOMPARE(rb.size(), 0);
+}
+
+void TestRingBuffer::move() {
+	quint32 counter = 0;
+
+	{
+		auto rb1 = RingBuffer<TestObject>(1);
+
+		qInfo() << "adding object to first buffer";
+		auto* n1 = &rb1.emplace(&counter);
+		QCOMPARE(counter, 1);
+		QCOMPARE(rb1.size(), 1);
+		QCOMPARE(&rb1.at(0), n1);
+
+		qInfo() << "move constructing new buffer";
+		auto rb2 = RingBuffer<TestObject>(std::move(rb1));
+		QCOMPARE(counter, 1);
+		QCOMPARE(rb2.size(), 1);
+		QCOMPARE(&rb2.at(0), n1);
+
+		qInfo() << "move assigning new buffer";
+		auto rb3 = RingBuffer<TestObject>();
+		rb3 = std::move(rb2);
+		QCOMPARE(counter, 1);
+		QCOMPARE(rb3.size(), 1);
+		QCOMPARE(&rb3.at(0), n1);
+	}
+
+	QCOMPARE(counter, 0);
+}
+
+void TestRingBuffer::hashLookup() {
+	auto hb = HashBuffer<int>(3);
+
+	qInfo() << "inserting 1,2,3 into HashBuffer";
+	hb.emplace(1);
+	hb.emplace(2);
+	hb.emplace(3);
+
+	qInfo() << "checking lookups";
+	QCOMPARE(hb.indexOf(3), 0);
+	QCOMPARE(hb.indexOf(2), 1);
+	QCOMPARE(hb.indexOf(1), 2);
+
+	qInfo() << "adding 4";
+	hb.emplace(4);
+	QCOMPARE(hb.indexOf(4), 0);
+	QCOMPARE(hb.indexOf(3), 1);
+	QCOMPARE(hb.indexOf(2), 2);
+	QCOMPARE(hb.indexOf(1), -1);
+}
+
+QTEST_MAIN(TestRingBuffer);
diff --git a/src/core/test/ringbuf.hpp b/src/core/test/ringbuf.hpp
new file mode 100644
index 00000000..1413031c
--- /dev/null
+++ b/src/core/test/ringbuf.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <qobject.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+class TestObject {
+public:
+	explicit TestObject(quint32* count);
+	~TestObject();
+	Q_DISABLE_COPY_MOVE(TestObject);
+
+private:
+	quint32* count;
+};
+
+class TestRingBuffer: public QObject {
+	Q_OBJECT;
+
+private slots:
+	static void fill();
+	static void clearPartial();
+	static void move();
+
+	static void hashLookup();
+};
diff --git a/src/core/test/scriptmodel.cpp b/src/core/test/scriptmodel.cpp
new file mode 100644
index 00000000..0abfdbf3
--- /dev/null
+++ b/src/core/test/scriptmodel.cpp
@@ -0,0 +1,181 @@
+#include "scriptmodel.hpp"
+
+#include <qabstractitemmodel.h>
+#include <qabstractitemmodeltester.h>
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qobject.h>
+#include <qsignalspy.h>
+#include <qstring.h>
+#include <qtest.h>
+#include <qtestcase.h>
+#include <qtypes.h>
+
+#include "../scriptmodel.hpp"
+
+using OpList = QList<ModelOperation>;
+
+bool ModelOperation::operator==(const ModelOperation& other) const {
+	return other.operation == this->operation && other.index == this->index
+	    && other.length == this->length && other.destIndex == this->destIndex;
+}
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+QDebug& operator<<(QDebug& debug, const ModelOperation& op) {
+	auto saver = QDebugStateSaver(debug);
+	debug.nospace();
+
+	switch (op.operation) {
+	case ModelOperation::Insert: debug << "Insert"; break;
+	case ModelOperation::Remove: debug << "Remove"; break;
+	case ModelOperation::Move: debug << "Move"; break;
+	}
+
+	debug << "(i: " << op.index << ", l: " << op.length;
+
+	if (op.destIndex != -1) {
+		debug << ", d: " << op.destIndex;
+	}
+
+	debug << ')';
+
+	return debug;
+}
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+QDebug& operator<<(QDebug& debug, const QVariantList& list) {
+	auto str = QString();
+
+	for (const auto& var: list) {
+		if (var.canConvert<QChar>()) {
+			str += var.value<QChar>();
+		} else {
+			qFatal() << "QVariantList debug overridden in test";
+		}
+	}
+
+	debug << str;
+	return debug;
+}
+
+void TestScriptModel::unique_data() {
+	QTest::addColumn<QString>("oldstr");
+	QTest::addColumn<QString>("newstr");
+	QTest::addColumn<OpList>("operations");
+
+	QTest::addRow("append") << "ABCD" << "ABCDEFG" << OpList({{ModelOperation::Insert, 4, 3}});
+
+	QTest::addRow("prepend") << "EFG" << "ABCDEFG" << OpList({{ModelOperation::Insert, 0, 4}});
+
+	QTest::addRow("insert") << "ABFG" << "ABCDEFG" << OpList({{ModelOperation::Insert, 2, 3}});
+
+	QTest::addRow("chop") << "ABCDEFG" << "ABCD" << OpList({{ModelOperation::Remove, 4, 3}});
+
+	QTest::addRow("slice") << "ABCDEFG" << "DEFG" << OpList({{ModelOperation::Remove, 0, 3}});
+
+	QTest::addRow("remove_mid") << "ABCDEFG" << "ABFG" << OpList({{ModelOperation::Remove, 2, 3}});
+
+	QTest::addRow("move_single") << "ABCDEFG" << "AFBCDEG"
+	                             << OpList({{ModelOperation::Move, 5, 1, 1}});
+
+	QTest::addRow("move_range") << "ABCDEFG" << "ADEFBCG"
+	                            << OpList({{ModelOperation::Move, 3, 3, 1}});
+
+	// beginning to end is the same operation
+	QTest::addRow("move_end_to_beginning")
+	    << "ABCDEFG" << "EFGABCD" << OpList({{ModelOperation::Move, 4, 3, 0}});
+
+	QTest::addRow("move_overlapping")
+	    << "ABCDEFG" << "ABDEFCG" << OpList({{ModelOperation::Move, 3, 3, 2}});
+
+	// Ensure iterators arent skipping anything at the end of operations by performing
+	// multiple back to back.
+
+	QTest::addRow("insert_state_ok") << "ABCDEFG" << "ABXXEFG"
+	                                 << OpList({
+	                                        {ModelOperation::Insert, 2, 2}, // ABXXCDEFG
+	                                        {ModelOperation::Remove, 4, 2}, // ABXXEFG
+	                                    });
+
+	QTest::addRow("remove_state_ok") << "ABCDEFG" << "ABFGE"
+	                                 << OpList({
+	                                        {ModelOperation::Remove, 2, 2},  // ABEFG
+	                                        {ModelOperation::Move, 3, 2, 2}, // ABFGE
+	                                    });
+
+	QTest::addRow("move_state_ok") << "ABCDEFG" << "ABEFXYCDG"
+	                               << OpList({
+	                                      {ModelOperation::Move, 4, 2, 2}, // ABEFCDG
+	                                      {ModelOperation::Insert, 4, 2},  // ABEFXYCDG
+	                                  });
+}
+
+void TestScriptModel::unique() {
+	QFETCH(const QString, oldstr);
+	QFETCH(const QString, newstr);
+	QFETCH(const OpList, operations);
+
+	auto strToVariantList = [](const QString& str) -> QVariantList {
+		QVariantList list;
+
+		for (auto c: str) {
+			list.emplace_back(c);
+		}
+
+		return list;
+	};
+
+	auto oldlist = strToVariantList(oldstr);
+	auto newlist = strToVariantList(newstr);
+
+	auto model = ScriptModel();
+	auto modelTester = QAbstractItemModelTester(&model);
+
+	OpList actualOperations;
+
+	auto onInsert = [&](const QModelIndex& parent, int first, int last) {
+		QCOMPARE(parent, QModelIndex());
+		actualOperations << ModelOperation(ModelOperation::Insert, first, last - first + 1);
+	};
+
+	auto onRemove = [&](const QModelIndex& parent, int first, int last) {
+		QCOMPARE(parent, QModelIndex());
+		actualOperations << ModelOperation(ModelOperation::Remove, first, last - first + 1);
+	};
+
+	auto onMove = [&](const QModelIndex& sourceParent,
+	                  int sourceStart,
+	                  int sourceEnd,
+	                  const QModelIndex& destParent,
+	                  int destStart) {
+		QCOMPARE(sourceParent, QModelIndex());
+		QCOMPARE(destParent, QModelIndex());
+		actualOperations << ModelOperation(
+		    ModelOperation::Move,
+		    sourceStart,
+		    sourceEnd - sourceStart + 1,
+		    destStart
+		);
+	};
+
+	QObject::connect(&model, &QAbstractItemModel::rowsInserted, &model, onInsert);
+	QObject::connect(&model, &QAbstractItemModel::rowsRemoved, &model, onRemove);
+	QObject::connect(&model, &QAbstractItemModel::rowsMoved, &model, onMove);
+
+	model.setValues(oldlist);
+	QCOMPARE_EQ(model.values(), oldlist);
+	QCOMPARE_EQ(
+	    actualOperations,
+	    OpList({{ModelOperation::Insert, 0, static_cast<qint32>(oldlist.length())}})
+	);
+
+	actualOperations.clear();
+
+	model.setValues(newlist);
+	QCOMPARE_EQ(model.values(), newlist);
+	QCOMPARE_EQ(actualOperations, operations);
+}
+
+QTEST_MAIN(TestScriptModel);
diff --git a/src/core/test/scriptmodel.hpp b/src/core/test/scriptmodel.hpp
new file mode 100644
index 00000000..3b50b328
--- /dev/null
+++ b/src/core/test/scriptmodel.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <qdebug.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+struct ModelOperation {
+	enum Enum : quint8 {
+		Insert,
+		Remove,
+		Move,
+	};
+
+	ModelOperation(Enum operation, qint32 index, qint32 length, qint32 destIndex = -1)
+	    : operation(operation)
+	    , index(index)
+	    , length(length)
+	    , destIndex(destIndex) {}
+
+	Enum operation;
+	qint32 index = 0;
+	qint32 length = 0;
+	qint32 destIndex = -1;
+
+	[[nodiscard]] bool operator==(const ModelOperation& other) const;
+};
+
+QDebug& operator<<(QDebug& debug, const ModelOperation& op);
+
+class TestScriptModel: public QObject {
+	Q_OBJECT;
+
+private slots:
+	static void unique_data(); // NOLINT
+	static void unique();
+};
diff --git a/src/core/test/stacklist.cpp b/src/core/test/stacklist.cpp
new file mode 100644
index 00000000..9b981729
--- /dev/null
+++ b/src/core/test/stacklist.cpp
@@ -0,0 +1,92 @@
+#include "stacklist.hpp"
+#include <cstddef>
+
+#include <qlist.h>
+#include <qtest.h>
+#include <qtestcase.h>
+
+#include "../stacklist.hpp"
+
+void TestStackList::push() {
+	StackList<int, 2> list;
+
+	list.push(1);
+	list.push(2);
+
+	QCOMPARE_EQ(list.toList(), QList({1, 2}));
+	QCOMPARE_EQ(list.length(), 2);
+}
+
+void TestStackList::pushAndGrow() {
+	StackList<int, 2> list;
+
+	list.push(1);
+	list.push(2);
+	list.push(3);
+	list.push(4);
+
+	QCOMPARE_EQ(list.toList(), QList({1, 2, 3, 4}));
+	QCOMPARE_EQ(list.length(), 4);
+}
+
+void TestStackList::copy() {
+	StackList<int, 2> list;
+
+	list.push(1);
+	list.push(2);
+	list.push(3);
+	list.push(4);
+
+	QCOMPARE_EQ(list.toList(), QList({1, 2, 3, 4}));
+	QCOMPARE_EQ(list.length(), 4);
+
+	auto list2 = list;
+
+	QCOMPARE_EQ(list2.toList(), QList({1, 2, 3, 4}));
+	QCOMPARE_EQ(list2.length(), 4);
+	QCOMPARE_EQ(list2, list);
+}
+
+void TestStackList::viewVla() {
+	StackList<int, 2> list;
+
+	list.push(1);
+	list.push(2);
+
+	QCOMPARE_EQ(list.toList(), QList({1, 2}));
+	QCOMPARE_EQ(list.length(), 2);
+
+	STACKLIST_VLA_VIEW(int, list, listView);
+
+	QList<int> ql;
+
+	for (size_t i = 0; i != list.length(); ++i) {
+		ql.push_back(listView[i]); // NOLINT
+	}
+
+	QCOMPARE_EQ(ql, list.toList());
+}
+
+void TestStackList::viewVlaGrown() {
+	StackList<int, 2> list;
+
+	list.push(1);
+	list.push(2);
+	list.push(3);
+	list.push(4);
+
+	QCOMPARE_EQ(list.toList(), QList({1, 2, 3, 4}));
+	QCOMPARE_EQ(list.length(), 4);
+
+	STACKLIST_VLA_VIEW(int, list, listView);
+
+	QList<int> ql;
+
+	for (size_t i = 0; i != list.length(); ++i) {
+		ql.push_back(listView[i]); // NOLINT
+	}
+
+	QCOMPARE_EQ(ql, list.toList());
+}
+
+QTEST_MAIN(TestStackList);
diff --git a/src/core/test/stacklist.hpp b/src/core/test/stacklist.hpp
new file mode 100644
index 00000000..f582761d
--- /dev/null
+++ b/src/core/test/stacklist.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+class TestStackList: public QObject {
+	Q_OBJECT;
+
+private slots:
+	static void push();
+	static void pushAndGrow();
+	static void copy();
+	static void viewVla();
+	static void viewVlaGrown();
+};
diff --git a/src/core/test/transformwatcher.cpp b/src/core/test/transformwatcher.cpp
new file mode 100644
index 00000000..ac10cfb0
--- /dev/null
+++ b/src/core/test/transformwatcher.cpp
@@ -0,0 +1,105 @@
+#include "transformwatcher.hpp"
+
+#include <qlist.h>
+#include <qquickitem.h>
+#include <qquickwindow.h>
+#include <qtest.h>
+#include <qtestcase.h>
+
+#include "../transformwatcher.hpp"
+
+void TestTransformWatcher::aParentOfB() { // NOLINT
+	auto a = QQuickItem();
+	a.setObjectName("a");
+	auto b = QQuickItem();
+	b.setObjectName("b");
+	b.setParentItem(&a);
+
+	auto watcher = TransformWatcher();
+	watcher.setA(&a);
+	watcher.setB(&b);
+
+	QCOMPARE(watcher.parentChain, {&a});
+	QCOMPARE(watcher.childChain, {&b});
+}
+
+void TestTransformWatcher::bParentOfA() { // NOLINT
+	auto a = QQuickItem();
+	a.setObjectName("a");
+	auto b = QQuickItem();
+	b.setObjectName("b");
+	a.setParentItem(&b);
+
+	auto watcher = TransformWatcher();
+	watcher.setA(&a);
+	watcher.setB(&b);
+
+	QCOMPARE(watcher.parentChain, (QList {&a, &b}));
+	QCOMPARE(watcher.childChain, {});
+}
+
+// a
+//  p1    b
+//   p2 c1
+//    p3
+void TestTransformWatcher::aParentChainB() { // NOLINT
+	auto a = QQuickItem();
+	a.setObjectName("a");
+	auto b = QQuickItem();
+	b.setObjectName("b");
+
+	auto p1 = QQuickItem();
+	p1.setObjectName("p1");
+	auto p2 = QQuickItem();
+	p2.setObjectName("p2");
+	auto p3 = QQuickItem();
+	p3.setObjectName("p3");
+	auto c1 = QQuickItem();
+	c1.setObjectName("c1");
+
+	a.setParentItem(&p1);
+	p1.setParentItem(&p2);
+	p2.setParentItem(&p3);
+
+	b.setParentItem(&c1);
+	c1.setParentItem(&p3);
+
+	auto watcher = TransformWatcher();
+	watcher.setA(&a);
+	watcher.setB(&b);
+
+	QCOMPARE(watcher.parentChain, (QList {&a, &p1, &p2, &p3}));
+	QCOMPARE(watcher.childChain, (QList {&b, &c1}));
+}
+
+void TestTransformWatcher::multiWindow() { // NOLINT
+	auto a = QQuickItem();
+	a.setObjectName("a");
+	auto b = QQuickItem();
+	b.setObjectName("b");
+
+	auto p = QQuickItem();
+	p.setObjectName("p");
+	auto c = QQuickItem();
+	c.setObjectName("c");
+
+	a.setParentItem(&p);
+	b.setParentItem(&c);
+
+	auto aW = QQuickWindow();
+	auto bW = QQuickWindow();
+
+	p.setParentItem(aW.contentItem());
+	c.setParentItem(bW.contentItem());
+
+	auto watcher = TransformWatcher();
+	watcher.setA(&a);
+	watcher.setB(&b);
+
+	QCOMPARE(watcher.parentChain, (QList {&a, &p, aW.contentItem()}));
+	QCOMPARE(watcher.childChain, (QList {&b, &c, bW.contentItem()}));
+	QCOMPARE(watcher.parentWindow, &aW);
+	QCOMPARE(watcher.childWindow, &bW);
+}
+
+QTEST_MAIN(TestTransformWatcher);
diff --git a/src/core/test/transformwatcher.hpp b/src/core/test/transformwatcher.hpp
new file mode 100644
index 00000000..e2bdfda8
--- /dev/null
+++ b/src/core/test/transformwatcher.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+class TestTransformWatcher: public QObject {
+	Q_OBJECT;
+
+private slots:
+	void aParentOfB();
+	void bParentOfA();
+	void aParentChainB();
+	void multiWindow();
+};
diff --git a/src/core/toolsupport.cpp b/src/core/toolsupport.cpp
new file mode 100644
index 00000000..afce008b
--- /dev/null
+++ b/src/core/toolsupport.cpp
@@ -0,0 +1,241 @@
+#include "toolsupport.hpp"
+#include <cerrno>
+
+#include <fcntl.h>
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qdir.h>
+#include <qfileinfo.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qqmlengine.h>
+#include <qtenvironmentvariables.h>
+
+#include "logcat.hpp"
+#include "paths.hpp"
+#include "scan.hpp"
+
+namespace qs::core {
+
+namespace {
+QS_LOGGING_CATEGORY(logTooling, "quickshell.tooling", QtWarningMsg);
+}
+
+bool QmlToolingSupport::updateTooling(const QDir& configRoot, QmlScanner& scanner) {
+	auto* vfs = QsPaths::instance()->shellVfsDir();
+
+	if (!vfs) {
+		qCCritical(logTooling) << "Tooling dir could not be created";
+		return false;
+	}
+
+	if (!QmlToolingSupport::lockTooling()) {
+		return false;
+	}
+
+	if (!QmlToolingSupport::updateQmllsConfig(configRoot, false)) {
+		QDir(vfs->filePath("qs")).removeRecursively();
+		return false;
+	}
+
+	QmlToolingSupport::updateToolingFs(scanner, configRoot, vfs->filePath("qs"));
+	return true;
+}
+
+bool QmlToolingSupport::lockTooling() {
+	if (QmlToolingSupport::toolingLock) return true;
+
+	auto lockPath = QsPaths::instance()->shellVfsDir()->filePath("tooling.lock");
+	auto* file = new QFile(lockPath);
+
+	if (!file->open(QFile::WriteOnly)) {
+		qCCritical(logTooling) << "Could not open tooling lock for write";
+		return false;
+	}
+
+	auto lock = flock {
+	    .l_type = F_WRLCK,
+	    .l_whence = SEEK_SET, // NOLINT (fcntl.h??)
+	    .l_start = 0,
+	    .l_len = 0,
+	    .l_pid = 0,
+	};
+
+	if (fcntl(file->handle(), F_SETLK, &lock) == 0) {
+		qCInfo(logTooling) << "Acquired tooling support lock";
+		QmlToolingSupport::toolingLock = file;
+		return true;
+	} else if (errno == EACCES || errno == EAGAIN) {
+		qCInfo(logTooling) << "Tooling support locked by another instance";
+		return false;
+	} else {
+		qCCritical(logTooling).nospace() << "Could not create tooling lock at " << lockPath
+		                                 << " with error code " << errno << ": " << qt_error_string();
+		return false;
+	}
+}
+
+QString QmlToolingSupport::getQmllsConfig() {
+	static auto config = []() {
+		// We can't replicate the algorithm used to create the import path list as it can have distro
+		// specific patches, e.g. nixos.
+		auto importPaths = QQmlEngine().importPathList();
+		importPaths.removeIf([](const QString& path) { return path.startsWith("qrc:"); });
+
+		auto vfsPath = QsPaths::instance()->shellVfsDir()->path();
+		auto importPathsStr = importPaths.join(u':');
+
+		QString qmllsConfig;
+		auto print = QDebug(&qmllsConfig).nospace();
+		print << "[General]\nno-cmake-calls=true\nbuildDir=" << vfsPath
+		      << "\nimportPaths=" << importPathsStr << '\n';
+
+		return qmllsConfig;
+	}();
+
+	return config;
+}
+
+bool QmlToolingSupport::updateQmllsConfig(const QDir& configRoot, bool create) {
+	auto shellConfigPath = configRoot.filePath(".qmlls.ini");
+	auto vfsConfigPath = QsPaths::instance()->shellVfsDir()->filePath(".qmlls.ini");
+
+	auto shellFileInfo = QFileInfo(shellConfigPath);
+	if (!create && !shellFileInfo.exists() && !shellFileInfo.isSymLink()) {
+		if (QmlToolingSupport::toolingEnabled) {
+			qInfo() << "QML tooling support disabled";
+			QmlToolingSupport::toolingEnabled = false;
+		} else {
+			qCInfo(logTooling) << "Not enabling QML tooling support, qmlls.ini is missing at path"
+			                   << shellConfigPath;
+		}
+
+		QFile::remove(vfsConfigPath);
+		return false;
+	}
+
+	auto vfsFile = QFile(vfsConfigPath);
+
+	if (!vfsFile.open(QFile::ReadWrite | QFile::Text)) {
+		qCCritical(logTooling) << "Failed to create qmlls config in vfs";
+		return false;
+	}
+
+	auto config = QmlToolingSupport::getQmllsConfig();
+
+	if (vfsFile.readAll() != config) {
+		if (!vfsFile.resize(0) || !vfsFile.write(config.toUtf8())) {
+			qCCritical(logTooling) << "Failed to write qmlls config in vfs";
+			return false;
+		}
+
+		qCDebug(logTooling) << "Wrote qmlls config in vfs";
+	}
+
+	if (!shellFileInfo.isSymLink() || shellFileInfo.symLinkTarget() != vfsConfigPath) {
+		QFile::remove(shellConfigPath);
+
+		if (!QFile::link(vfsConfigPath, shellConfigPath)) {
+			qCCritical(logTooling) << "Failed to create qmlls config symlink";
+			return false;
+		}
+
+		qCDebug(logTooling) << "Created qmlls config symlink";
+	}
+
+	if (!QmlToolingSupport::toolingEnabled) {
+		qInfo() << "QML tooling support enabled";
+		QmlToolingSupport::toolingEnabled = true;
+	}
+
+	return true;
+}
+
+void QmlToolingSupport::updateToolingFs(
+    QmlScanner& scanner,
+    const QDir& scanDir,
+    const QDir& linkDir
+) {
+	QList<QString> files;
+	QSet<QString> subdirs;
+
+	auto scanPath = scanDir.path();
+
+	linkDir.mkpath(".");
+
+	for (auto& path: scanner.scannedFiles) {
+		if (path.length() < scanPath.length() + 1 || !path.startsWith(scanPath)) continue;
+		auto name = path.sliced(scanPath.length() + 1);
+
+		if (name.contains('/')) {
+			auto dirname = name.first(name.indexOf('/'));
+			subdirs.insert(dirname);
+			continue;
+		}
+
+		auto fileInfo = QFileInfo(path);
+		if (!fileInfo.isFile()) continue;
+
+		auto spath = linkDir.filePath(name);
+		auto sFileInfo = QFileInfo(spath);
+
+		if (!sFileInfo.isSymLink() || sFileInfo.symLinkTarget() != path) {
+			QFile::remove(spath);
+
+			if (QFile::link(path, spath)) {
+				qCDebug(logTooling) << "Created symlink to" << path << "at" << spath;
+				files.append(spath);
+			} else {
+				qCCritical(logTooling) << "Could not create symlink to" << path << "at" << spath;
+			}
+		} else {
+			files.append(spath);
+		}
+	}
+
+	for (auto [path, text]: scanner.fileIntercepts.asKeyValueRange()) {
+		if (path.length() < scanPath.length() + 1 || !path.startsWith(scanPath)) continue;
+		auto name = path.sliced(scanPath.length() + 1);
+
+		if (name.contains('/')) {
+			auto dirname = name.first(name.indexOf('/'));
+			subdirs.insert(dirname);
+			continue;
+		}
+
+		auto spath = linkDir.filePath(name);
+		auto file = QFile(spath);
+		if (!file.open(QFile::ReadWrite | QFile::Text)) {
+			qCCritical(logTooling) << "Failed to open injected file" << spath;
+			continue;
+		}
+
+		if (file.readAll() == text) {
+			files.append(spath);
+			continue;
+		}
+
+		if (file.resize(0) && file.write(text.toUtf8())) {
+			files.append(spath);
+			qCDebug(logTooling) << "Wrote injected file" << spath;
+		} else {
+			qCCritical(logTooling) << "Failed to write injected file" << spath;
+		}
+	}
+
+	for (auto& name: linkDir.entryList(QDir::Files | QDir::System)) { // System = broken symlinks
+		auto path = linkDir.filePath(name);
+
+		if (!files.contains(path)) {
+			if (QFile::remove(path)) qCDebug(logTooling) << "Removed old file at" << path;
+			else qCWarning(logTooling) << "Failed to remove old file at" << path;
+		}
+	}
+
+	for (const auto& subdir: subdirs) {
+		QmlToolingSupport::updateToolingFs(scanner, scanDir.filePath(subdir), linkDir.filePath(subdir));
+	}
+}
+
+} // namespace qs::core
diff --git a/src/core/toolsupport.hpp b/src/core/toolsupport.hpp
new file mode 100644
index 00000000..9fb79216
--- /dev/null
+++ b/src/core/toolsupport.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <qdir.h>
+
+#include "scan.hpp"
+
+namespace qs::core {
+
+class QmlToolingSupport {
+public:
+	static bool updateTooling(const QDir& configRoot, QmlScanner& scanner);
+
+private:
+	static QString getQmllsConfig();
+	static bool lockTooling();
+	static bool updateQmllsConfig(const QDir& configRoot, bool create);
+	static void updateToolingFs(QmlScanner& scanner, const QDir& scanDir, const QDir& linkDir);
+	static inline bool toolingEnabled = false;
+	static inline QFile* toolingLock = nullptr;
+};
+
+} // namespace qs::core
diff --git a/src/core/transformwatcher.cpp b/src/core/transformwatcher.cpp
new file mode 100644
index 00000000..6fc7c34a
--- /dev/null
+++ b/src/core/transformwatcher.cpp
@@ -0,0 +1,183 @@
+#include "transformwatcher.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qobject.h>
+#include <qquickitem.h>
+#include <qquickwindow.h>
+#include <qtmetamacros.h>
+
+void TransformWatcher::resolveChains(QQuickItem* a, QQuickItem* b, QQuickItem* commonParent) {
+	if (a == nullptr || b == nullptr) return;
+
+	auto aChain = QVector<QQuickItem*>();
+	auto bChain = QVector<QQuickItem*>();
+
+	auto* aParent = a;
+	auto* bParent = b;
+
+	// resolve the parent chain of b. if a is in the chain break early
+	while (bParent != nullptr) {
+		bChain.push_back(bParent);
+
+		if (bParent == a) {
+			aChain.push_back(a);
+			goto chainResolved;
+		}
+
+		if (bParent == commonParent) break;
+		bParent = bParent->parentItem();
+	}
+
+	// resolve the parent chain of a, breaking as soon as b is found
+	while (aParent != nullptr) {
+		aChain.push_back(aParent);
+
+		for (auto bParent = bChain.begin(); bParent != bChain.end(); bParent++) {
+			if (*bParent == aParent) {
+				bParent++;
+				bChain.erase(bParent, bChain.end());
+				goto chainResolved;
+			}
+		}
+
+		if (aParent == commonParent) break;
+		aParent = aParent->parentItem();
+	}
+
+	if (commonParent != nullptr && aParent == commonParent) {
+		qWarning() << this << "failed to find a common parent between" << a << "and" << b
+		           << "due to incorrectly set commonParent" << commonParent;
+
+		return;
+	}
+
+chainResolved:
+
+	this->parentChain = aChain;
+	if (bChain.last() == aChain.last()) bChain.removeLast();
+	this->childChain = bChain;
+
+	if (a->window() != b->window()) {
+		this->parentWindow = a->window();
+		this->childWindow = b->window();
+	} else {
+		this->parentWindow = nullptr;
+		this->childWindow = nullptr;
+	}
+}
+
+void TransformWatcher::resolveChains() {
+	this->resolveChains(this->mA, this->mB, this->mCommonParent);
+}
+
+void TransformWatcher::linkItem(QQuickItem* item) const {
+	QObject::connect(item, &QQuickItem::xChanged, this, &TransformWatcher::transformChanged);
+	QObject::connect(item, &QQuickItem::yChanged, this, &TransformWatcher::transformChanged);
+	QObject::connect(item, &QQuickItem::widthChanged, this, &TransformWatcher::transformChanged);
+	QObject::connect(item, &QQuickItem::heightChanged, this, &TransformWatcher::transformChanged);
+	QObject::connect(item, &QQuickItem::scaleChanged, this, &TransformWatcher::transformChanged);
+	QObject::connect(item, &QQuickItem::rotationChanged, this, &TransformWatcher::transformChanged);
+
+	QObject::connect(item, &QQuickItem::parentChanged, this, &TransformWatcher::recalcChains);
+	QObject::connect(item, &QQuickItem::windowChanged, this, &TransformWatcher::recalcChains);
+
+	if (item != this->mA && item != this->mB) {
+		QObject::connect(item, &QObject::destroyed, this, &TransformWatcher::itemDestroyed);
+	}
+}
+
+void TransformWatcher::linkChains() {
+	for (auto* item: this->parentChain) {
+		this->linkItem(item);
+	}
+
+	for (auto* item: this->childChain) {
+		this->linkItem(item);
+	}
+}
+
+void TransformWatcher::unlinkChains() {
+	for (auto* item: this->parentChain) {
+		QObject::disconnect(item, nullptr, this, nullptr);
+	}
+
+	for (auto* item: this->childChain) {
+		QObject::disconnect(item, nullptr, this, nullptr);
+	}
+
+	// relink a and b destruction notifications
+	if (this->mA != nullptr) {
+		QObject::connect(this->mA, &QObject::destroyed, this, &TransformWatcher::aDestroyed);
+	}
+
+	if (this->mB != nullptr) {
+		QObject::connect(this->mB, &QObject::destroyed, this, &TransformWatcher::bDestroyed);
+	}
+
+	this->parentChain.clear();
+	this->childChain.clear();
+}
+
+void TransformWatcher::recalcChains() {
+	this->unlinkChains();
+	this->resolveChains();
+	this->linkChains();
+}
+
+void TransformWatcher::itemDestroyed() {
+	auto destroyed =
+	    this->parentChain.removeOne(this->sender()) || this->childChain.removeOne(this->sender());
+
+	if (destroyed) this->recalcChains();
+}
+
+QQuickItem* TransformWatcher::a() const { return this->mA; }
+
+void TransformWatcher::setA(QQuickItem* a) {
+	if (this->mA == a) return;
+	if (this->mA != nullptr) QObject::disconnect(this->mA, nullptr, this, nullptr);
+	this->mA = a;
+
+	if (this->mA != nullptr) {
+		QObject::connect(this->mA, &QObject::destroyed, this, &TransformWatcher::aDestroyed);
+	}
+
+	this->recalcChains();
+}
+
+void TransformWatcher::aDestroyed() {
+	this->mA = nullptr;
+	this->unlinkChains();
+	emit this->aChanged();
+}
+
+QQuickItem* TransformWatcher::b() const { return this->mB; }
+
+void TransformWatcher::setB(QQuickItem* b) {
+	if (this->mB == b) return;
+	if (this->mB != nullptr) QObject::disconnect(this->mB, nullptr, this, nullptr);
+	this->mB = b;
+
+	if (this->mB != nullptr) {
+		QObject::connect(this->mB, &QObject::destroyed, this, &TransformWatcher::bDestroyed);
+	}
+
+	this->recalcChains();
+}
+
+void TransformWatcher::bDestroyed() {
+	this->mB = nullptr;
+	this->unlinkChains();
+	emit this->bChanged();
+}
+
+QQuickItem* TransformWatcher::commonParent() const { return this->mCommonParent; }
+
+void TransformWatcher::setCommonParent(QQuickItem* commonParent) {
+	if (this->mCommonParent == commonParent) return;
+	this->mCommonParent = commonParent;
+	this->recalcChains();
+}
diff --git a/src/core/transformwatcher.hpp b/src/core/transformwatcher.hpp
new file mode 100644
index 00000000..8efa9399
--- /dev/null
+++ b/src/core/transformwatcher.hpp
@@ -0,0 +1,87 @@
+#pragma once
+
+#include <qlist.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qquickitem.h>
+#include <qquickwindow.h>
+#include <qtmetamacros.h>
+
+#ifdef QS_TEST
+class TestTransformWatcher;
+#endif
+
+///! Monitor of all geometry changes between two objects.
+/// The TransformWatcher monitors all properties that affect the geometry
+/// of two @@QtQuick.Item$s relative to eachother.
+///
+/// > [!INFO] The algorithm responsible for determining the relationship
+/// > between `a` and `b` is biased towards `a` being a parent of `b`,
+/// > or `a` being closer to the common parent of `a` and `b` than `b`.
+class TransformWatcher: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	Q_PROPERTY(QQuickItem* a READ a WRITE setA NOTIFY aChanged);
+	Q_PROPERTY(QQuickItem* b READ b WRITE setB NOTIFY bChanged);
+	/// Known common parent of both `a` and `b`. Defaults to `null`.
+	///
+	/// This property can be used to optimize the algorithm that figures out
+	/// the relationship between `a` and `b`. Setting it to something that is not
+	/// a common parent of both `a` and `b` will prevent the path from being determined
+	/// correctly, and setting it to `null` will disable the optimization.
+	Q_PROPERTY(QQuickItem* commonParent READ commonParent WRITE setCommonParent NOTIFY commonParentChanged);
+	/// This property is updated whenever the geometry of any item in the path from `a` to `b` changes.
+	///
+	/// Its value is undefined, and is intended to trigger an expression update.
+	Q_PROPERTY(QObject* transform READ transform NOTIFY transformChanged);
+	// clang-format on
+	QML_ELEMENT;
+
+public:
+	explicit TransformWatcher(QObject* parent = nullptr): QObject(parent) {}
+
+	[[nodiscard]] QQuickItem* a() const;
+	void setA(QQuickItem* a);
+
+	[[nodiscard]] QQuickItem* b() const;
+	void setB(QQuickItem* b);
+
+	[[nodiscard]] QQuickItem* commonParent() const;
+	void setCommonParent(QQuickItem* commonParent);
+
+	[[nodiscard]] QObject* transform() const { return nullptr; } // NOLINT
+
+signals:
+	void transformChanged();
+
+	void aChanged();
+	void bChanged();
+	void commonParentChanged();
+
+private slots:
+	void recalcChains();
+	void itemDestroyed();
+	void aDestroyed();
+	void bDestroyed();
+
+private:
+	void resolveChains(QQuickItem* a, QQuickItem* b, QQuickItem* commonParent);
+	void resolveChains();
+	void linkItem(QQuickItem* item) const;
+	void linkChains();
+	void unlinkChains();
+
+	QQuickItem* mA = nullptr;
+	QQuickItem* mB = nullptr;
+	QQuickItem* mCommonParent = nullptr;
+
+	// a -> traverse parent chain -> parent window -> global scope -> child window -> traverse child chain -> b
+	QList<QQuickItem*> parentChain;
+	QList<QQuickItem*> childChain;
+	QQuickWindow* parentWindow = nullptr;
+	QQuickWindow* childWindow = nullptr;
+
+#ifdef QS_TEST
+	friend class TestTransformWatcher;
+#endif
+};
diff --git a/src/core/types.cpp b/src/core/types.cpp
new file mode 100644
index 00000000..81c1d010
--- /dev/null
+++ b/src/core/types.cpp
@@ -0,0 +1,26 @@
+#include "types.hpp"
+
+#include <qdebug.h>
+#include <qmargins.h>
+#include <qnamespace.h>
+#include <qrect.h>
+
+QRect Box::qrect() const { return {this->x, this->y, this->w, this->h}; }
+
+bool Box::operator==(const Box& other) const {
+	return this->x == other.x && this->y == other.y && this->w == other.w && this->h == other.h;
+}
+
+QDebug operator<<(QDebug debug, const Box& box) {
+	auto saver = QDebugStateSaver(debug);
+	debug.nospace() << "Box(" << box.x << ',' << box.y << ' ' << box.w << 'x' << box.h << ')';
+	return debug;
+}
+
+Qt::Edges Edges::toQt(Edges::Flags edges) { return Qt::Edges(edges.toInt()); }
+
+bool Edges::isOpposing(Edges::Flags edges) {
+	return edges.testFlags(Edges::Top | Edges::Bottom) || edges.testFlags(Edges::Left | Edges::Right);
+}
+
+QMargins Margins::qmargins() const { return {this->left, this->top, this->right, this->bottom}; }
diff --git a/src/core/types.hpp b/src/core/types.hpp
new file mode 100644
index 00000000..b6cb2598
--- /dev/null
+++ b/src/core/types.hpp
@@ -0,0 +1,101 @@
+#pragma once
+
+#include <qdebug.h>
+#include <qmargins.h>
+#include <qnamespace.h>
+#include <qpoint.h>
+#include <qqmlintegration.h>
+#include <qrect.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+class Box {
+	Q_GADGET;
+	Q_PROPERTY(qint32 x MEMBER x);
+	Q_PROPERTY(qint32 y MEMBER y);
+	Q_PROPERTY(qint32 w MEMBER w);
+	Q_PROPERTY(qint32 h MEMBER h);
+	Q_PROPERTY(qint32 width MEMBER w);
+	Q_PROPERTY(qint32 height MEMBER h);
+	QML_CONSTRUCTIBLE_VALUE;
+	QML_VALUE_TYPE(box);
+
+public:
+	explicit Box() = default;
+	Box(qint32 x, qint32 y, qint32 w, qint32 h): x(x), y(y), w(w), h(h) {}
+
+	Q_INVOKABLE Box(const QRect& rect): x(rect.x()), y(rect.y()), w(rect.width()), h(rect.height()) {}
+	Q_INVOKABLE Box(const QPoint& rect): x(rect.x()), y(rect.y()) {}
+
+	Q_INVOKABLE Box(const QRectF& rect)
+	    : x(static_cast<qint32>(rect.x()))
+	    , y(static_cast<qint32>(rect.y()))
+	    , w(static_cast<qint32>(rect.width()))
+	    , h(static_cast<qint32>(rect.height())) {}
+
+	Q_INVOKABLE Box(const QPointF& rect)
+	    : x(static_cast<qint32>(rect.x()))
+	    , y(static_cast<qint32>(rect.y())) {}
+
+	bool operator==(const Box& other) const;
+
+	qint32 x = 0;
+	qint32 y = 0;
+	qint32 w = 0;
+	qint32 h = 0;
+
+	[[nodiscard]] QRect qrect() const;
+	[[nodiscard]] bool isEmpty() const { return this->w == 0 && this->h == 0; }
+};
+
+QDebug operator<<(QDebug debug, const Box& box);
+
+class Margins {
+	Q_GADGET;
+	Q_PROPERTY(qint32 left MEMBER left);
+	Q_PROPERTY(qint32 right MEMBER right);
+	Q_PROPERTY(qint32 top MEMBER top);
+	Q_PROPERTY(qint32 bottom MEMBER bottom);
+	QML_CONSTRUCTIBLE_VALUE;
+	QML_VALUE_TYPE(margins);
+
+public:
+	[[nodiscard]] bool operator==(const Margins& other) const noexcept {
+		// clang-format off
+		return this->left == other.left
+			&& this->right == other.right
+			&& this->top == other.top
+			&& this->bottom == other.bottom;
+		// clang-format on
+	}
+
+	qint32 left = 0;
+	qint32 right = 0;
+	qint32 top = 0;
+	qint32 bottom = 0;
+
+	[[nodiscard]] QMargins qmargins() const;
+};
+
+///! Top Left Right Bottom flags.
+/// Edge flags can be combined with the `|` operator.
+namespace Edges { // NOLINT
+Q_NAMESPACE;
+QML_NAMED_ELEMENT(Edges);
+
+enum Enum : quint8 {
+	None = 0,
+	Top = Qt::TopEdge,
+	Left = Qt::LeftEdge,
+	Right = Qt::RightEdge,
+	Bottom = Qt::BottomEdge,
+};
+Q_ENUM_NS(Enum);
+Q_DECLARE_FLAGS(Flags, Enum);
+
+Qt::Edges toQt(Flags edges);
+bool isOpposing(Flags edges);
+
+}; // namespace Edges
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(Edges::Flags);
diff --git a/src/core/util.hpp b/src/core/util.hpp
new file mode 100644
index 00000000..88583d0c
--- /dev/null
+++ b/src/core/util.hpp
@@ -0,0 +1,304 @@
+#pragma once
+#include <algorithm>
+#include <type_traits>
+
+#include <bit>
+#include <qlatin1stringview.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qstringview.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+
+template <size_t length>
+struct StringLiteral {
+	constexpr StringLiteral(const char (&str)[length]) { // NOLINT
+		std::copy_n(str, length, this->value);
+	}
+
+	constexpr operator const char*() const noexcept { return this->value; }
+	operator QLatin1StringView() const { return QLatin1String(this->value, length); }
+
+	char value[length]; // NOLINT
+};
+
+template <size_t length>
+struct StringLiteral16 {
+	constexpr StringLiteral16(const char16_t (&str)[length]) { // NOLINT
+		std::copy_n(str, length, this->value);
+	}
+
+	[[nodiscard]] constexpr const QChar* qCharPtr() const noexcept {
+		return std::bit_cast<const QChar*>(&this->value);
+	}
+
+	[[nodiscard]] Q_ALWAYS_INLINE operator QString() const noexcept {
+		return QString::fromRawData(this->qCharPtr(), static_cast<qsizetype>(length - 1));
+	}
+
+	[[nodiscard]] Q_ALWAYS_INLINE operator QStringView() const noexcept {
+		return QStringView(this->qCharPtr(), static_cast<qsizetype>(length - 1));
+	}
+
+	char16_t value[length]; // NOLINT
+};
+
+// NOLINTBEGIN
+#define DROP_EMIT(object, func)                                                                    \
+	DropEmitter(object, static_cast<void (*)(typeof(object))>([](typeof(object) o) { o->func(); }))
+
+#define DROP_EMIT_IF(cond, object, func) (cond) ? DROP_EMIT(object, func) : DropEmitter()
+
+#define DEFINE_DROP_EMIT_IF(cond, object, func) DropEmitter func = DROP_EMIT_IF(cond, object, func)
+
+#define DROP_EMIT_SET(object, local, member, signal)                                               \
+	auto signal = DropEmitter();                                                                     \
+	if (local == object->member) {                                                                   \
+		object->member = local;                                                                        \
+		signal = DROP_EMIT(object, signal);                                                            \
+	}
+// NOLINTEND
+
+class DropEmitter {
+public:
+	Q_DISABLE_COPY(DropEmitter);
+	template <class O>
+	DropEmitter(O* object, void (*signal)(O*))
+	    : object(object)
+	    , signal(*reinterpret_cast<void (*)(void*)>(signal)) {}
+
+	DropEmitter() = default;
+
+	DropEmitter(DropEmitter&& other) noexcept: object(other.object), signal(other.signal) {
+		other.object = nullptr;
+	}
+
+	~DropEmitter() { this->call(); }
+
+	DropEmitter& operator=(DropEmitter&& other) noexcept {
+		this->object = other.object;
+		this->signal = other.signal;
+		other.object = nullptr;
+		return *this;
+	}
+
+	explicit operator bool() const noexcept { return this->object; }
+
+	void call() {
+		if (!this->object) return;
+		this->signal(this->object);
+		this->object = nullptr;
+	}
+
+	// orders calls for multiple emitters (instead of reverse definition order)
+	template <typename... Args>
+	static void call(Args&... args) {
+		(args.call(), ...);
+	}
+
+private:
+	void* object = nullptr;
+	void (*signal)(void*) = nullptr;
+};
+
+// NOLINTBEGIN
+#define DECLARE_MEMBER(class, name, member, signal)                                                \
+	using M_##name = MemberMetadata<&class ::member, &class ::signal>
+
+#define DECLARE_MEMBER_NS(class, name, member) using M_##name = MemberMetadata<&class ::member>
+
+#define DECLARE_MEMBER_GET(name) [[nodiscard]] M_##name::Ref name() const
+#define DECLARE_MEMBER_SET(name, setter) M_##name::Ret setter(M_##name::Ref value)
+
+#define DECLARE_MEMBER_GETSET(name, setter)                                                        \
+	DECLARE_MEMBER_GET(name);                                                                        \
+	DECLARE_MEMBER_SET(name, setter)
+
+#define DECLARE_MEMBER_SETONLY(class, name, setter, member, signal) DECLARE_MEMBER(cl
+
+#define DECLARE_MEMBER_FULL(class, name, setter, member, signal)                                   \
+	DECLARE_MEMBER(class, name, member, signal);                                                     \
+	DECLARE_MEMBER_GETSET(name, setter)
+
+#define DECLARE_MEMBER_WITH_GET(class, name, member, signal)                                       \
+	DECLARE_MEMBER(class, name, member, signal);                                                     \
+                                                                                                   \
+public:                                                                                            \
+	DECLARE_MEMBER_GET(name);                                                                        \
+                                                                                                   \
+private:
+
+#define DECLARE_PRIVATE_MEMBER(class, name, setter, member, signal)                                \
+	DECLARE_MEMBER_WITH_GET(class, name, member, signal);                                            \
+	DECLARE_MEMBER_SET(name, setter);
+
+#define DECLARE_PMEMBER(type, name) using M_##name = PseudomemberMetadata<type, true>;
+#define DECLARE_PMEMBER_NS(type, name) using M_##name = PseudomemberMetadata<type, false>;
+
+#define DECLARE_PMEMBER_FULL(type, name, setter)                                                   \
+	DECLARE_PMEMBER(type, name);                                                                     \
+	DECLARE_MEMBER_GETSET(name, setter)
+
+#define DECLARE_PMEMBER_WITH_GET(type, name)                                                       \
+	DECLARE_PMEMBER(type, name);                                                                     \
+                                                                                                   \
+public:                                                                                            \
+	DECLARE_MEMBER_GET(name);                                                                        \
+                                                                                                   \
+private:
+
+#define DECLARE_PRIVATE_PMEMBER(type, name, setter)                                                \
+	DECLARE_PMEMBER_WITH_GET(type, name);                                                            \
+	DECLARE_MEMBER_SET(name, setter);
+
+#define DEFINE_PMEMBER_GET_M(Class, Member, name) Member::Ref Class::name() const
+#define DEFINE_PMEMBER_GET(Class, name) DEFINE_PMEMBER_GET_M(Class, Class::M_##name, name)
+
+#define DEFINE_MEMBER_GET_M(Class, Member, name)                                                   \
+	DEFINE_PMEMBER_GET_M(Class, Member, name) { return Member::get(this); }
+
+#define DEFINE_MEMBER_GET(Class, name) DEFINE_MEMBER_GET_M(Class, Class::M_##name, name)
+
+#define DEFINE_MEMBER_SET_M(Class, Member, setter)                                                 \
+	Member::Ret Class::setter(Member::Ref value) { return Member::set(this, value); }
+
+#define DEFINE_MEMBER_SET(Class, name, setter) DEFINE_MEMBER_SET_M(Class, Class::M_##name, setter)
+
+#define DEFINE_MEMBER_GETSET(Class, name, setter)                                                  \
+	DEFINE_MEMBER_GET(Class, name)                                                                   \
+	DEFINE_MEMBER_SET(Class, name, setter)
+
+#define MEMBER_EMIT(name) std::remove_reference_t<decltype(*this)>::M_##name::emitter(this)
+// NOLINTEND
+
+template <typename T>
+struct MemberPointerTraits;
+
+template <typename T, typename C>
+struct MemberPointerTraits<T C::*> {
+	using Class = C;
+	using Type = T;
+};
+
+template <auto member, auto signal = nullptr>
+class MemberMetadata {
+	using Traits = MemberPointerTraits<decltype(member)>;
+	using Class = Traits::Class;
+
+public:
+	using Type = Traits::Type;
+	using Ref = const Type&;
+	using Ret = std::conditional_t<std::is_null_pointer_v<decltype(signal)>, void, DropEmitter>;
+
+	static Ref get(const Class* obj) { return obj->*member; }
+
+	static Ret set(Class* obj, Ref value) {
+		if constexpr (signal == nullptr) {
+			if (MemberMetadata::get(obj) == value) return;
+			obj->*member = value;
+		} else {
+			if (MemberMetadata::get(obj) == value) return DropEmitter();
+			obj->*member = value;
+			return MemberMetadata::emitter(obj);
+		}
+	}
+
+	static Ret emitter(Class* obj) {
+		if constexpr (signal != nullptr) {
+			return DropEmitter(obj, &MemberMetadata::emitForObject);
+		}
+	}
+
+private:
+	static void emitForObject(Class* obj) { (obj->*signal)(); }
+};
+
+// allows use of member macros without an actual field backing them
+template <typename T, bool hasSignal>
+class PseudomemberMetadata {
+public:
+	using Type = T;
+	using Ref = const Type&;
+	using Ret = std::conditional_t<hasSignal, DropEmitter, void>;
+};
+
+class GuardedEmitBlocker {
+public:
+	explicit GuardedEmitBlocker(bool* var): var(var) { *this->var = true; }
+	~GuardedEmitBlocker() { *this->var = false; }
+	Q_DISABLE_COPY_MOVE(GuardedEmitBlocker);
+
+private:
+	bool* var;
+};
+
+template <auto signal>
+class GuardedEmitter {
+	using Traits = MemberPointerTraits<decltype(signal)>;
+	using Class = Traits::Class;
+
+	bool blocked = false;
+
+public:
+	GuardedEmitter() = default;
+	~GuardedEmitter() = default;
+	Q_DISABLE_COPY_MOVE(GuardedEmitter);
+
+	void call(Class* obj) {
+		if (!this->blocked) (obj->*signal)();
+	}
+
+	GuardedEmitBlocker block() { return GuardedEmitBlocker(&this->blocked); }
+};
+
+template <auto member, auto destroyedSlot, auto changedSignal>
+class SimpleObjectHandleOps {
+	using Traits = MemberPointerTraits<decltype(member)>;
+
+public:
+	static bool setObject(Traits::Class* parent, Traits::Type value) {
+		if (value == parent->*member) return false;
+
+		if (parent->*member != nullptr) {
+			QObject::disconnect(parent->*member, &QObject::destroyed, parent, destroyedSlot);
+		}
+
+		parent->*member = value;
+
+		if (value != nullptr) {
+			QObject::connect(parent->*member, &QObject::destroyed, parent, destroyedSlot);
+		}
+
+		if constexpr (changedSignal != nullptr) {
+			emit(parent->*changedSignal)();
+		}
+
+		return true;
+	}
+};
+
+template <auto member, auto destroyedSlot, auto changedSignal = nullptr>
+bool setSimpleObjectHandle(auto* parent, auto* value) {
+	return SimpleObjectHandleOps<member, destroyedSlot, changedSignal>::setObject(parent, value);
+}
+
+template <auto methodPtr>
+class MethodFunctor {
+	using PtrMeta = MemberPointerTraits<decltype(methodPtr)>;
+	using Class = PtrMeta::Class;
+
+public:
+	MethodFunctor(Class* obj): obj(obj) {}
+
+	void operator()() { (this->obj->*methodPtr)(); }
+
+private:
+	Class* obj;
+};
+
+// NOLINTBEGIN
+#define QS_BINDING_SUBSCRIBE_METHOD(Class, bindable, method, strategy)                             \
+	QPropertyChangeHandler<MethodFunctor<&Class::method>>                                            \
+	    _qs_method_subscribe_##bindable##_##method =                                                 \
+	        (bindable).strategy(MethodFunctor<&Class::method>(this));
+// NOLINTEND
diff --git a/src/core/variants.cpp b/src/core/variants.cpp
index e564e1bf..a190e36d 100644
--- a/src/core/variants.cpp
+++ b/src/core/variants.cpp
@@ -6,51 +6,110 @@
 #include <qlogging.h>
 #include <qobject.h>
 #include <qqmlengine.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
 
 #include "reload.hpp"
 
 void Variants::onReload(QObject* oldInstance) {
 	auto* old = qobject_cast<Variants*>(oldInstance);
 
-	for (auto& [variant, instanceObj]: this->instances.values) {
+	for (auto& [variant, instanceObj]: this->mInstances.values) {
 		QObject* oldInstance = nullptr;
 		if (old != nullptr) {
-			auto& values = old->instances.values;
+			auto& values = old->mInstances.values;
 
-			int matchcount = 0;
-			int matchi = 0;
-			int i = 0;
-			for (auto& [valueSet, _]: values) {
-				int count = 0;
-				for (auto& [k, v]: variant.toStdMap()) {
-					if (valueSet.contains(k) && valueSet.value(k) == v) {
-						count++;
+			if (variant.canConvert<QVariantMap>()) {
+				auto variantMap = variant.value<QVariantMap>();
+
+				int matchcount = 0;
+				int matchi = 0;
+				int i = 0;
+				for (auto& [value, _]: values) {
+					if (!value.canConvert<QVariantMap>()) continue;
+					auto valueSet = value.value<QVariantMap>();
+
+					int count = 0;
+					for (auto [k, v]: variantMap.asKeyValueRange()) {
+						if (valueSet.contains(k) && valueSet.value(k) == v) {
+							count++;
+						}
 					}
+
+					if (count > matchcount) {
+						matchcount = count;
+						matchi = i;
+					}
+
+					i++;
 				}
 
-				if (count > matchcount) {
-					matchcount = count;
-					matchi = i;
+				if (matchcount > 0) {
+					oldInstance = values.takeAt(matchi).second;
 				}
+			} else {
+				int i = 0;
+				for (auto& [value, _]: values) {
+					if (variant == value) {
+						oldInstance = values.takeAt(i).second;
+						break;
+					}
 
-				i++;
-			}
-
-			if (matchcount > 0) {
-				oldInstance = values.takeAt(matchi).second;
+					i++;
+				}
 			}
 		}
 
 		auto* instance = qobject_cast<Reloadable*>(instanceObj);
 
-		if (instance != nullptr) instance->onReload(oldInstance);
+		if (instance != nullptr) instance->reload(oldInstance);
 		else Reloadable::reloadChildrenRecursive(instanceObj, oldInstance);
 	}
+
+	this->loaded = true;
 }
 
-void Variants::setVariants(QVariantList variants) {
-	this->mVariants = std::move(variants);
+QVariant Variants::model() const { return QVariant::fromValue(this->mModel); }
+
+void Variants::setModel(const QVariant& model) {
+	if (model.canConvert<QVariantList>()) {
+		this->mModel = model.value<QVariantList>();
+	} else if (model.canConvert<QQmlListReference>()) {
+		auto list = model.value<QQmlListReference>();
+		if (!list.isReadable()) {
+			qWarning() << "Non readable list" << model << "assigned to Variants.model, Ignoring.";
+			return;
+		}
+
+		QVariantList model;
+		auto size = list.count();
+		for (auto i = 0; i < size; i++) {
+			model.push_back(QVariant::fromValue(list.at(i)));
+		}
+
+		this->mModel = std::move(model);
+	} else {
+		qWarning() << "Non list data" << model << "assigned to Variants.model, Ignoring.";
+		return;
+	}
+
 	this->updateVariants();
+	emit this->modelChanged();
+	emit this->instancesChanged();
+}
+
+QQmlListProperty<QObject> Variants::instances() {
+	return QQmlListProperty<QObject>(this, nullptr, &Variants::instanceCount, &Variants::instanceAt);
+}
+
+qsizetype Variants::instanceCount(QQmlListProperty<QObject>* prop) {
+	return static_cast<Variants*>(prop->object)->mInstances.values.length(); // NOLINT
+}
+
+QObject* Variants::instanceAt(QQmlListProperty<QObject>* prop, qsizetype i) {
+	return static_cast<Variants*>(prop->object)->mInstances.values.at(i).second; // NOLINT
 }
 
 void Variants::componentComplete() {
@@ -59,47 +118,46 @@ void Variants::componentComplete() {
 }
 
 void Variants::updateVariants() {
-	if (this->mComponent == nullptr) {
+	if (this->mDelegate == nullptr) {
 		qWarning() << "Variants instance does not have a component specified";
 		return;
 	}
 
 	// clean up removed entries
-	for (auto iter = this->instances.values.begin(); iter < this->instances.values.end();) {
-		if (this->mVariants.contains(iter->first)) {
+	for (auto iter = this->mInstances.values.begin(); iter < this->mInstances.values.end();) {
+		if (this->mModel.contains(iter->first)) {
 			iter++;
 		} else {
 			iter->second->deleteLater();
-			iter = this->instances.values.erase(iter);
+			iter = this->mInstances.values.erase(iter);
 		}
 	}
 
-	for (auto iter = this->mVariants.begin(); iter < this->mVariants.end(); iter++) {
-		auto& variantObj = *iter;
-		if (!variantObj.canConvert<QVariantMap>()) {
-			qWarning() << "value passed to Variants is not an object and will be ignored:" << variantObj;
-		} else {
-			auto variant = variantObj.value<QVariantMap>();
-
-			for (auto iter2 = this->mVariants.begin(); iter2 < iter; iter2++) {
-				if (*iter2 == variantObj) {
-					qWarning() << "same value specified twice in Variants, duplicates will be ignored:"
-					           << variantObj;
-					goto outer;
-				}
+	for (auto iter = this->mModel.begin(); iter < this->mModel.end(); iter++) {
+		auto& variant = *iter;
+		for (auto iter2 = this->mModel.begin(); iter2 < iter; iter2++) {
+			if (*iter2 == variant) {
+				qWarning() << "same value specified twice in Variants, duplicates will be ignored:"
+				           << variant;
+				goto outer;
 			}
+		}
 
-			if (this->instances.contains(variant)) {
+		{
+			if (this->mInstances.contains(variant)) {
 				continue; // we dont need to recreate this one
 			}
 
-			auto* instance = this->mComponent->createWithInitialProperties(
-			    variant,
-			    QQmlEngine::contextForObject(this->mComponent)
+			auto variantMap = QVariantMap();
+			variantMap.insert("modelData", variant);
+
+			auto* instance = this->mDelegate->createWithInitialProperties(
+			    variantMap,
+			    QQmlEngine::contextForObject(this->mDelegate)
 			);
 
 			if (instance == nullptr) {
-				qWarning() << this->mComponent->errorString().toStdString().c_str();
+				qWarning() << this->mDelegate->errorString().toStdString().c_str();
 				qWarning() << "failed to create variant with object" << variant;
 				continue;
 			}
@@ -107,7 +165,12 @@ void Variants::updateVariants() {
 			QQmlEngine::setObjectOwnership(instance, QQmlEngine::CppOwnership);
 
 			instance->setParent(this);
-			this->instances.insert(variant, instance);
+			this->mInstances.insert(variant, instance);
+
+			if (this->loaded) {
+				if (auto* reloadable = qobject_cast<Reloadable*>(instance)) reloadable->reload(nullptr);
+				else Reloadable::reloadChildrenRecursive(instance, nullptr);
+			}
 		}
 
 	outer:;
@@ -133,7 +196,7 @@ V* AwfulMap<K, V>::get(const K& key) {
 }
 
 template <typename K, typename V>
-void AwfulMap<K, V>::insert(K key, V value) {
+void AwfulMap<K, V>::insert(const K& key, V value) {
 	this->values.push_back(QPair<K, V>(key, value));
 }
 
diff --git a/src/core/variants.hpp b/src/core/variants.hpp
index 79224e24..fa0333d3 100644
--- a/src/core/variants.hpp
+++ b/src/core/variants.hpp
@@ -6,9 +6,12 @@
 #include <qmap.h>
 #include <qobject.h>
 #include <qqmlcomponent.h>
+#include <qqmllist.h>
 #include <qqmlparserstatus.h>
 #include <qtmetamacros.h>
+#include <qvariant.h>
 
+#include "doc.hpp"
 #include "reload.hpp"
 
 // extremely inefficient map
@@ -17,40 +20,64 @@ class AwfulMap {
 public:
 	[[nodiscard]] bool contains(const K& key) const;
 	[[nodiscard]] V* get(const K& key);
-	void insert(K key, V value); // assumes no duplicates
-	bool remove(const K& key);   // returns true if anything was removed
+	void insert(const K& key, V value); // assumes no duplicates
+	bool remove(const K& key);          // returns true if anything was removed
 	QList<QPair<K, V>> values;
 };
 
-///! Creates instances of a component based on a given set of variants.
+///! Creates instances of a component based on a given model.
 /// Creates and destroys instances of the given component when the given property changes.
 ///
-/// See [Quickshell.screens] for an example of using `Variants` to create copies of a window per
+/// `Variants` is similar to @@QtQuick.Repeater except it is for *non @@QtQuick.Item$* objects, and acts as
+/// a reload scope.
+///
+/// Each non duplicate value passed to @@model will create a new instance of
+/// @@delegate with a `modelData` property set to that value.
+///
+/// See @@Quickshell.screens for an example of using `Variants` to create copies of a window per
 /// screen.
 ///
-/// [Quickshell.screens]: ../quickshell#prop.screens
+/// > [!WARNING] BUG: Variants currently fails to reload children if the variant set is changed as
+/// > it is instantiated. (usually due to a mutation during variant creation)
 class Variants: public Reloadable {
 	Q_OBJECT;
-	/// The component to create instances of
-	Q_PROPERTY(QQmlComponent* component MEMBER mComponent);
+	/// The component to create instances of.
+	///
+	/// The delegate should define a `modelData` property that will be popuplated with a value
+	/// from the @@model.
+	Q_PROPERTY(QQmlComponent* delegate MEMBER mDelegate);
 	/// The list of sets of properties to create instances with.
 	/// Each set creates an instance of the component, which are updated when the input sets update.
-	Q_PROPERTY(QList<QVariant> variants MEMBER mVariants WRITE setVariants);
-	Q_CLASSINFO("DefaultProperty", "component");
+	QSDOC_PROPERTY_OVERRIDE(QList<QVariant> model READ model WRITE setModel NOTIFY modelChanged);
+	QSDOC_HIDE Q_PROPERTY(QVariant model READ model WRITE setModel NOTIFY modelChanged);
+	/// Current instances of the delegate.
+	Q_PROPERTY(QQmlListProperty<QObject> instances READ instances NOTIFY instancesChanged);
+	Q_CLASSINFO("DefaultProperty", "delegate");
 	QML_ELEMENT;
 
 public:
 	explicit Variants(QObject* parent = nullptr): Reloadable(parent) {}
 
 	void onReload(QObject* oldInstance) override;
-
 	void componentComplete() override;
 
+	[[nodiscard]] QVariant model() const;
+	void setModel(const QVariant& model);
+
+	QQmlListProperty<QObject> instances();
+
+signals:
+	void modelChanged();
+	void instancesChanged();
+
 private:
-	void setVariants(QVariantList variants);
+	static qsizetype instanceCount(QQmlListProperty<QObject>* prop);
+	static QObject* instanceAt(QQmlListProperty<QObject>* prop, qsizetype i);
+
 	void updateVariants();
 
-	QQmlComponent* mComponent = nullptr;
-	QVariantList mVariants;
-	AwfulMap<QVariantMap, QObject*> instances;
+	QQmlComponent* mDelegate = nullptr;
+	QVariantList mModel;
+	AwfulMap<QVariant, QObject*> mInstances;
+	bool loaded = false;
 };
diff --git a/src/core/watcher.cpp b/src/core/watcher.cpp
deleted file mode 100644
index 6b06d584..00000000
--- a/src/core/watcher.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "watcher.hpp"
-
-#include <qdir.h>
-#include <qfileinfo.h>
-#include <qfilesystemwatcher.h>
-#include <qobject.h>
-#include <qtmetamacros.h>
-
-FiletreeWatcher::FiletreeWatcher(QObject* parent): QObject(parent) {
-	QObject::connect(
-	    &this->watcher,
-	    &QFileSystemWatcher::fileChanged,
-	    this,
-	    &FiletreeWatcher::onFileChanged
-	);
-
-	QObject::connect(
-	    &this->watcher,
-	    &QFileSystemWatcher::directoryChanged,
-	    this,
-	    &FiletreeWatcher::onDirectoryChanged
-	);
-}
-void FiletreeWatcher::addPath(const QString& path) {
-	this->watcher.addPath(path);
-
-	if (QFileInfo(path).isDir()) {
-		auto dir = QDir(path);
-
-		for (auto& entry: dir.entryList(QDir::AllEntries | QDir::NoDotAndDotDot)) {
-			this->addPath(dir.filePath(entry));
-		}
-	}
-}
-
-void FiletreeWatcher::onDirectoryChanged(const QString& path) { this->addPath(path); }
-
-void FiletreeWatcher::onFileChanged(const QString& path) { emit this->fileChanged(path); }
diff --git a/src/core/watcher.hpp b/src/core/watcher.hpp
deleted file mode 100644
index a729f03c..00000000
--- a/src/core/watcher.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-
-#include <qdir.h>
-#include <qfilesystemwatcher.h>
-#include <qobject.h>
-
-class FiletreeWatcher: public QObject {
-	Q_OBJECT;
-
-public:
-	explicit FiletreeWatcher(QObject* parent = nullptr);
-
-	void addPath(const QString& path);
-
-signals:
-	void fileChanged(const QString& path);
-
-private slots:
-	void onDirectoryChanged(const QString& path);
-	void onFileChanged(const QString& path);
-
-private:
-	QFileSystemWatcher watcher;
-};
diff --git a/src/core/windowinterface.cpp b/src/core/windowinterface.cpp
deleted file mode 100644
index a29bd599..00000000
--- a/src/core/windowinterface.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "windowinterface.hpp" // NOLINT
diff --git a/src/core/windowinterface.hpp b/src/core/windowinterface.hpp
deleted file mode 100644
index 4f20d9c0..00000000
--- a/src/core/windowinterface.hpp
+++ /dev/null
@@ -1,125 +0,0 @@
-#pragma once
-
-#include <qcolor.h>
-#include <qobject.h>
-#include <qqmlintegration.h>
-#include <qqmllist.h>
-#include <qquickitem.h>
-#include <qtmetamacros.h>
-#include <qtypes.h>
-
-#include "qmlscreen.hpp"
-#include "region.hpp"
-#include "reload.hpp"
-
-class WindowInterface: public Reloadable {
-	Q_OBJECT;
-	// clang-format off
-	Q_PROPERTY(QQuickItem* contentItem READ contentItem);
-	/// If the window is shown or hidden. Defaults to true.
-	Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged);
-	Q_PROPERTY(qint32 width READ width WRITE setWidth NOTIFY widthChanged);
-	Q_PROPERTY(qint32 height READ height WRITE setHeight NOTIFY heightChanged);
-	/// The screen that the window currently occupies.
-	///
-	/// > [!INFO] This cannot be changed after windowConnected.
-	Q_PROPERTY(QuickshellScreenInfo* screen READ screen WRITE setScreen NOTIFY screenChanged);
-	/// The background color of the window. Defaults to white.
-	///
-	/// > [!WARNING] This seems to behave weirdly when using transparent colors on some systems.
-	/// > Using a colored content item over a transparent window is the recommended way to work around this:
-	/// > ```qml
-	/// > ProxyWindow {
-	/// >   color: "transparent"
-	/// >   Rectangle {
-	/// >     anchors.fill: parent
-	/// >     color: "#20ffffff"
-	/// >
-	/// >     // your content here
-	/// >   }
-	/// > }
-	/// > ```
-	Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged);
-	/// The clickthrough mask. Defaults to null.
-	///
-	/// If non null then the clickable areas of the window will be determined by the provided region.
-	///
-	/// ```qml
-	/// ShellWindow {
-	///   // The mask region is set to `rect`, meaning only `rect` is clickable.
-	///   // All other clicks pass through the window to ones behind it.
-	///   mask: Region { item: rect }
-	///
-	///   Rectangle {
-	///     id: rect
-	///
-	///     anchors.centerIn: parent
-	///     width: 100
-	///     height: 100
-	///   }
-	/// }
-	/// ```
-	///
-	/// If the provided region's intersection mode is `Combine` (the default),
-	/// then the region will be used as is. Otherwise it will be applied on top of the window region.
-	///
-	/// For example, setting the intersection mode to `Xor` will invert the mask and make everything in
-	/// the mask region not clickable and pass through clicks inside it through the window.
-	///
-	/// ```qml
-	/// ShellWindow {
-	///   // The mask region is set to `rect`, but the intersection mode is set to `Xor`.
-	///   // This inverts the mask causing all clicks inside `rect` to be passed to the window
-	///   // behind this one.
-	///   mask: Region { item: rect; intersection: Intersection.Xor }
-	///
-	///   Rectangle {
-	///     id: rect
-	///
-	///     anchors.centerIn: parent
-	///     width: 100
-	///     height: 100
-	///   }
-	/// }
-	/// ```
-	Q_PROPERTY(PendingRegion* mask READ mask WRITE setMask NOTIFY maskChanged);
-	Q_PROPERTY(QQmlListProperty<QObject> data READ data);
-	// clang-format on
-	Q_CLASSINFO("DefaultProperty", "data");
-	QML_NAMED_ELEMENT(QSWindow);
-	QML_UNCREATABLE("uncreatable base class");
-
-public:
-	explicit WindowInterface(QObject* parent = nullptr): Reloadable(parent) {}
-
-	[[nodiscard]] virtual QQuickItem* contentItem() const = 0;
-
-	[[nodiscard]] virtual bool isVisible() const = 0;
-	virtual void setVisible(bool visible) = 0;
-
-	[[nodiscard]] virtual qint32 width() const = 0;
-	virtual void setWidth(qint32 width) = 0;
-
-	[[nodiscard]] virtual qint32 height() const = 0;
-	virtual void setHeight(qint32 height) = 0;
-
-	[[nodiscard]] virtual QuickshellScreenInfo* screen() const = 0;
-	virtual void setScreen(QuickshellScreenInfo* screen) = 0;
-
-	[[nodiscard]] virtual QColor color() const = 0;
-	virtual void setColor(QColor color) = 0;
-
-	[[nodiscard]] virtual PendingRegion* mask() const = 0;
-	virtual void setMask(PendingRegion* mask) = 0;
-
-	[[nodiscard]] virtual QQmlListProperty<QObject> data() = 0;
-
-signals:
-	void windowConnected();
-	void visibleChanged();
-	void widthChanged();
-	void heightChanged();
-	void screenChanged();
-	void colorChanged();
-	void maskChanged();
-};
diff --git a/src/crash/CMakeLists.txt b/src/crash/CMakeLists.txt
new file mode 100644
index 00000000..7fdd8305
--- /dev/null
+++ b/src/crash/CMakeLists.txt
@@ -0,0 +1,17 @@
+qt_add_library(quickshell-crash STATIC
+	main.cpp
+	interface.cpp
+	handler.cpp
+)
+
+qs_pch(quickshell-crash SET large)
+
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(breakpad REQUIRED IMPORTED_TARGET breakpad)
+# only need client?? take only includes from pkg config todo
+target_link_libraries(quickshell-crash PRIVATE PkgConfig::breakpad -lbreakpad_client)
+
+# quick linked for pch compat
+target_link_libraries(quickshell-crash PRIVATE quickshell-build Qt::Quick Qt::Widgets)
+
+target_link_libraries(quickshell PRIVATE quickshell-crash)
diff --git a/src/crash/handler.cpp b/src/crash/handler.cpp
new file mode 100644
index 00000000..1433a879
--- /dev/null
+++ b/src/crash/handler.cpp
@@ -0,0 +1,185 @@
+#include "handler.hpp"
+#include <array>
+#include <cstdio>
+#include <cstring>
+
+#include <bits/types/sigset_t.h>
+#include <breakpad/client/linux/handler/exception_handler.h>
+#include <breakpad/client/linux/handler/minidump_descriptor.h>
+#include <breakpad/common/linux/linux_libc_support.h>
+#include <qdatastream.h>
+#include <qfile.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include "../core/instanceinfo.hpp"
+#include "../core/logcat.hpp"
+
+extern char** environ; // NOLINT
+
+using namespace google_breakpad;
+
+namespace qs::crash {
+
+namespace {
+QS_LOGGING_CATEGORY(logCrashHandler, "quickshell.crashhandler", QtWarningMsg);
+}
+
+struct CrashHandlerPrivate {
+	ExceptionHandler* exceptionHandler = nullptr;
+	int minidumpFd = -1;
+	int infoFd = -1;
+
+	static bool minidumpCallback(const MinidumpDescriptor& descriptor, void* context, bool succeeded);
+};
+
+CrashHandler::CrashHandler(): d(new CrashHandlerPrivate()) {}
+
+void CrashHandler::init() {
+	// MinidumpDescriptor has no move constructor and the copy constructor breaks fds.
+	auto createHandler = [this](const MinidumpDescriptor& desc) {
+		this->d->exceptionHandler = new ExceptionHandler(
+		    desc,
+		    nullptr,
+		    &CrashHandlerPrivate::minidumpCallback,
+		    this->d,
+		    true,
+		    -1
+		);
+	};
+
+	qCDebug(logCrashHandler) << "Starting crash handler...";
+
+	this->d->minidumpFd = memfd_create("quickshell:minidump", MFD_CLOEXEC);
+
+	if (this->d->minidumpFd == -1) {
+		qCCritical(logCrashHandler
+		) << "Failed to allocate minidump memfd, minidumps will be saved in the working directory.";
+		createHandler(MinidumpDescriptor("."));
+	} else {
+		qCDebug(logCrashHandler) << "Created memfd" << this->d->minidumpFd
+		                         << "for holding possible minidumps.";
+		createHandler(MinidumpDescriptor(this->d->minidumpFd));
+	}
+
+	qCInfo(logCrashHandler) << "Crash handler initialized.";
+}
+
+void CrashHandler::setRelaunchInfo(const RelaunchInfo& info) {
+	this->d->infoFd = memfd_create("quickshell:instance_info", MFD_CLOEXEC);
+
+	if (this->d->infoFd == -1) {
+		qCCritical(logCrashHandler
+		) << "Failed to allocate instance info memfd, crash recovery will not work.";
+		return;
+	}
+
+	QFile file;
+	file.open(this->d->infoFd, QFile::ReadWrite);
+
+	QDataStream ds(&file);
+	ds << info;
+	file.flush();
+
+	qCDebug(logCrashHandler) << "Stored instance info in memfd" << this->d->infoFd;
+}
+
+CrashHandler::~CrashHandler() {
+	delete this->d->exceptionHandler;
+	delete this->d;
+}
+
+bool CrashHandlerPrivate::minidumpCallback(
+    const MinidumpDescriptor& /*descriptor*/,
+    void* context,
+    bool /*success*/
+) {
+	// A fork that just dies to ensure the coredump is caught by the system.
+	auto coredumpPid = fork();
+
+	if (coredumpPid == 0) {
+		return false;
+	}
+
+	auto* self = static_cast<CrashHandlerPrivate*>(context);
+
+	auto exe = std::array<char, 4096>();
+	if (readlink("/proc/self/exe", exe.data(), exe.size() - 1) == -1) {
+		perror("Failed to find crash reporter executable.\n");
+		_exit(-1);
+	}
+
+	auto arg = std::array<char*, 2> {exe.data(), nullptr};
+
+	auto env = std::array<char*, 4096>();
+	auto envi = 0;
+
+	auto infoFd = dup(self->infoFd);
+	auto infoFdStr = std::array<char, 38>();
+	memcpy(infoFdStr.data(), "__QUICKSHELL_CRASH_INFO_FD=-1" /*\0*/, 30);
+	if (infoFd != -1) my_uitos(&infoFdStr[27], infoFd, 10);
+	env[envi++] = infoFdStr.data();
+
+	auto corePidStr = std::array<char, 39>();
+	memcpy(corePidStr.data(), "__QUICKSHELL_CRASH_DUMP_PID=-1" /*\0*/, 31);
+	if (coredumpPid != -1) my_uitos(&corePidStr[28], coredumpPid, 10);
+	env[envi++] = corePidStr.data();
+
+	auto populateEnv = [&]() {
+		auto senvi = 0;
+		while (envi != 4095) {
+			auto var = environ[senvi++]; // NOLINT
+			if (var == nullptr) break;
+			env[envi++] = var;
+		}
+
+		env[envi] = nullptr;
+	};
+
+	sigset_t sigset;
+	sigemptyset(&sigset);                       // NOLINT (include)
+	sigprocmask(SIG_SETMASK, &sigset, nullptr); // NOLINT
+
+	auto pid = fork();
+
+	if (pid == -1) {
+		perror("Failed to fork and launch crash reporter.\n");
+		return false;
+	} else if (pid == 0) {
+		// dup to remove CLOEXEC
+		// if already -1 will return -1
+		auto dumpFd = dup(self->minidumpFd);
+		auto logFd = dup(CrashInfo::INSTANCE.logFd);
+
+		// allow up to 10 digits, which should never happen
+		auto dumpFdStr = std::array<char, 38>();
+		auto logFdStr = std::array<char, 37>();
+
+		memcpy(dumpFdStr.data(), "__QUICKSHELL_CRASH_DUMP_FD=-1" /*\0*/, 30);
+		memcpy(logFdStr.data(), "__QUICKSHELL_CRASH_LOG_FD=-1" /*\0*/, 29);
+
+		if (dumpFd != -1) my_uitos(&dumpFdStr[27], dumpFd, 10);
+		if (logFd != -1) my_uitos(&logFdStr[26], logFd, 10);
+
+		env[envi++] = dumpFdStr.data();
+		env[envi++] = logFdStr.data();
+
+		populateEnv();
+		execve(exe.data(), arg.data(), env.data());
+
+		perror("Failed to launch crash reporter.\n");
+		_exit(-1);
+	} else {
+		populateEnv();
+		execve(exe.data(), arg.data(), env.data());
+
+		perror("Failed to relaunch quickshell.\n");
+		_exit(-1);
+	}
+
+	return false; // should make sure it hits the system coredump handler
+}
+
+} // namespace qs::crash
diff --git a/src/crash/handler.hpp b/src/crash/handler.hpp
new file mode 100644
index 00000000..2a1d86fa
--- /dev/null
+++ b/src/crash/handler.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <qtclasshelpermacros.h>
+
+#include "../core/instanceinfo.hpp"
+namespace qs::crash {
+
+struct CrashHandlerPrivate;
+
+class CrashHandler {
+public:
+	explicit CrashHandler();
+	~CrashHandler();
+	Q_DISABLE_COPY_MOVE(CrashHandler);
+
+	void init();
+	void setRelaunchInfo(const RelaunchInfo& info);
+
+private:
+	CrashHandlerPrivate* d;
+};
+
+} // namespace qs::crash
diff --git a/src/crash/interface.cpp b/src/crash/interface.cpp
new file mode 100644
index 00000000..c6334401
--- /dev/null
+++ b/src/crash/interface.cpp
@@ -0,0 +1,120 @@
+#include "interface.hpp"
+#include <cstring>
+#include <utility>
+
+#include <qapplication.h>
+#include <qboxlayout.h>
+#include <qconfig.h>
+#include <qdesktopservices.h>
+#include <qfont.h>
+#include <qfontinfo.h>
+#include <qlabel.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qpushbutton.h>
+#include <qtversion.h>
+#include <qwidget.h>
+
+#include "build.hpp"
+
+class ReportLabel: public QWidget {
+public:
+	ReportLabel(const QString& label, const QString& content, QWidget* parent): QWidget(parent) {
+		auto* layout = new QHBoxLayout(this);
+		layout->setContentsMargins(0, 0, 0, 0);
+		layout->addWidget(new QLabel(label, this));
+
+		auto* cl = new QLabel(content, this);
+		cl->setTextInteractionFlags(Qt::TextSelectableByMouse);
+		layout->addWidget(cl);
+
+		layout->addStretch();
+	}
+};
+
+CrashReporterGui::CrashReporterGui(QString reportFolder, int pid)
+    : reportFolder(std::move(reportFolder)) {
+	this->setWindowFlags(Qt::Window);
+
+	auto textHeight = QFontInfo(QFont()).pixelSize();
+
+	auto* mainLayout = new QVBoxLayout(this);
+
+	auto qtVersionMatches = strcmp(qVersion(), QT_VERSION_STR) == 0;
+	if (qtVersionMatches) {
+		mainLayout->addWidget(new QLabel(
+		    "<u>Quickshell has crashed. Please submit a bug report to help us fix it.</u>",
+		    this
+		));
+	} else {
+		mainLayout->addWidget(
+		    new QLabel("<u>Quickshell has crashed, likely due to a Qt version mismatch.</u>", this)
+		);
+	}
+
+	mainLayout->addSpacing(textHeight);
+
+	mainLayout->addWidget(new QLabel("General information", this));
+	mainLayout->addWidget(new ReportLabel("Git Revision:", GIT_REVISION, this));
+	mainLayout->addWidget(new QLabel(
+	    QString::fromLatin1("Runtime Qt version: ") % qVersion() % ", Buildtime Qt version: "
+	        % QT_VERSION_STR,
+	    this
+	));
+	mainLayout->addWidget(new ReportLabel("Crashed process ID:", QString::number(pid), this));
+	mainLayout->addWidget(new ReportLabel("Crash report folder:", this->reportFolder, this));
+	mainLayout->addSpacing(textHeight);
+
+	if (qtVersionMatches) {
+		mainLayout->addWidget(new QLabel("Please open a bug report for this issue via github or email.")
+		);
+	} else {
+		mainLayout->addWidget(new QLabel(
+		    "Please rebuild Quickshell against the current Qt version.\n"
+		    "If this does not solve the problem, please open a bug report via github or email."
+		));
+	}
+
+	mainLayout->addWidget(new ReportLabel(
+	    "Github:",
+	    "https://github.com/quickshell-mirror/quickshell/issues/new?template=crash.yml",
+	    this
+	));
+
+	mainLayout->addWidget(new ReportLabel("Email:", "quickshell-bugs@outfoxxed.me", this));
+
+	auto* buttons = new QWidget(this);
+	buttons->setMinimumWidth(900);
+	auto* buttonLayout = new QHBoxLayout(buttons);
+	buttonLayout->setContentsMargins(0, 0, 0, 0);
+
+	auto* reportButton = new QPushButton("Open report page", buttons);
+	reportButton->setDefault(true);
+	QObject::connect(reportButton, &QPushButton::clicked, this, &CrashReporterGui::openReportUrl);
+	buttonLayout->addWidget(reportButton);
+
+	auto* openFolderButton = new QPushButton("Open crash folder", buttons);
+	QObject::connect(openFolderButton, &QPushButton::clicked, this, &CrashReporterGui::openFolder);
+	buttonLayout->addWidget(openFolderButton);
+
+	auto* cancelButton = new QPushButton("Exit", buttons);
+	QObject::connect(cancelButton, &QPushButton::clicked, this, &CrashReporterGui::cancel);
+	buttonLayout->addWidget(cancelButton);
+
+	mainLayout->addWidget(buttons);
+
+	mainLayout->addStretch();
+	this->setFixedSize(this->sizeHint());
+}
+
+void CrashReporterGui::openFolder() {
+	QDesktopServices::openUrl(QUrl::fromLocalFile(this->reportFolder));
+}
+
+void CrashReporterGui::openReportUrl() {
+	QDesktopServices::openUrl(
+	    QUrl("https://github.com/outfoxxed/quickshell/issues/new?template=crash.yml")
+	);
+}
+
+void CrashReporterGui::cancel() { QApplication::quit(); }
diff --git a/src/crash/interface.hpp b/src/crash/interface.hpp
new file mode 100644
index 00000000..d7800435
--- /dev/null
+++ b/src/crash/interface.hpp
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <qwidget.h>
+
+class CrashReporterGui: public QWidget {
+public:
+	CrashReporterGui(QString reportFolder, int pid);
+
+private slots:
+	void openFolder();
+
+	static void openReportUrl();
+	static void cancel();
+
+private:
+	QString reportFolder;
+};
diff --git a/src/crash/main.cpp b/src/crash/main.cpp
new file mode 100644
index 00000000..b9f0eabe
--- /dev/null
+++ b/src/crash/main.cpp
@@ -0,0 +1,191 @@
+#include "main.hpp"
+#include <cerrno>
+#include <cstdlib>
+
+#include <qapplication.h>
+#include <qconfig.h>
+#include <qcoreapplication.h>
+#include <qdatastream.h>
+#include <qdir.h>
+#include <qfile.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qtenvironmentvariables.h>
+#include <qtextstream.h>
+#include <qtversion.h>
+#include <sys/sendfile.h>
+#include <sys/types.h>
+
+#include "../core/instanceinfo.hpp"
+#include "../core/logcat.hpp"
+#include "../core/logging.hpp"
+#include "../core/paths.hpp"
+#include "build.hpp"
+#include "interface.hpp"
+
+namespace {
+
+QS_LOGGING_CATEGORY(logCrashReporter, "quickshell.crashreporter", QtWarningMsg);
+
+int tryDup(int fd, const QString& path) {
+	QFile sourceFile;
+	if (!sourceFile.open(fd, QFile::ReadOnly, QFile::AutoCloseHandle)) {
+		qCCritical(logCrashReporter) << "Failed to open source fd for duplication.";
+		return 1;
+	}
+
+	auto destFile = QFile(path);
+	if (!destFile.open(QFile::WriteOnly)) {
+		qCCritical(logCrashReporter) << "Failed to open dest file for duplication.";
+		return 2;
+	}
+
+	auto size = sourceFile.size();
+	off_t offset = 0;
+	ssize_t count = 0;
+
+	sourceFile.seek(0);
+
+	while (count != size) {
+		auto r = sendfile(destFile.handle(), sourceFile.handle(), &offset, sourceFile.size());
+		if (r == -1) {
+			qCCritical(logCrashReporter).nospace()
+			    << "Failed to duplicate fd " << fd << " with error code " << errno
+			    << ". Error: " << qt_error_string();
+			return 3;
+		} else {
+			count += r;
+		}
+	}
+
+	return 0;
+}
+
+void recordCrashInfo(const QDir& crashDir, const InstanceInfo& instance) {
+	qCDebug(logCrashReporter) << "Recording crash information at" << crashDir.path();
+
+	if (!crashDir.mkpath(".")) {
+		qCCritical(logCrashReporter) << "Failed to create folder" << crashDir
+		                             << "to save crash information.";
+		return;
+	}
+
+	auto crashProc = qEnvironmentVariable("__QUICKSHELL_CRASH_DUMP_PID").toInt();
+	auto dumpFd = qEnvironmentVariable("__QUICKSHELL_CRASH_DUMP_FD").toInt();
+	auto logFd = qEnvironmentVariable("__QUICKSHELL_CRASH_LOG_FD").toInt();
+
+	qCDebug(logCrashReporter) << "Saving minidump from fd" << dumpFd;
+	auto dumpDupStatus = tryDup(dumpFd, crashDir.filePath("minidump.dmp.log"));
+	if (dumpDupStatus != 0) {
+		qCCritical(logCrashReporter) << "Failed to write minidump:" << dumpDupStatus;
+	}
+
+	qCDebug(logCrashReporter) << "Saving log from fd" << logFd;
+	auto logDupStatus = tryDup(logFd, crashDir.filePath("log.qslog.log"));
+	if (logDupStatus != 0) {
+		qCCritical(logCrashReporter) << "Failed to save log:" << logDupStatus;
+	}
+
+	auto copyBinStatus = 0;
+	if (!DISTRIBUTOR_DEBUGINFO_AVAILABLE) {
+		qCDebug(logCrashReporter) << "Copying binary to crash folder";
+		if (!QFile(QCoreApplication::applicationFilePath()).copy(crashDir.filePath("executable.txt"))) {
+			copyBinStatus = 1;
+			qCCritical(logCrashReporter) << "Failed to copy binary.";
+		}
+	}
+
+	{
+		auto extraInfoFile = QFile(crashDir.filePath("info.txt"));
+		if (!extraInfoFile.open(QFile::WriteOnly)) {
+			qCCritical(logCrashReporter) << "Failed to open crash info file for writing.";
+		} else {
+			auto stream = QTextStream(&extraInfoFile);
+			stream << "===== Build Information =====\n";
+			stream << "Git Revision: " << GIT_REVISION << '\n';
+			stream << "Buildtime Qt Version: " << QT_VERSION_STR << "\n";
+			stream << "Build Type: " << BUILD_TYPE << '\n';
+			stream << "Compiler: " << COMPILER << '\n';
+			stream << "Complie Flags: " << COMPILE_FLAGS << "\n\n";
+			stream << "Build configuration:\n" << BUILD_CONFIGURATION << "\n";
+
+			stream << "\n===== Runtime Information =====\n";
+			stream << "Runtime Qt Version: " << qVersion() << '\n';
+			stream << "Crashed process ID: " << crashProc << '\n';
+			stream << "Run ID: " << instance.instanceId << '\n';
+			stream << "Shell ID: " << instance.shellId << '\n';
+			stream << "Config Path: " << instance.configPath << '\n';
+
+			stream << "\n===== Report Integrity =====\n";
+			stream << "Minidump save status: " << dumpDupStatus << '\n';
+			stream << "Log save status: " << logDupStatus << '\n';
+			stream << "Binary copy status: " << copyBinStatus << '\n';
+
+			stream << "\n===== System Information =====\n\n";
+			stream << "/etc/os-release:";
+			auto osReleaseFile = QFile("/etc/os-release");
+			if (osReleaseFile.open(QFile::ReadOnly)) {
+				stream << '\n' << osReleaseFile.readAll() << '\n';
+				osReleaseFile.close();
+			} else {
+				stream << "FAILED TO OPEN\n";
+			}
+
+			stream << "/etc/lsb-release:";
+			auto lsbReleaseFile = QFile("/etc/lsb-release");
+			if (lsbReleaseFile.open(QFile::ReadOnly)) {
+				stream << '\n' << lsbReleaseFile.readAll();
+				lsbReleaseFile.close();
+			} else {
+				stream << "FAILED TO OPEN\n";
+			}
+
+			extraInfoFile.close();
+		}
+	}
+
+	qCDebug(logCrashReporter) << "Recorded crash information.";
+}
+
+} // namespace
+
+void qsCheckCrash(int argc, char** argv) {
+	auto fd = qEnvironmentVariable("__QUICKSHELL_CRASH_DUMP_FD");
+	if (fd.isEmpty()) return;
+
+	RelaunchInfo info;
+
+	auto crashProc = qEnvironmentVariable("__QUICKSHELL_CRASH_DUMP_PID").toInt();
+
+	{
+		auto infoFd = qEnvironmentVariable("__QUICKSHELL_CRASH_INFO_FD").toInt();
+
+		QFile file;
+		file.open(infoFd, QFile::ReadOnly, QFile::AutoCloseHandle);
+		file.seek(0);
+
+		auto ds = QDataStream(&file);
+		ds >> info;
+	}
+
+	LogManager::init(
+	    !info.noColor,
+	    info.timestamp,
+	    info.sparseLogsOnly,
+	    info.defaultLogLevel,
+	    info.logRules
+	);
+
+	auto app = QApplication(argc, argv);
+	QApplication::setDesktopFileName("org.quickshell");
+
+	auto crashDir = QsPaths::crashDir(info.instance.instanceId);
+
+	qCInfo(logCrashReporter) << "Starting crash reporter...";
+
+	recordCrashInfo(crashDir, info.instance);
+
+	auto gui = CrashReporterGui(crashDir.path(), crashProc);
+	gui.show();
+	exit(QApplication::exec()); // NOLINT
+}
diff --git a/src/crash/main.hpp b/src/crash/main.hpp
new file mode 100644
index 00000000..b6a282cf
--- /dev/null
+++ b/src/crash/main.hpp
@@ -0,0 +1,3 @@
+#pragma once
+
+void qsCheckCrash(int argc, char** argv);
diff --git a/src/dbus/CMakeLists.txt b/src/dbus/CMakeLists.txt
new file mode 100644
index 00000000..fc004f3d
--- /dev/null
+++ b/src/dbus/CMakeLists.txt
@@ -0,0 +1,44 @@
+set_source_files_properties(org.freedesktop.DBus.Properties.xml PROPERTIES
+	CLASSNAME DBusPropertiesInterface
+)
+
+set_source_files_properties(org.freedesktop.DBus.ObjectManager.xml PROPERTIES
+	CLASSNAME DBusObjectManagerInterface
+	INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/dbus_objectmanager_types.hpp
+)
+
+qt_add_dbus_interface(DBUS_INTERFACES
+	org.freedesktop.DBus.Properties.xml
+	dbus_properties
+)
+
+qt_add_dbus_interface(DBUS_INTERFACES
+	org.freedesktop.DBus.ObjectManager.xml
+	dbus_objectmanager
+)
+
+qt_add_library(quickshell-dbus STATIC
+	properties.cpp
+	objectmanager.cpp
+	bus.cpp
+	${DBUS_INTERFACES}
+)
+
+# dbus headers
+target_include_directories(quickshell-dbus PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+
+target_link_libraries(quickshell-dbus PRIVATE Qt::Core Qt::DBus)
+# todo: link dbus to quickshell here instead of in modules that use it directly
+# linker does not like this as is
+
+qs_add_pchset(dbus
+	DEPENDENCIES Qt::DBus
+	HEADERS
+		<QtDBus>
+		<qdebug.h>
+		<qdbusargument.h>
+)
+
+qs_pch(quickshell-dbus SET dbus)
+
+add_subdirectory(dbusmenu)
diff --git a/src/dbus/bus.cpp b/src/dbus/bus.cpp
new file mode 100644
index 00000000..d53c4c6b
--- /dev/null
+++ b/src/dbus/bus.cpp
@@ -0,0 +1,61 @@
+#include "bus.hpp" // NOLINT
+#include <functional>
+
+#include <qcontainerfwd.h>
+#include <qdbusconnection.h>
+#include <qdbusmessage.h>
+#include <qdbuspendingcall.h>
+#include <qdbuspendingreply.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+#include "../core/logcat.hpp"
+
+namespace qs::dbus {
+
+namespace {
+QS_LOGGING_CATEGORY(logDbus, "quickshell.dbus", QtWarningMsg);
+}
+
+void tryLaunchService(
+    QObject* parent,
+    QDBusConnection& connection,
+    const QString& serviceName,
+    const std::function<void(bool)>& callback
+) {
+	qCDebug(logDbus) << "Attempting to launch service" << serviceName;
+
+	auto message = QDBusMessage::createMethodCall(
+	    "org.freedesktop.DBus",
+	    "/org/freedesktop/DBus",
+	    "org.freedesktop.DBus",
+	    "StartServiceByName"
+	);
+
+	message << serviceName << 0u;
+	auto pendingCall = connection.asyncCall(message);
+
+	auto* call = new QDBusPendingCallWatcher(pendingCall, parent);
+
+	auto responseCallback = [callback, serviceName](QDBusPendingCallWatcher* call) {
+		const QDBusPendingReply<quint32> reply = *call;
+
+		if (reply.isError()) {
+			qCWarning(logDbus).noquote().nospace()
+			    << "Could not launch service " << serviceName << ": " << reply.error();
+			callback(false);
+		} else {
+			qCDebug(logDbus) << "Service launch successful for" << serviceName;
+			callback(true);
+		}
+
+		delete call;
+	};
+
+	QObject::connect(call, &QDBusPendingCallWatcher::finished, parent, responseCallback);
+}
+
+} // namespace qs::dbus
diff --git a/src/dbus/bus.hpp b/src/dbus/bus.hpp
new file mode 100644
index 00000000..1c4c71e4
--- /dev/null
+++ b/src/dbus/bus.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <functional>
+
+#include <qcontainerfwd.h>
+#include <qdbusconnection.h>
+#include <qobject.h>
+
+namespace qs::dbus {
+
+void tryLaunchService(
+    QObject* parent,
+    QDBusConnection& connection,
+    const QString& serviceName,
+    const std::function<void(bool)>& callback
+);
+
+}
diff --git a/src/dbus/dbus_objectmanager_types.hpp b/src/dbus/dbus_objectmanager_types.hpp
new file mode 100644
index 00000000..5e0869c1
--- /dev/null
+++ b/src/dbus/dbus_objectmanager_types.hpp
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <qdbusextratypes.h>
+#include <qhash.h>
+#include <qmap.h>
+#include <qstring.h>
+#include <qvariant.h>
+
+using DBusObjectManagerInterfaces = QHash<QString, QVariantMap>;
+using DBusObjectManagerObjects = QHash<QDBusObjectPath, DBusObjectManagerInterfaces>;
diff --git a/src/dbus/dbusmenu/CMakeLists.txt b/src/dbus/dbusmenu/CMakeLists.txt
new file mode 100644
index 00000000..61cee42c
--- /dev/null
+++ b/src/dbus/dbusmenu/CMakeLists.txt
@@ -0,0 +1,35 @@
+set_source_files_properties(com.canonical.dbusmenu.xml PROPERTIES
+	CLASSNAME DBusMenuInterface
+	INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/dbus_menu_types.hpp
+)
+
+qt_add_dbus_interface(DBUS_INTERFACES
+	com.canonical.dbusmenu.xml
+	dbus_menu
+)
+
+qt_add_library(quickshell-dbusmenu STATIC
+	dbus_menu_types.cpp
+	dbusmenu.cpp
+	${DBUS_INTERFACES}
+)
+
+qt_add_qml_module(quickshell-dbusmenu
+	URI Quickshell.DBusMenu
+	VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+qs_add_module_deps_light(quickshell-dbusmenu Quickshell)
+
+install_qml_module(quickshell-dbusmenu)
+
+# dbus headers
+target_include_directories(quickshell-dbusmenu PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+
+target_link_libraries(quickshell-dbusmenu PRIVATE Qt::Quick Qt::DBus)
+qs_add_link_dependencies(quickshell-dbusmenu quickshell-dbus)
+
+qs_module_pch(quickshell-dbusmenu SET dbus)
+
+target_link_libraries(quickshell PRIVATE quickshell-dbusmenuplugin)
diff --git a/src/dbus/dbusmenu/com.canonical.dbusmenu.xml b/src/dbus/dbusmenu/com.canonical.dbusmenu.xml
new file mode 100644
index 00000000..12f021bc
--- /dev/null
+++ b/src/dbus/dbusmenu/com.canonical.dbusmenu.xml
@@ -0,0 +1,68 @@
+<node>
+	<interface name="com.canonical.dbusmenu">
+		<property name="Version" type="u" access="read"/>
+		<property name="TextDirection" type="s" access="read"/>
+		<property name="Status" type="s" access="read"/>
+		<property name="IconThemePath" type="as" access="read"/>
+
+		<method name="GetLayout">
+			<arg type="i" name="parentId" direction="in"/>
+			<arg type="i" name="recursionDepth" direction="in"/>
+			<arg type="as" name="propertyNames" direction="in"/>
+			<arg type="u" name="revision" direction="out"/>
+			<arg type="(ia{sv}av)" name="layout" direction="out"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.Out1" value="DBusMenuLayout"/>
+		</method>
+		<method name="GetGroupProperties">
+			<arg type="ai" name="ids" direction="in"/>
+			<arg type="as" name="propertyNames" direction="in"/>
+			<arg type="a(ia{sv})" name="properties" direction="out"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="DBusMenuIdList"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="DBusMenuItemPropertiesList"/>
+		</method>
+		<method name="GetProperty">
+			<arg type="i" name="id" direction="in"/>
+			<arg type="s" name="name" direction="in"/>
+			<arg type="v" name="value" direction="out"/>
+		</method>
+		<method name="Event">
+			<arg type="i" name="id" direction="in"/>
+			<arg type="s" name="eventId" direction="in"/>
+			<arg type="v" name="data" direction="in"/>
+			<arg type="u" name="timestamp" direction="in"/>
+		</method>
+		<!--<method name="EventGroup">
+			<arg type="a(isvu)" name="events" direction="in"/>
+			<arg type="ai" name="idErrors" direction="out"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="DBusMenuEventList"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="DBusMenuIdList"/>
+		</method>-->
+		<method name="AboutToShow">
+			<arg type="i" name="id" direction="in"/>
+			<arg type="b" name="needUpdate" direction="out"/>
+		</method>
+		<method name="AboutToShowGroup">
+			<arg type="ai" name="ids" direction="in"/>
+			<arg type="ai" name="updatesNeeded" direction="out"/>
+			<arg type="ai" name="idErrors" direction="out"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="DBusMenuIdList"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="DBusMenuIdList"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.Out1" value="DBusMenuIdList"/>
+		</method>
+
+		<signal name="ItemsPropertiesUpdated">
+			<arg type="a(ia{sv})" name="updatedProps" direction="out"/>
+			<arg type="a(ias)" name="removedProps" direction="out"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="DBusMenuItemPropertiesList"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.Out1" value="DBusMenuItemPropertyNamesList"/>
+		</signal>
+		<signal name="LayoutUpdated">
+			<arg type="u" name="revision" direction="out"/>
+			<arg type="i" name="parent" direction="out"/>
+		</signal>
+		<signal name="ItemActivationRequested">
+			<arg type="i" name="id" direction="out"/>
+			<arg type="u" name="timestamp" direction="out"/>
+		</signal>
+	</interface>
+</node>
diff --git a/src/dbus/dbusmenu/dbus_menu_types.cpp b/src/dbus/dbusmenu/dbus_menu_types.cpp
new file mode 100644
index 00000000..36ae41fe
--- /dev/null
+++ b/src/dbus/dbusmenu/dbus_menu_types.cpp
@@ -0,0 +1,92 @@
+#include "dbus_menu_types.hpp"
+
+#include <qdbusargument.h>
+#include <qdbusextratypes.h>
+#include <qdebug.h>
+#include <qmetatype.h>
+#include <qvariant.h>
+
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusMenuLayout& layout) {
+	layout.children.clear();
+
+	argument.beginStructure();
+	argument >> layout.id;
+	argument >> layout.properties;
+
+	argument.beginArray();
+	while (!argument.atEnd()) {
+		auto childArgument = qdbus_cast<QDBusVariant>(argument).variant().value<QDBusArgument>();
+		auto child = qdbus_cast<DBusMenuLayout>(childArgument);
+		layout.children.append(child);
+	}
+	argument.endArray();
+
+	argument.endStructure();
+	return argument;
+}
+
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusMenuLayout& layout) {
+	argument.beginStructure();
+	argument << layout.id;
+	argument << layout.properties;
+
+	argument.beginArray(qMetaTypeId<QDBusVariant>());
+	for (const auto& child: layout.children) {
+		argument << QDBusVariant(QVariant::fromValue(child));
+	}
+	argument.endArray();
+
+	argument.endStructure();
+	return argument;
+}
+
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusMenuItemProperties& item) {
+	argument.beginStructure();
+	argument >> item.id;
+	argument >> item.properties;
+	argument.endStructure();
+	return argument;
+}
+
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusMenuItemProperties& item) {
+	argument.beginStructure();
+	argument << item.id;
+	argument << item.properties;
+	argument.endStructure();
+	return argument;
+}
+
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusMenuItemPropertyNames& names) {
+	argument.beginStructure();
+	argument >> names.id;
+	argument >> names.properties;
+	argument.endStructure();
+	return argument;
+}
+
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusMenuItemPropertyNames& names) {
+	argument.beginStructure();
+	argument << names.id;
+	argument << names.properties;
+	argument.endStructure();
+	return argument;
+}
+
+QDebug operator<<(QDebug debug, const DBusMenuLayout& layout) {
+	debug.nospace() << "DBusMenuLayout(id=" << layout.id << ", properties=" << layout.properties
+	                << ", children=" << layout.children << ")";
+
+	return debug;
+}
+
+QDebug operator<<(QDebug debug, const DBusMenuItemProperties& item) {
+	debug.nospace() << "DBusMenuItemProperties(id=" << item.id << ", properties=" << item.properties
+	                << ")";
+	return debug;
+}
+
+QDebug operator<<(QDebug debug, const DBusMenuItemPropertyNames& names) {
+	debug.nospace() << "DBusMenuItemPropertyNames(id=" << names.id
+	                << ", properties=" << names.properties << ")";
+	return debug;
+}
diff --git a/src/dbus/dbusmenu/dbus_menu_types.hpp b/src/dbus/dbusmenu/dbus_menu_types.hpp
new file mode 100644
index 00000000..29659497
--- /dev/null
+++ b/src/dbus/dbusmenu/dbus_menu_types.hpp
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qdbusargument.h>
+#include <qdebug.h>
+#include <qlist.h>
+#include <qtypes.h>
+
+struct DBusMenuLayout {
+	qint32 id = 0;
+	QVariantMap properties;
+	QList<DBusMenuLayout> children;
+};
+
+using DBusMenuIdList = QList<qint32>;
+
+struct DBusMenuItemProperties {
+	qint32 id = 0;
+	QVariantMap properties;
+};
+
+using DBusMenuItemPropertiesList = QList<DBusMenuItemProperties>;
+
+struct DBusMenuItemPropertyNames {
+	qint32 id = 0;
+	QStringList properties;
+};
+
+using DBusMenuItemPropertyNamesList = QList<DBusMenuItemPropertyNames>;
+
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusMenuLayout& layout);
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusMenuLayout& layout);
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusMenuItemProperties& item);
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusMenuItemProperties& item);
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusMenuItemPropertyNames& names);
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusMenuItemPropertyNames& names);
+
+QDebug operator<<(QDebug debug, const DBusMenuLayout& layout);
+QDebug operator<<(QDebug debug, const DBusMenuItemProperties& item);
+QDebug operator<<(QDebug debug, const DBusMenuItemPropertyNames& names);
+
+Q_DECLARE_METATYPE(DBusMenuLayout);
+Q_DECLARE_METATYPE(DBusMenuIdList);
+Q_DECLARE_METATYPE(DBusMenuItemProperties);
+Q_DECLARE_METATYPE(DBusMenuItemPropertiesList);
+Q_DECLARE_METATYPE(DBusMenuItemPropertyNames);
+Q_DECLARE_METATYPE(DBusMenuItemPropertyNamesList);
diff --git a/src/dbus/dbusmenu/dbusmenu.cpp b/src/dbus/dbusmenu/dbusmenu.cpp
new file mode 100644
index 00000000..186b1330
--- /dev/null
+++ b/src/dbus/dbusmenu/dbusmenu.cpp
@@ -0,0 +1,573 @@
+#include "dbusmenu.hpp"
+#include <algorithm>
+
+#include <qbytearray.h>
+#include <qcontainerfwd.h>
+#include <qdatetime.h>
+#include <qdbusconnection.h>
+#include <qdbusextratypes.h>
+#include <qdbusmetatype.h>
+#include <qdbuspendingcall.h>
+#include <qdbuspendingreply.h>
+#include <qdebug.h>
+#include <qimage.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+#include "../../core/iconimageprovider.hpp"
+#include "../../core/logcat.hpp"
+#include "../../core/model.hpp"
+#include "../../core/qsmenu.hpp"
+#include "../../dbus/properties.hpp"
+#include "dbus_menu.h"
+#include "dbus_menu_types.hpp"
+
+QS_LOGGING_CATEGORY(logDbusMenu, "quickshell.dbus.dbusmenu", QtWarningMsg);
+
+using namespace qs::menu;
+
+namespace qs::dbus::dbusmenu {
+
+DBusMenuItem::DBusMenuItem(qint32 id, DBusMenu* menu, DBusMenuItem* parentMenu)
+    : QsMenuEntry(menu)
+    , id(id)
+    , menu(menu)
+    , parentMenu(parentMenu) {
+	QObject::connect(this, &QsMenuEntry::opened, this, &DBusMenuItem::sendOpened);
+	QObject::connect(this, &QsMenuEntry::closed, this, &DBusMenuItem::sendClosed);
+	QObject::connect(this, &QsMenuEntry::triggered, this, &DBusMenuItem::sendTriggered);
+
+	QObject::connect(this->menu, &DBusMenu::iconThemePathChanged, this, &DBusMenuItem::iconChanged);
+}
+
+void DBusMenuItem::sendOpened() const { this->menu->sendEvent(this->id, "opened"); }
+void DBusMenuItem::sendClosed() const { this->menu->sendEvent(this->id, "closed"); }
+void DBusMenuItem::sendTriggered() const { this->menu->sendEvent(this->id, "clicked"); }
+
+DBusMenu* DBusMenuItem::menuHandle() const { return this->menu; }
+bool DBusMenuItem::enabled() const { return this->mEnabled; }
+QString DBusMenuItem::text() const { return this->mCleanLabel; }
+
+QString DBusMenuItem::icon() const {
+	if (!this->iconName.isEmpty()) {
+		return IconImageProvider::requestString(
+		    this->iconName,
+		    this->menu->iconThemePath.value().join(':')
+		);
+	} else if (this->image.hasData()) {
+		return this->image.url();
+	} else return nullptr;
+}
+
+QsMenuButtonType::Enum DBusMenuItem::buttonType() const { return this->mButtonType; };
+Qt::CheckState DBusMenuItem::checkState() const { return this->mCheckState; }
+bool DBusMenuItem::isSeparator() const { return this->mSeparator; }
+
+bool DBusMenuItem::isShowingChildren() const { return this->mShowChildren && this->childrenLoaded; }
+
+void DBusMenuItem::setShowChildrenRecursive(bool showChildren) {
+	if (showChildren == this->mShowChildren) return;
+	this->mShowChildren = showChildren;
+	this->childrenLoaded = false;
+
+	if (showChildren) {
+		this->menu->prepareToShow(this->id, -1);
+	} else {
+		if (!this->mChildren.isEmpty()) {
+			for (auto child: this->mChildren) {
+				this->menu->removeRecursive(child);
+			}
+
+			this->mChildren.clear();
+			this->onChildrenUpdated();
+		}
+	}
+}
+
+void DBusMenuItem::updateLayout() const {
+	if (!this->isShowingChildren()) return;
+	this->menu->updateLayout(this->id, -1);
+}
+
+bool DBusMenuItem::hasChildren() const { return this->displayChildren || this->id == 0; }
+
+ObjectModel<QsMenuEntry>* DBusMenuItem::children() {
+	return reinterpret_cast<ObjectModel<QsMenuEntry>*>(&this->enabledChildren);
+}
+
+void DBusMenuItem::updateProperties(const QVariantMap& properties, const QStringList& removed) {
+	// Some programs appear to think sending an empty map does not mean "reset everything"
+	// and instead means "do nothing". oh well...
+	if (properties.isEmpty() && removed.isEmpty()) {
+		qCDebug(logDbusMenu) << "Ignoring empty property update for" << this;
+		return;
+	}
+
+	auto originalText = this->mText;
+	//auto originalMnemonic = this->mnemonic;
+	auto originalEnabled = this->mEnabled;
+	auto originalVisible = this->visible;
+	auto originalIconName = this->iconName;
+	auto imageChanged = false;
+	auto originalIsSeparator = this->mSeparator;
+	auto originalButtonType = this->mButtonType;
+	auto originalToggleState = this->mCheckState;
+	auto originalDisplayChildren = this->displayChildren;
+
+	auto label = properties.value("label");
+	if (label.canConvert<QString>()) {
+		auto text = label.value<QString>();
+		this->mText = text;
+		this->mCleanLabel = text;
+		//this->mnemonic = QChar();
+
+		for (auto i = 0; i < this->mText.length() - 1;) {
+			if (this->mText.at(i) == '_') {
+				//if (this->mnemonic == QChar()) this->mnemonic = this->mLabel.at(i + 1);
+				this->mText.remove(i, 1);
+				this->mText.insert(i + 1, "</u>");
+				this->mText.insert(i, "<u>");
+				i += 8;
+			} else {
+				i++;
+			}
+		}
+
+		for (auto i = 0; i < this->mCleanLabel.length() - 1; i++) {
+			if (this->mCleanLabel.at(i) == '_') {
+				this->mCleanLabel.remove(i, 1);
+			}
+		}
+	} else if (removed.isEmpty() || removed.contains("label")) {
+		this->mText = "";
+		//this->mnemonic = QChar();
+	}
+
+	auto enabled = properties.value("enabled");
+	if (enabled.canConvert<bool>()) {
+		this->mEnabled = enabled.value<bool>();
+	} else if (removed.isEmpty() || removed.contains("enabled")) {
+		this->mEnabled = true;
+	}
+
+	auto visible = properties.value("visible");
+	if (visible.canConvert<bool>()) {
+		this->visible = visible.value<bool>();
+	} else if (removed.isEmpty() || removed.contains("visible")) {
+		this->visible = true;
+	}
+
+	auto iconName = properties.value("icon-name");
+	if (iconName.canConvert<QString>()) {
+		this->iconName = iconName.value<QString>();
+	} else if (removed.isEmpty() || removed.contains("icon-name")) {
+		this->iconName = "";
+	}
+
+	auto iconData = properties.value("icon-data");
+	if (iconData.canConvert<QByteArray>()) {
+		auto data = iconData.value<QByteArray>();
+		if (data.isEmpty()) {
+			imageChanged = this->image.hasData();
+			this->image.data.clear();
+		} else if (!this->image.hasData() || this->image.data != data) {
+			imageChanged = true;
+			this->image.data = data;
+			this->image.imageChanged();
+		}
+	} else if (removed.isEmpty() || removed.contains("icon-data")) {
+		imageChanged = this->image.hasData();
+		image.data.clear();
+	}
+
+	auto type = properties.value("type");
+	if (type.canConvert<QString>()) {
+		this->mSeparator = type.value<QString>() == "separator";
+	} else if (removed.isEmpty() || removed.contains("type")) {
+		this->mSeparator = false;
+	}
+
+	auto toggleType = properties.value("toggle-type");
+	if (toggleType.canConvert<QString>()) {
+		auto toggleTypeStr = toggleType.value<QString>();
+
+		if (toggleTypeStr == "") this->mButtonType = QsMenuButtonType::None;
+		else if (toggleTypeStr == "checkmark") this->mButtonType = QsMenuButtonType::CheckBox;
+		else if (toggleTypeStr == "radio") this->mButtonType = QsMenuButtonType::RadioButton;
+		else {
+			qCWarning(logDbusMenu) << "Unrecognized toggle type" << toggleTypeStr << "for" << this;
+			this->mButtonType = QsMenuButtonType::None;
+		}
+	} else if (removed.isEmpty() || removed.contains("toggle-type")) {
+		this->mButtonType = QsMenuButtonType::None;
+	}
+
+	auto toggleState = properties.value("toggle-state");
+	if (toggleState.canConvert<qint32>()) {
+		auto toggleStateInt = toggleState.value<qint32>();
+
+		if (toggleStateInt == 0) this->mCheckState = Qt::Unchecked;
+		else if (toggleStateInt == 1) this->mCheckState = Qt::Checked;
+		else this->mCheckState = Qt::PartiallyChecked;
+	} else if (removed.isEmpty() || removed.contains("toggle-state")) {
+		this->mCheckState = Qt::Unchecked;
+	}
+
+	auto childrenDisplay = properties.value("children-display");
+	if (childrenDisplay.canConvert<QString>()) {
+		auto childrenDisplayStr = childrenDisplay.value<QString>();
+
+		if (childrenDisplayStr == "") this->displayChildren = false;
+		else if (childrenDisplayStr == "submenu") this->displayChildren = true;
+		else {
+			qCWarning(logDbusMenu) << "Unrecognized children-display mode" << childrenDisplayStr << "for"
+			                       << this;
+			this->displayChildren = false;
+		}
+	} else if (removed.isEmpty() || removed.contains("children-display")) {
+		this->displayChildren = false;
+	}
+
+	if (this->mText != originalText) emit this->textChanged();
+	//if (this->mnemonic != originalMnemonic) emit this->labelChanged();
+	if (this->mEnabled != originalEnabled) emit this->enabledChanged();
+	if (this->visible != originalVisible && this->parentMenu != nullptr)
+		this->parentMenu->onChildrenUpdated();
+	if (this->mButtonType != originalButtonType) emit this->buttonTypeChanged();
+	if (this->mCheckState != originalToggleState) emit this->checkStateChanged();
+	if (this->mSeparator != originalIsSeparator) emit this->isSeparatorChanged();
+	if (this->displayChildren != originalDisplayChildren) emit this->hasChildrenChanged();
+
+	if (this->iconName != originalIconName || imageChanged) {
+		emit this->iconChanged();
+	}
+
+	qCDebug(logDbusMenu).nospace() << "Updated properties of " << this << " { label=" << this->mText
+	                               << ", enabled=" << this->mEnabled << ", visible=" << this->visible
+	                               << ", iconName=" << this->iconName << ", iconData=" << &this->image
+	                               << ", separator=" << this->mSeparator
+	                               << ", toggleType=" << this->mButtonType
+	                               << ", toggleState=" << this->mCheckState
+	                               << ", displayChildren=" << this->displayChildren << " }";
+}
+
+void DBusMenuItem::onChildrenUpdated() {
+	QVector<DBusMenuItem*> children;
+	for (auto child: this->mChildren) {
+		auto* item = this->menu->items.value(child);
+		if (item->visible) children.append(item);
+	}
+
+	this->enabledChildren.diffUpdate(children);
+}
+
+QDebug operator<<(QDebug debug, DBusMenuItem* item) {
+	if (item == nullptr) {
+		debug << "DBusMenuItem(nullptr)";
+		return debug;
+	}
+
+	auto saver = QDebugStateSaver(debug);
+	debug.nospace() << "DBusMenuItem(" << static_cast<void*>(item) << ", id=" << item->id
+	                << ", label=" << item->mText << ", menu=" << item->menu << ")";
+	return debug;
+}
+
+DBusMenu::DBusMenu(const QString& service, const QString& path, QObject* parent): QObject(parent) {
+	qDBusRegisterMetaType<DBusMenuLayout>();
+	qDBusRegisterMetaType<DBusMenuIdList>();
+	qDBusRegisterMetaType<DBusMenuItemProperties>();
+	qDBusRegisterMetaType<DBusMenuItemPropertiesList>();
+	qDBusRegisterMetaType<DBusMenuItemPropertyNames>();
+	qDBusRegisterMetaType<DBusMenuItemPropertyNamesList>();
+
+	this->interface = new DBusMenuInterface(service, path, QDBusConnection::sessionBus(), this);
+
+	if (!this->interface->isValid()) {
+		qCWarning(logDbusMenu).noquote() << "Cannot create DBusMenu for" << service << "at" << path;
+		return;
+	}
+
+	QObject::connect(
+	    this->interface,
+	    &DBusMenuInterface::LayoutUpdated,
+	    this,
+	    &DBusMenu::onLayoutUpdated
+	);
+
+	this->properties.setInterface(this->interface);
+	this->properties.updateAllViaGetAll();
+}
+
+void DBusMenu::prepareToShow(qint32 item, qint32 depth) {
+	auto pending = this->interface->AboutToShow(item);
+	auto* call = new QDBusPendingCallWatcher(pending, this);
+
+	auto responseCallback = [this, item, depth](QDBusPendingCallWatcher* call) {
+		const QDBusPendingReply<bool> reply = *call;
+		if (reply.isError()) {
+			qCDebug(logDbusMenu) << "Error in AboutToShow, but showing anyway for menu" << item << "of"
+			                     << this << reply.error();
+		}
+
+		this->updateLayout(item, depth);
+
+		delete call;
+	};
+
+	QObject::connect(call, &QDBusPendingCallWatcher::finished, this, responseCallback);
+}
+
+void DBusMenu::updateLayout(qint32 parent, qint32 depth) {
+	auto pending = this->interface->GetLayout(parent, depth, QStringList());
+	auto* call = new QDBusPendingCallWatcher(pending, this);
+
+	auto responseCallback = [this, parent, depth](QDBusPendingCallWatcher* call) {
+		const QDBusPendingReply<uint, DBusMenuLayout> reply = *call;
+
+		if (reply.isError()) {
+			qCWarning(logDbusMenu) << "Error updating layout for menu" << parent << "of" << this
+			                       << reply.error();
+		} else {
+			auto layout = reply.argumentAt<1>();
+			this->updateLayoutRecursive(layout, this->items.value(parent), depth);
+		}
+
+		delete call;
+	};
+
+	QObject::connect(call, &QDBusPendingCallWatcher::finished, this, responseCallback);
+}
+
+void DBusMenu::updateLayoutRecursive(
+    const DBusMenuLayout& layout,
+    DBusMenuItem* parent,
+    qint32 depth
+) {
+	auto* item = this->items.value(layout.id);
+	if (item == nullptr) {
+		// there is an actual nullptr in the map and not no entry
+		if (this->items.contains(layout.id)) {
+			item = new DBusMenuItem(layout.id, this, parent);
+			item->mShowChildren = parent != nullptr && parent->mShowChildren;
+			this->items.insert(layout.id, item);
+		}
+	}
+
+	if (item == nullptr) return;
+
+	qCDebug(logDbusMenu) << "Updating layout recursively for" << this << "menu" << layout.id;
+	item->updateProperties(layout.properties);
+
+	if (depth != 0) {
+		auto childrenChanged = false;
+		auto iter = item->mChildren.begin();
+		while (iter != item->mChildren.end()) {
+			auto existing = std::ranges::find_if(layout.children, [&](const DBusMenuLayout& layout) {
+				return layout.id == *iter;
+			});
+
+			if (!item->mShowChildren || existing == layout.children.end()) {
+				qCDebug(logDbusMenu) << "Removing missing layout item" << this->items.value(*iter) << "from"
+				                     << item;
+				this->removeRecursive(*iter);
+				iter = item->mChildren.erase(iter);
+				childrenChanged = true;
+			} else {
+				iter++;
+			}
+		}
+
+		for (const auto& child: layout.children) {
+			if (item->mShowChildren && !item->mChildren.contains(child.id)) {
+				qCDebug(logDbusMenu) << "Creating new layout item" << child.id << "in" << item;
+				// item->mChildren.push_back(child.id);
+				this->items.insert(child.id, nullptr);
+				childrenChanged = true;
+			}
+
+			this->updateLayoutRecursive(child, item, depth - 1);
+		}
+
+		if (childrenChanged) {
+			// reset to preserve order
+			item->mChildren.clear();
+			for (const auto& child: layout.children) {
+				item->mChildren.push_back(child.id);
+			}
+
+			item->onChildrenUpdated();
+		}
+	}
+
+	if (item->mShowChildren && !item->childrenLoaded) {
+		item->childrenLoaded = true;
+	}
+
+	emit item->layoutUpdated();
+}
+
+void DBusMenu::removeRecursive(qint32 id) {
+	auto* item = this->items.value(id);
+
+	if (item != nullptr) {
+		for (auto child: item->mChildren) {
+			this->removeRecursive(child);
+		}
+	}
+
+	this->items.remove(id);
+
+	if (item != nullptr) {
+		item->deleteLater();
+	}
+}
+
+void DBusMenu::sendEvent(qint32 item, const QString& event) {
+	qCDebug(logDbusMenu) << "Sending event" << event << "to menu" << item << "of" << this;
+
+	auto pending =
+	    this->interface->Event(item, event, QDBusVariant(0), QDateTime::currentSecsSinceEpoch());
+	auto* call = new QDBusPendingCallWatcher(pending, this);
+
+	auto responseCallback = [this, item, event](QDBusPendingCallWatcher* call) {
+		const QDBusPendingReply<> reply = *call;
+
+		if (reply.isError()) {
+			qCWarning(logDbusMenu) << "Error sending event" << event << "to" << item << "of" << this
+			                       << reply.error();
+		}
+
+		delete call;
+	};
+
+	QObject::connect(call, &QDBusPendingCallWatcher::finished, this, responseCallback);
+}
+
+DBusMenuItem* DBusMenu::menu() { return &this->rootItem; }
+
+void DBusMenu::onLayoutUpdated(quint32 /*unused*/, qint32 parent) {
+	// note: spec says this is recursive
+	this->updateLayout(parent, -1);
+}
+
+void DBusMenu::onItemPropertiesUpdated( // NOLINT
+    const DBusMenuItemPropertiesList& updatedProps,
+    const DBusMenuItemPropertyNamesList& removedProps
+) {
+	for (const auto& propset: updatedProps) {
+		auto* item = this->items.value(propset.id);
+		if (item != nullptr) {
+			item->updateProperties(propset.properties);
+		}
+	}
+
+	for (const auto& propset: removedProps) {
+		auto* item = this->items.value(propset.id);
+		if (item != nullptr) {
+			item->updateProperties({}, propset.properties);
+		}
+	}
+}
+
+QDebug operator<<(QDebug debug, DBusMenu* menu) {
+	if (menu == nullptr) {
+		debug << "DBusMenu(nullptr)";
+		return debug;
+	}
+
+	auto saver = QDebugStateSaver(debug);
+	debug.nospace() << "DBusMenu(" << static_cast<void*>(menu) << ", " << menu->properties.toString()
+	                << ")";
+	return debug;
+}
+
+QImage
+DBusMenuPngImage::requestImage(const QString& /*unused*/, QSize* size, const QSize& /*unused*/) {
+	auto image = QImage();
+
+	if (!image.loadFromData(this->data, "PNG")) {
+		qCWarning(logDbusMenu) << "Failed to load dbusmenu item png";
+	}
+
+	if (size != nullptr) *size = image.size();
+	return image;
+}
+
+void DBusMenuHandle::setAddress(const QString& service, const QString& path) {
+	if (service == this->service && path == this->path) return;
+	this->service = service;
+	this->path = path;
+	this->onMenuPathChanged();
+}
+
+void DBusMenuHandle::refHandle() {
+	this->refcount++;
+	qCDebug(logDbusMenu) << this << "gained a reference. Refcount is now" << this->refcount;
+
+	if (this->refcount == 1 || !this->mMenu) {
+		this->onMenuPathChanged();
+	} else {
+		// Refresh the layout when opening a menu in case a bad client isn't updating it
+		// and another ref is open somewhere.
+		this->mMenu->rootItem.updateLayout();
+	}
+}
+
+void DBusMenuHandle::unrefHandle() {
+	this->refcount--;
+	qCDebug(logDbusMenu) << this << "lost a reference. Refcount is now" << this->refcount;
+
+	if (this->refcount == 0) {
+		this->onMenuPathChanged();
+	}
+}
+
+void DBusMenuHandle::onMenuPathChanged() {
+	qCDebug(logDbusMenu) << "Updating" << this << "with refcount" << this->refcount;
+
+	if (this->mMenu) {
+		// Without this, layout updated can be sent after mMenu is set to null,
+		// leaving loaded = true while mMenu = nullptr.
+		QObject::disconnect(&this->mMenu->rootItem, nullptr, this, nullptr);
+		this->mMenu->deleteLater();
+		this->mMenu = nullptr;
+		this->loaded = false;
+		emit this->menuChanged();
+	}
+
+	if (this->refcount > 0 && !this->service.isEmpty() && !this->path.isEmpty()) {
+		this->mMenu = new DBusMenu(this->service, this->path);
+		this->mMenu->setParent(this);
+
+		QObject::connect(&this->mMenu->rootItem, &DBusMenuItem::layoutUpdated, this, [this]() {
+			QObject::disconnect(&this->mMenu->rootItem, &DBusMenuItem::layoutUpdated, this, nullptr);
+			this->loaded = true;
+			emit this->menuChanged();
+		});
+
+		this->mMenu->rootItem.setShowChildrenRecursive(true);
+	}
+}
+
+QsMenuEntry* DBusMenuHandle::menu() { return this->loaded ? &this->mMenu->rootItem : nullptr; }
+
+QDebug operator<<(QDebug debug, const DBusMenuHandle* handle) {
+	if (handle) {
+		auto saver = QDebugStateSaver(debug);
+		debug.nospace() << "DBusMenuHandle(" << static_cast<const void*>(handle)
+		                << ", service=" << handle->service << ", path=" << handle->path << ')';
+	} else {
+		debug << "DBusMenuHandle(nullptr)";
+	}
+
+	return debug;
+}
+
+} // namespace qs::dbus::dbusmenu
diff --git a/src/dbus/dbusmenu/dbusmenu.hpp b/src/dbus/dbusmenu/dbusmenu.hpp
new file mode 100644
index 00000000..1192baaa
--- /dev/null
+++ b/src/dbus/dbusmenu/dbusmenu.hpp
@@ -0,0 +1,196 @@
+#pragma once
+
+#include <qbytearray.h>
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qhash.h>
+#include <qloggingcategory.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qqmllist.h>
+#include <qquickimageprovider.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/doc.hpp"
+#include "../../core/imageprovider.hpp"
+#include "../../core/model.hpp"
+#include "../../core/qsmenu.hpp"
+#include "../properties.hpp"
+#include "dbus_menu_types.hpp"
+
+QS_DECLARE_LOGGING_CATEGORY(logDbusMenu);
+
+class DBusMenuInterface;
+
+namespace qs::dbus::dbusmenu {
+
+// hack because docgen can't take namespaces in superclasses
+using menu::QsMenuEntry;
+
+class DBusMenu;
+class DBusMenuItem;
+
+class DBusMenuPngImage: public QsIndexedImageHandle {
+public:
+	explicit DBusMenuPngImage(): QsIndexedImageHandle(QQuickImageProvider::Image) {}
+
+	[[nodiscard]] bool hasData() const { return !data.isEmpty(); }
+	QImage requestImage(const QString& id, QSize* size, const QSize& requestedSize) override;
+
+	QByteArray data;
+};
+
+///! Menu item shared by an external program.
+/// Menu item shared by an external program via the
+/// [DBusMenu specification](https://github.com/AyatanaIndicators/libdbusmenu/blob/master/libdbusmenu-glib/dbus-menu.xml).
+class DBusMenuItem: public QsMenuEntry {
+	Q_OBJECT;
+	/// Handle to the root of this menu.
+	Q_PROPERTY(qs::dbus::dbusmenu::DBusMenu* menuHandle READ menuHandle CONSTANT);
+	QML_ELEMENT;
+	QML_UNCREATABLE("DBusMenus can only be acquired from a DBusMenuHandle");
+
+public:
+	explicit DBusMenuItem(qint32 id, DBusMenu* menu, DBusMenuItem* parentMenu);
+
+	/// Refreshes the menu contents.
+	///
+	/// Usually you shouldn't need to call this manually but some applications providing
+	/// menus do not update them correctly. Call this if menus don't update their state.
+	///
+	/// The @@layoutUpdated(s) signal will be sent when a response is received.
+	Q_INVOKABLE void updateLayout() const;
+
+	[[nodiscard]] DBusMenu* menuHandle() const;
+
+	[[nodiscard]] bool isSeparator() const override;
+	[[nodiscard]] bool enabled() const override;
+	[[nodiscard]] QString text() const override;
+	[[nodiscard]] QString icon() const override;
+	[[nodiscard]] menu::QsMenuButtonType::Enum buttonType() const override;
+	[[nodiscard]] Qt::CheckState checkState() const override;
+	[[nodiscard]] bool hasChildren() const override;
+
+	[[nodiscard]] bool isShowingChildren() const;
+	void setShowChildrenRecursive(bool showChildren);
+
+	[[nodiscard]] ObjectModel<QsMenuEntry>* children() override;
+
+	void updateProperties(const QVariantMap& properties, const QStringList& removed = {});
+	void onChildrenUpdated();
+
+	qint32 id = 0;
+	QString mText;
+	QVector<qint32> mChildren;
+	bool mShowChildren = false;
+	bool childrenLoaded = false;
+	DBusMenu* menu = nullptr;
+
+signals:
+	void layoutUpdated();
+
+private slots:
+	void sendOpened() const;
+	void sendClosed() const;
+	void sendTriggered() const;
+
+private:
+	QString mCleanLabel;
+	//QChar mnemonic;
+	bool mEnabled = true;
+	bool visible = true;
+	bool mSeparator = false;
+	QString iconName;
+	DBusMenuPngImage image;
+	menu::QsMenuButtonType::Enum mButtonType = menu::QsMenuButtonType::None;
+	Qt::CheckState mCheckState = Qt::Unchecked;
+	bool displayChildren = false;
+	ObjectModel<DBusMenuItem> enabledChildren {this};
+	DBusMenuItem* parentMenu = nullptr;
+};
+
+QDebug operator<<(QDebug debug, DBusMenuItem* item);
+
+///! Handle to a DBusMenu tree.
+/// Handle to a menu tree provided by a remote process.
+class DBusMenu: public QObject {
+	Q_OBJECT;
+	Q_PROPERTY(qs::dbus::dbusmenu::DBusMenuItem* menu READ menu CONSTANT);
+	QML_NAMED_ELEMENT(DBusMenuHandle);
+	QML_UNCREATABLE("Menu handles cannot be directly created");
+
+public:
+	explicit DBusMenu(const QString& service, const QString& path, QObject* parent = nullptr);
+
+	QS_DBUS_BINDABLE_PROPERTY_GROUP(DBusMenu, properties);
+
+signals:
+	QSDOC_HIDE void iconThemePathChanged();
+
+public:
+	Q_OBJECT_BINDABLE_PROPERTY(DBusMenu, QStringList, iconThemePath, &DBusMenu::iconThemePathChanged);
+
+	void prepareToShow(qint32 item, qint32 depth);
+	void updateLayout(qint32 parent, qint32 depth);
+	void removeRecursive(qint32 id);
+	void sendEvent(qint32 item, const QString& event);
+
+	DBusMenuItem rootItem {0, this, nullptr};
+	QHash<qint32, DBusMenuItem*> items {std::make_pair(0, &this->rootItem)};
+
+	[[nodiscard]] DBusMenuItem* menu();
+
+private slots:
+	void onLayoutUpdated(quint32 revision, qint32 parent);
+	void onItemPropertiesUpdated(
+	    const DBusMenuItemPropertiesList& updatedProps,
+	    const DBusMenuItemPropertyNamesList& removedProps
+	);
+
+private:
+	void updateLayoutRecursive(const DBusMenuLayout& layout, DBusMenuItem* parent, qint32 depth);
+
+	QS_DBUS_PROPERTY_BINDING(
+	    DBusMenu,
+	    pIconThemePath,
+	    iconThemePath,
+	    properties,
+	    "IconThemePath",
+	    false
+	);
+
+	DBusMenuInterface* interface = nullptr;
+};
+
+QDebug operator<<(QDebug debug, DBusMenu* menu);
+
+class DBusMenuHandle;
+
+QDebug operator<<(QDebug debug, const DBusMenuHandle* handle);
+
+class DBusMenuHandle: public menu::QsMenuHandle {
+public:
+	explicit DBusMenuHandle(QObject* parent): menu::QsMenuHandle(parent) {}
+
+	void setAddress(const QString& service, const QString& path);
+
+	void refHandle() override;
+	void unrefHandle() override;
+
+	[[nodiscard]] QsMenuEntry* menu() override;
+
+private:
+	void onMenuPathChanged();
+
+	QString service;
+	QString path;
+	DBusMenu* mMenu = nullptr;
+	bool loaded = false;
+	quint32 refcount = 0;
+
+	friend QDebug operator<<(QDebug debug, const DBusMenuHandle* handle);
+};
+
+} // namespace qs::dbus::dbusmenu
diff --git a/src/dbus/dbusmenu/module.md b/src/dbus/dbusmenu/module.md
new file mode 100644
index 00000000..810393e4
--- /dev/null
+++ b/src/dbus/dbusmenu/module.md
@@ -0,0 +1,4 @@
+name = "Quickshell.DBusMenu"
+description = "Types related to DBusMenu (used in system tray)"
+headers = [ "dbusmenu.hpp" ]
+-----
diff --git a/src/dbus/objectmanager.cpp b/src/dbus/objectmanager.cpp
new file mode 100644
index 00000000..258f6fe8
--- /dev/null
+++ b/src/dbus/objectmanager.cpp
@@ -0,0 +1,87 @@
+#include "objectmanager.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdbusconnection.h>
+#include <qdbusmetatype.h>
+#include <qdbuspendingcall.h>
+#include <qdbuspendingreply.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qtmetamacros.h>
+
+#include "../core/logcat.hpp"
+#include "dbus_objectmanager.h"
+#include "dbus_objectmanager_types.hpp"
+
+namespace {
+QS_LOGGING_CATEGORY(logDbusObjectManager, "quickshell.dbus.objectmanager", QtWarningMsg);
+}
+
+namespace qs::dbus {
+
+DBusObjectManager::DBusObjectManager(QObject* parent): QObject(parent) {
+	qDBusRegisterMetaType<DBusObjectManagerInterfaces>();
+	qDBusRegisterMetaType<DBusObjectManagerObjects>();
+}
+
+bool DBusObjectManager::setInterface(
+    const QString& service,
+    const QString& path,
+    const QDBusConnection& connection
+) {
+	delete this->mInterface;
+	this->mInterface = new DBusObjectManagerInterface(service, path, connection, this);
+
+	if (!this->mInterface->isValid()) {
+		qCWarning(logDbusObjectManager) << "Failed to create DBusObjectManagerInterface for" << service
+		                                << path << ":" << this->mInterface->lastError();
+		delete this->mInterface;
+		this->mInterface = nullptr;
+		return false;
+	}
+
+	QObject::connect(
+	    this->mInterface,
+	    &DBusObjectManagerInterface::InterfacesAdded,
+	    this,
+	    &DBusObjectManager::interfacesAdded
+	);
+
+	QObject::connect(
+	    this->mInterface,
+	    &DBusObjectManagerInterface::InterfacesRemoved,
+	    this,
+	    &DBusObjectManager::interfacesRemoved
+	);
+
+	this->fetchInitialObjects();
+	return true;
+}
+
+void DBusObjectManager::fetchInitialObjects() {
+	if (!this->mInterface) return;
+
+	auto reply = this->mInterface->GetManagedObjects();
+	auto* watcher = new QDBusPendingCallWatcher(reply, this);
+
+	QObject::connect(
+	    watcher,
+	    &QDBusPendingCallWatcher::finished,
+	    this,
+	    [this](QDBusPendingCallWatcher* watcher) {
+		    const QDBusPendingReply<DBusObjectManagerObjects> reply = *watcher;
+		    watcher->deleteLater();
+
+		    if (reply.isError()) {
+			    qCWarning(logDbusObjectManager) << "Failed to get managed objects:" << reply.error();
+			    return;
+		    }
+
+		    for (const auto& [path, interfaces]: reply.value().asKeyValueRange()) {
+			    emit this->interfacesAdded(path, interfaces);
+		    }
+	    }
+	);
+}
+
+} // namespace qs::dbus
diff --git a/src/dbus/objectmanager.hpp b/src/dbus/objectmanager.hpp
new file mode 100644
index 00000000..4246ea28
--- /dev/null
+++ b/src/dbus/objectmanager.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <qdbusconnection.h>
+#include <qobject.h>
+#include <qstring.h>
+#include <qtmetamacros.h>
+
+#include "dbus_objectmanager_types.hpp"
+
+class DBusObjectManagerInterface;
+
+namespace qs::dbus {
+
+class DBusObjectManager: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit DBusObjectManager(QObject* parent = nullptr);
+
+	bool setInterface(
+	    const QString& service,
+	    const QString& path,
+	    const QDBusConnection& connection = QDBusConnection::sessionBus()
+	);
+
+signals:
+	void
+	interfacesAdded(const QDBusObjectPath& objectPath, const DBusObjectManagerInterfaces& interfaces);
+	void interfacesRemoved(const QDBusObjectPath& objectPath, const QStringList& interfaces);
+
+private:
+	void fetchInitialObjects();
+
+	DBusObjectManagerInterface* mInterface = nullptr;
+};
+
+} // namespace qs::dbus
\ No newline at end of file
diff --git a/src/dbus/org.freedesktop.DBus.ObjectManager.xml b/src/dbus/org.freedesktop.DBus.ObjectManager.xml
new file mode 100644
index 00000000..24749f22
--- /dev/null
+++ b/src/dbus/org.freedesktop.DBus.ObjectManager.xml
@@ -0,0 +1,18 @@
+<node>
+	<interface name="org.freedesktop.DBus.ObjectManager">
+		<method name="GetManagedObjects">
+			<arg name="objects" direction="out" type="a{oa{sa{sv}}}"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="DBusObjectManagerObjects"/>
+		</method>
+
+		<signal name="InterfacesAdded">
+			<arg name="object" type="o"/>
+			<arg name="interfaces" type="a{sa{sv}}"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.Out1" value="DBusObjectManagerInterfaces"/>
+		</signal>
+		<signal name="InterfacesRemoved">
+			<arg name="object" type="o"/>
+			<arg name="interfaces" type="as"/>
+		</signal>
+	</interface>
+</node>
diff --git a/src/dbus/org.freedesktop.DBus.Properties.xml b/src/dbus/org.freedesktop.DBus.Properties.xml
new file mode 100644
index 00000000..021123ab
--- /dev/null
+++ b/src/dbus/org.freedesktop.DBus.Properties.xml
@@ -0,0 +1,26 @@
+<node>
+	<interface name="org.freedesktop.DBus.Properties">
+		<method name="Get">
+			<arg name="interface_name" direction="in" type="s"/>
+			<arg name="property_name" direction="in" type="s"/>
+			<arg name="value" direction="out" type="v"/>
+		</method>
+		<method name="Set">
+			<arg name="interface_name" direction="in" type="s"/>
+			<arg name="property_name" direction="in" type="s"/>
+			<arg name="value" direction="in" type="v"/>
+		</method>
+		<method name="GetAll">
+			<arg name="interface_name" direction="in" type="s"/>
+			<arg name="props" direction="out" type="a{sv}"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.Out0" value="QVariantMap"/>
+		</method>
+
+		<signal name="PropertiesChanged">
+			<arg type="s" name="interface_name"/>
+			<arg type="a{sv}" name="changed_properties"/>
+			<arg type="as" name="invalidated_properties"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.Out1" value="QVariantMap" />
+		</signal>
+	</interface>
+</node>
diff --git a/src/dbus/properties.cpp b/src/dbus/properties.cpp
new file mode 100644
index 00000000..d0f65d99
--- /dev/null
+++ b/src/dbus/properties.cpp
@@ -0,0 +1,342 @@
+#include "properties.hpp"
+#include <algorithm>
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qdbusabstractinterface.h>
+#include <qdbusargument.h>
+#include <qdbuserror.h>
+#include <qdbusextratypes.h>
+#include <qdbusmessage.h>
+#include <qdbusmetatype.h>
+#include <qdbuspendingcall.h>
+#include <qdbuspendingreply.h>
+#include <qdebug.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qmetatype.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qtversionchecks.h>
+#include <qvariant.h>
+
+#include "../core/logcat.hpp"
+#include "dbus_properties.h"
+
+QS_LOGGING_CATEGORY(logDbusProperties, "quickshell.dbus.properties", QtWarningMsg);
+
+namespace qs::dbus {
+
+QDBusError demarshallVariant(const QVariant& variant, const QMetaType& type, void* slot) {
+	const char* expectedSignature = "v";
+
+	if (type.id() != QMetaType::QVariant) {
+		expectedSignature = QDBusMetaType::typeToSignature(type);
+		if (expectedSignature == nullptr) {
+			qFatal() << "failed to demarshall unregistered dbus meta-type" << type << "with" << variant;
+		}
+	}
+
+	if (variant.metaType() == type) {
+		if (type.id() == QMetaType::QVariant) {
+			*reinterpret_cast<QVariant*>(slot) = variant;
+		} else {
+			type.destruct(slot);
+			type.construct(slot, variant.constData());
+		}
+	} else if (variant.metaType() == QMetaType::fromType<QDBusArgument>()) {
+		auto arg = qvariant_cast<QDBusArgument>(variant);
+		auto signature = arg.currentSignature();
+
+		if (signature == expectedSignature) {
+			if (!QDBusMetaType::demarshall(arg, type, slot)) {
+				QString error;
+				QDebug(&error) << "failed to deserialize dbus value" << variant << "into" << type;
+				return QDBusError(QDBusError::InvalidArgs, error);
+			}
+		} else {
+			QString error;
+			QDebug(&error) << "mismatched signature while trying to demarshall" << variant << "into"
+			               << type << "expected" << expectedSignature << "got" << signature;
+			return QDBusError(QDBusError::InvalidArgs, error);
+		}
+	} else {
+		QString error;
+		QDebug(&error) << "failed to deserialize variant" << variant << "into" << type;
+		return QDBusError(QDBusError::InvalidArgs, error);
+	}
+
+	return QDBusError();
+}
+
+void asyncReadPropertyInternal(
+    const QMetaType& type,
+    QDBusAbstractInterface& interface,
+    const QString& property,
+    std::function<void(std::function<QDBusError(void*)>)> callback // NOLINT
+) {
+	if (type.id() != QMetaType::QVariant) {
+		const char* expectedSignature = QDBusMetaType::typeToSignature(type);
+		if (expectedSignature == nullptr) {
+			qFatal() << "qs::dbus::asyncReadPropertyInternal called with unregistered dbus meta-type"
+			         << type;
+		}
+	}
+
+	auto callMessage = QDBusMessage::createMethodCall(
+	    interface.service(),
+	    interface.path(),
+	    "org.freedesktop.DBus.Properties",
+	    "Get"
+	);
+
+	callMessage << interface.interface() << property;
+	auto pendingCall = interface.connection().asyncCall(callMessage);
+
+	auto* call = new QDBusPendingCallWatcher(pendingCall, &interface);
+
+	auto responseCallback = [type, callback](QDBusPendingCallWatcher* call) {
+		QDBusPendingReply<QDBusVariant> reply = *call;
+
+		callback([&](void* slot) {
+			if (reply.isError()) {
+				return reply.error();
+			} else {
+				return demarshallVariant(reply.value().variant(), type, slot);
+			}
+		});
+
+		delete call;
+	};
+
+	QObject::connect(call, &QDBusPendingCallWatcher::finished, &interface, responseCallback);
+}
+
+DBusPropertyGroup::DBusPropertyGroup(QVector<DBusPropertyCore*> properties, QObject* parent)
+    : QObject(parent)
+    , properties(std::move(properties)) {}
+
+void DBusPropertyGroup::setInterface(QDBusAbstractInterface* interface) {
+	if (this->interface != nullptr) {
+		delete this->propertyInterface;
+		this->propertyInterface = nullptr;
+	}
+
+	if (interface != nullptr) {
+		this->interface = interface;
+
+		this->propertyInterface = new DBusPropertiesInterface(
+		    interface->service(),
+		    interface->path(),
+		    interface->connection(),
+		    this
+		);
+
+		QObject::connect(
+		    this->propertyInterface,
+		    &DBusPropertiesInterface::PropertiesChanged,
+		    this,
+		    &DBusPropertyGroup::onPropertiesChanged
+		);
+	}
+}
+
+void DBusPropertyGroup::attachProperty(DBusPropertyCore* property) {
+	this->properties.append(property);
+}
+
+void DBusPropertyGroup::updateAllDirect() {
+	qCDebug(logDbusProperties).noquote()
+	    << "Updating all properties of" << this->toString() << "via individual queries";
+
+	if (this->interface == nullptr) {
+		qFatal() << "Attempted to update properties of disconnected property group";
+	}
+
+	for (auto* property: this->properties) {
+		this->requestPropertyUpdate(property);
+	}
+}
+
+void DBusPropertyGroup::updateAllViaGetAll() {
+	qCDebug(logDbusProperties).noquote()
+	    << "Updating all properties of" << this->toString() << "via GetAll";
+
+	if (this->interface == nullptr) {
+		qFatal() << "Attempted to update properties of disconnected property group";
+	}
+
+	auto pendingCall = this->propertyInterface->GetAll(this->interface->interface());
+	auto* call = new QDBusPendingCallWatcher(pendingCall, this);
+
+	auto responseCallback = [this](QDBusPendingCallWatcher* call) {
+		const QDBusPendingReply<QVariantMap> reply = *call;
+
+		if (reply.isError()) {
+			qCWarning(logDbusProperties).noquote()
+			    << "Error updating properties of" << this->toString() << "via GetAll";
+			qCWarning(logDbusProperties) << reply.error();
+			emit this->getAllFailed(reply.error());
+		} else {
+			qCDebug(logDbusProperties).noquote()
+			    << "Received GetAll property set for" << this->toString();
+			this->updatePropertySet(reply.value(), true);
+			emit this->getAllFinished();
+		}
+
+		delete call;
+	};
+
+	QObject::connect(call, &QDBusPendingCallWatcher::finished, this, responseCallback);
+}
+
+void DBusPropertyGroup::updatePropertySet(const QVariantMap& properties, bool complainMissing) {
+	for (const auto [name, value]: properties.asKeyValueRange()) {
+		auto prop = std::ranges::find_if(this->properties, [&name](DBusPropertyCore* prop) {
+			return prop->nameRef() == name;
+		});
+
+		if (prop == this->properties.end()) {
+			qCDebug(logDbusProperties) << "Ignoring untracked property update" << name << "for"
+			                           << this->toString();
+		} else {
+			this->tryUpdateProperty(*prop, value);
+		}
+	}
+
+	if (complainMissing) {
+		for (const auto* prop: this->properties) {
+			if (prop->isRequired() && !properties.contains(prop->name())) {
+				qCWarning(logDbusProperties)
+				    << prop->nameRef() << "missing from property set for" << this->toString();
+			}
+		}
+	}
+}
+
+void DBusPropertyGroup::tryUpdateProperty(DBusPropertyCore* property, const QVariant& variant)
+    const {
+	property->mExists = true;
+
+	auto error = property->store(variant);
+	if (error.isValid()) {
+		qCWarning(logDbusProperties).noquote()
+		    << "Error demarshalling property update for" << this->propertyString(property);
+		qCWarning(logDbusProperties) << error;
+	} else {
+		qCDebug(logDbusProperties).noquote()
+		    << "Updated property" << this->propertyString(property) << "to" << property->valueString();
+	}
+}
+
+void DBusPropertyGroup::requestPropertyUpdate(DBusPropertyCore* property) {
+	const QString propStr = this->propertyString(property);
+
+	if (this->interface == nullptr) {
+		qFatal(logDbusProperties).noquote()
+		    << "Tried to update property" << propStr << "of a disconnected interface";
+	}
+
+	qCDebug(logDbusProperties).noquote() << "Updating property" << propStr;
+
+	auto pendingCall = this->propertyInterface->Get(this->interface->interface(), property->name());
+	auto* call = new QDBusPendingCallWatcher(pendingCall, this);
+
+	auto responseCallback = [this, propStr, property](QDBusPendingCallWatcher* call) {
+		const QDBusPendingReply<QDBusVariant> reply = *call;
+
+		if (reply.isError()) {
+			if (!property->isRequired() && reply.error().type() == QDBusError::InvalidArgs) {
+				qCDebug(logDbusProperties) << "Error updating non-required property" << propStr;
+				qCDebug(logDbusProperties) << reply.error();
+			} else {
+				qCWarning(logDbusProperties).noquote() << "Error updating property" << propStr;
+				qCWarning(logDbusProperties) << reply.error();
+			}
+		} else {
+			this->tryUpdateProperty(property, reply.value().variant());
+		}
+
+		delete call;
+	};
+
+	QObject::connect(call, &QDBusPendingCallWatcher::finished, this, responseCallback);
+}
+
+void DBusPropertyGroup::pushPropertyUpdate(DBusPropertyCore* property) {
+	const QString propStr = this->propertyString(property);
+
+	if (this->interface == nullptr) {
+		qFatal(logDbusProperties).noquote()
+		    << "Tried to write property" << propStr << "of a disconnected interface";
+	}
+
+	qCDebug(logDbusProperties).noquote() << "Writing property" << propStr;
+
+	auto pendingCall = this->propertyInterface->Set(
+	    this->interface->interface(),
+	    property->name(),
+	    QDBusVariant(property->serialize())
+	);
+
+	auto* call = new QDBusPendingCallWatcher(pendingCall, this);
+
+	auto responseCallback = [propStr](QDBusPendingCallWatcher* call) {
+		const QDBusPendingReply<> reply = *call;
+
+		if (reply.isError()) {
+			qCWarning(logDbusProperties).noquote() << "Error writing property" << propStr;
+			qCWarning(logDbusProperties) << reply.error();
+		}
+		delete call;
+	};
+
+	QObject::connect(call, &QDBusPendingCallWatcher::finished, this, responseCallback);
+}
+
+QString DBusPropertyGroup::toString() const {
+	if (this->interface == nullptr) {
+		return "{ DISCONNECTED }";
+	} else {
+		return this->interface->service() + this->interface->path() + "/"
+		     + this->interface->interface();
+	}
+}
+
+QString DBusPropertyGroup::propertyString(const DBusPropertyCore* property) const {
+	return this->toString() % ':' % property->nameRef();
+}
+
+void DBusPropertyGroup::onPropertiesChanged(
+    const QString& interfaceName,
+    const QVariantMap& changedProperties,
+    const QStringList& invalidatedProperties
+) {
+	if (interfaceName != this->interface->interface()) return;
+	qCDebug(logDbusProperties).noquote()
+	    << "Received property change set and invalidations for" << this->toString();
+
+	for (const auto& name: invalidatedProperties) {
+		auto prop = std::ranges::find_if(this->properties, [&name](DBusPropertyCore* prop) {
+			return prop->nameRef() == name;
+		});
+
+		if (prop == this->properties.end()) {
+			qCDebug(logDbusProperties) << "Ignoring untracked property invalidation" << name << "for"
+			                           << this;
+		} else {
+			this->requestPropertyUpdate(*prop);
+		}
+	}
+
+	this->updatePropertySet(changedProperties, false);
+}
+
+} // namespace qs::dbus
+
+#if QT_VERSION < QT_VERSION_CHECK(6, 8, 0)
+QDebug operator<<(QDebug debug, const QDBusObjectPath& path) {
+	debug.nospace() << "QDBusObjectPath(" << path.path() << ")";
+	return debug;
+}
+#endif
diff --git a/src/dbus/properties.hpp b/src/dbus/properties.hpp
new file mode 100644
index 00000000..f6a63300
--- /dev/null
+++ b/src/dbus/properties.hpp
@@ -0,0 +1,337 @@
+#pragma once
+
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#include <bit>
+#include <qcontainerfwd.h>
+#include <qdbusabstractinterface.h>
+#include <qdbuserror.h>
+#include <qdbusextratypes.h>
+#include <qdbuspendingcall.h>
+#include <qdbusreply.h>
+#include <qdbusservicewatcher.h>
+#include <qdebug.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qoverload.h>
+#include <qstringview.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtversionchecks.h>
+#include <qvariant.h>
+
+#include "../core/logcat.hpp"
+#include "../core/util.hpp"
+
+class DBusPropertiesInterface;
+
+QS_DECLARE_LOGGING_CATEGORY(logDbusProperties);
+
+namespace qs::dbus {
+
+QDBusError demarshallVariant(const QVariant& variant, const QMetaType& type, void* slot);
+
+template <typename T>
+class DBusResult {
+public:
+	explicit DBusResult() = default;
+	DBusResult(T value): value(std::move(value)) {}
+	DBusResult(QDBusError error): error(std::move(error)) {}
+	explicit DBusResult(T value, QDBusError error)
+	    : value(std::move(value))
+	    , error(std::move(error)) {}
+
+	bool isValid() { return !this->error.isValid(); }
+
+	T value {};
+	QDBusError error;
+};
+
+template <typename T>
+DBusResult<T> demarshallVariant(const QVariant& variant) {
+	T value;
+	auto error = demarshallVariant(variant, QMetaType::fromType<T>(), &value);
+	return DBusResult<T>(value, error);
+}
+
+void asyncReadPropertyInternal(
+    const QMetaType& type,
+    QDBusAbstractInterface& interface,
+    const QString& property,
+    std::function<void(std::function<QDBusError(void*)>)> callback
+);
+
+template <typename T>
+void asyncReadProperty(
+    QDBusAbstractInterface& interface,
+    const QString& property,
+    const std::function<void(T, QDBusError)>& callback
+) {
+	asyncReadPropertyInternal(
+	    QMetaType::fromType<T>(),
+	    interface,
+	    property,
+	    [callback](std::function<QDBusError(void*)> internalCallback) { // NOLINT
+		    T slot;
+		    auto error = internalCallback(static_cast<void*>(&slot));
+		    callback(slot, error);
+	    }
+	);
+}
+
+class DBusPropertyGroup;
+
+class DBusPropertyCore {
+public:
+	DBusPropertyCore() = default;
+	virtual ~DBusPropertyCore() = default;
+	Q_DISABLE_COPY_MOVE(DBusPropertyCore);
+
+	[[nodiscard]] virtual QString name() const = 0;
+	[[nodiscard]] virtual QStringView nameRef() const = 0;
+	[[nodiscard]] virtual QString valueString() = 0;
+	[[nodiscard]] virtual bool isRequired() const = 0;
+	[[nodiscard]] bool exists() const { return this->mExists; }
+
+protected:
+	virtual QDBusError store(const QVariant& variant) = 0;
+	[[nodiscard]] virtual QVariant serialize() = 0;
+
+private:
+	bool mExists : 1 = false;
+
+	friend class DBusPropertyGroup;
+};
+
+// Default implementation with no transformation
+template <typename T>
+struct DBusDataTransform {
+	using Wire = T;
+	using Data = T;
+};
+
+namespace bindable_p {
+
+template <typename T>
+struct BindableParams;
+
+template <template <typename, typename, auto, auto> class B, typename C, typename T, auto O, auto S>
+struct BindableParams<B<C, T, O, S>> {
+	using Class = C;
+	using Type = T;
+	static constexpr size_t OFFSET = O;
+};
+
+template <typename Bindable>
+struct BindableType {
+	using Meta = BindableParams<Bindable>;
+	using Type = Meta::Type;
+};
+
+template <typename T, typename = void>
+struct HasFromWire: std::false_type {};
+
+template <typename T>
+struct HasFromWire<T, std::void_t<decltype(T::fromWire(std::declval<typename T::Wire>()))>>
+    : std::true_type {};
+
+template <typename T, typename = void>
+struct HasToWire: std::false_type {};
+
+template <typename T>
+struct HasToWire<T, std::void_t<decltype(T::toWire(std::declval<typename T::Data>()))>>
+    : std::true_type {};
+
+} // namespace bindable_p
+
+template <
+    typename T,
+    auto offset,
+    auto bindablePtr,
+    auto updatedPtr,
+    auto groupPtr,
+    StringLiteral16 Name,
+    bool required>
+class DBusBindableProperty: public DBusPropertyCore {
+	using PtrMeta = MemberPointerTraits<decltype(bindablePtr)>;
+	using Owner = PtrMeta::Class;
+	using Bindable = PtrMeta::Type;
+	using BindableType = bindable_p::BindableType<Bindable>::Type;
+	using BaseType = std::conditional_t<std::is_void_v<T>, BindableType, T>;
+	using Transform = DBusDataTransform<BaseType>;
+	using DataType = Transform::Data;
+	using WireType = Transform::Wire;
+
+public:
+	explicit DBusBindableProperty() { this->group()->attachProperty(this); }
+
+	[[nodiscard]] QString name() const override { return Name; }
+	[[nodiscard]] QStringView nameRef() const override { return Name; }
+	[[nodiscard]] bool isRequired() const override { return required; }
+
+	[[nodiscard]] QString valueString() override {
+		QString str;
+		QDebug(&str) << this->bindable()->value();
+		return str;
+	}
+
+	void write() { this->group()->pushPropertyUpdate(this); }
+	void requestUpdate() { this->group()->requestPropertyUpdate(this); }
+
+protected:
+	QDBusError store(const QVariant& variant) override {
+		DBusResult<DataType> result;
+
+		if constexpr (bindable_p::HasFromWire<Transform>::value) {
+			auto wireResult = demarshallVariant<WireType>(variant);
+			if (!wireResult.isValid()) return wireResult.error;
+			result = Transform::fromWire(std::move(wireResult.value));
+		} else if constexpr (std::is_same_v<WireType, BaseType>) {
+			result = demarshallVariant<DataType>(variant);
+		} else {
+			return QDBusError(QDBusError::NotSupported, "This property cannot be deserialized");
+		}
+
+		if (!result.isValid()) return result.error;
+		this->bindable()->setValue(std::move(result.value));
+
+		if constexpr (updatedPtr != nullptr) {
+			(this->owner()->*updatedPtr)();
+		}
+
+		return QDBusError();
+	}
+
+	QVariant serialize() override {
+		if constexpr (bindable_p::HasToWire<Transform>::value) {
+			return QVariant::fromValue(Transform::toWire(this->bindable()->value()));
+		} else if constexpr (std::is_same_v<WireType, BaseType>) {
+			return QVariant::fromValue(this->bindable()->value());
+		} else {
+			return QVariant();
+		}
+	}
+
+private:
+	[[nodiscard]] constexpr Owner* owner() const {
+		auto* self = std::bit_cast<char*>(this);
+		return std::bit_cast<Owner*>(self - offset()); // NOLINT
+	}
+
+	[[nodiscard]] constexpr DBusPropertyGroup* group() const { return &(this->owner()->*groupPtr); }
+	[[nodiscard]] constexpr Bindable* bindable() const { return &(this->owner()->*bindablePtr); }
+};
+
+class DBusPropertyGroup: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit DBusPropertyGroup(QVector<DBusPropertyCore*> properties = {}, QObject* parent = nullptr);
+	explicit DBusPropertyGroup(QObject* parent): DBusPropertyGroup({}, parent) {}
+
+	void setInterface(QDBusAbstractInterface* interface);
+	void attachProperty(DBusPropertyCore* property);
+	void updateAllDirect();
+	void updateAllViaGetAll();
+	void updatePropertySet(const QVariantMap& properties, bool complainMissing = true);
+	[[nodiscard]] QString toString() const;
+	[[nodiscard]] bool isConnected() const { return this->interface; }
+
+	void pushPropertyUpdate(DBusPropertyCore* property);
+	void requestPropertyUpdate(DBusPropertyCore* property);
+
+signals:
+	void getAllFinished();
+	void getAllFailed(QDBusError error);
+
+private slots:
+	void onPropertiesChanged(
+	    const QString& interfaceName,
+	    const QVariantMap& changedProperties,
+	    const QStringList& invalidatedProperties
+	);
+
+private:
+	void tryUpdateProperty(DBusPropertyCore* property, const QVariant& variant) const;
+	[[nodiscard]] QString propertyString(const DBusPropertyCore* property) const;
+
+	DBusPropertiesInterface* propertyInterface = nullptr;
+	QDBusAbstractInterface* interface = nullptr;
+	QVector<DBusPropertyCore*> properties;
+
+	friend class AbstractDBusProperty;
+};
+
+} // namespace qs::dbus
+
+#if QT_VERSION < QT_VERSION_CHECK(6, 8, 0)
+QDebug operator<<(QDebug debug, const QDBusObjectPath& path);
+#endif
+
+// NOLINTBEGIN
+#define QS_DBUS_BINDABLE_PROPERTY_GROUP(Class, name) qs::dbus::DBusPropertyGroup name {this};
+
+#define QS_DBUS_PROPERTY_BINDING_P(                                                                \
+    Class,                                                                                         \
+    Type,                                                                                          \
+    property,                                                                                      \
+    bindable,                                                                                      \
+    updated,                                                                                       \
+    group,                                                                                         \
+    name,                                                                                          \
+    required                                                                                       \
+)                                                                                                  \
+	static constexpr size_t _qs_property_##property##_offset() { return offsetof(Class, property); } \
+                                                                                                   \
+	qs::dbus::DBusBindableProperty<                                                                  \
+	    Type,                                                                                        \
+	    &Class::_qs_property_##property##_offset,                                                    \
+	    &Class::bindable,                                                                            \
+	    updated,                                                                                     \
+	    &Class::group,                                                                               \
+	    u##name,                                                                                     \
+	    required>                                                                                    \
+	    property;
+
+#define QS_DBUS_PROPERTY_BINDING_8(                                                                \
+    Class,                                                                                         \
+    Type,                                                                                          \
+    property,                                                                                      \
+    bindable,                                                                                      \
+    updated,                                                                                       \
+    group,                                                                                         \
+    name,                                                                                          \
+    required                                                                                       \
+)                                                                                                  \
+	QS_DBUS_PROPERTY_BINDING_P(                                                                      \
+	    Class,                                                                                       \
+	    Type,                                                                                        \
+	    property,                                                                                    \
+	    bindable,                                                                                    \
+	    &Class::updated,                                                                             \
+	    group,                                                                                       \
+	    name,                                                                                        \
+	    required                                                                                     \
+	)
+
+#define QS_DBUS_PROPERTY_BINDING_7(Class, Type, property, bindable, group, name, required)         \
+	QS_DBUS_PROPERTY_BINDING_P(Class, Type, property, bindable, nullptr, group, name, required)
+
+#define QS_DBUS_PROPERTY_BINDING_6(Class, property, bindable, group, name, required)               \
+	QS_DBUS_PROPERTY_BINDING_7(Class, void, property, bindable, group, name, required)
+
+#define QS_DBUS_PROPERTY_BINDING_5(Class, property, bindable, group, name)                         \
+	QS_DBUS_PROPERTY_BINDING_6(Class, property, bindable, group, name, true)
+
+// Q_OBJECT_BINDABLE_PROPERTY elides the warning for the exact same reason,
+// so we consider it safe to disable the warning.
+// clang-format off
+#define QS_DBUS_PROPERTY_BINDING(...) \
+	QT_WARNING_PUSH QT_WARNING_DISABLE_INVALID_OFFSETOF \
+	QT_OVERLOADED_MACRO(QS_DBUS_PROPERTY_BINDING, __VA_ARGS__) \
+	QT_WARNING_POP
+// clang-format on
+// NOLINTEND
diff --git a/src/debug/CMakeLists.txt b/src/debug/CMakeLists.txt
new file mode 100644
index 00000000..55da4fcb
--- /dev/null
+++ b/src/debug/CMakeLists.txt
@@ -0,0 +1,7 @@
+qt_add_library(quickshell-debug STATIC
+	lint.cpp
+)
+
+qs_pch(quickshell-debug)
+target_link_libraries(quickshell-debug PRIVATE Qt::Quick)
+target_link_libraries(quickshell PRIVATE quickshell-debug)
diff --git a/src/debug/lint.cpp b/src/debug/lint.cpp
new file mode 100644
index 00000000..dd65a280
--- /dev/null
+++ b/src/debug/lint.cpp
@@ -0,0 +1,82 @@
+#include "lint.hpp"
+#include <algorithm>
+
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qqmlcontext.h>
+#include <qqmlengine.h>
+#include <qqmlinfo.h>
+#include <qquickitem.h>
+#include <qquickwindow.h>
+#include <qstringliteral.h>
+
+#include "../core/logcat.hpp"
+
+namespace qs::debug {
+
+namespace {
+QS_LOGGING_CATEGORY(logLint, "quickshell.linter", QtWarningMsg);
+
+void lintZeroSized(QQuickItem* item);
+bool isRenderable(QQuickItem* item);
+} // namespace
+
+void lintObjectTree(QObject* object) {
+	if (!logLint().isWarningEnabled()) return;
+
+	for (auto* child: object->children()) {
+		if (child->isQuickItemType()) {
+			auto* item = static_cast<QQuickItem*>(child); // NOLINT;
+			lintItemTree(item);
+		} else {
+			lintObjectTree(child);
+		}
+	}
+}
+
+void lintItemTree(QQuickItem* item) {
+	if (!logLint().isWarningEnabled()) return;
+
+	lintZeroSized(item);
+
+	for (auto* child: item->childItems()) {
+		lintItemTree(child);
+	}
+}
+
+namespace {
+
+void lintZeroSized(QQuickItem* item) {
+	if (!item->isEnabled() || !item->isVisible()) return;
+	if (item->childItems().isEmpty()) return;
+
+	auto zeroWidth = item->width() == 0;
+	auto zeroHeight = item->height() == 0;
+
+	if (!zeroWidth && !zeroHeight) return;
+
+	if (!isRenderable(item)) return;
+
+	auto* ctx = QQmlEngine::contextForObject(item);
+	if (!ctx || ctx->baseUrl().scheme() != QStringLiteral("qsintercept")) return;
+
+	qmlWarning(item) << "Item is visible and has visible children, but has zero "
+	                 << (zeroWidth && zeroHeight ? "width and height"
+	                     : zeroWidth             ? "width"
+	                                             : "height");
+}
+
+bool isRenderable(QQuickItem* item) {
+	if (!item->isEnabled() || !item->isVisible()) return false;
+
+	if (item->flags().testFlags(QQuickItem::ItemHasContents)) {
+		return true;
+	}
+
+	return std::ranges::any_of(item->childItems(), [](auto* item) { return isRenderable(item); });
+}
+
+} // namespace
+
+} // namespace qs::debug
diff --git a/src/debug/lint.hpp b/src/debug/lint.hpp
new file mode 100644
index 00000000..5b5420ea
--- /dev/null
+++ b/src/debug/lint.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <qobject.h>
+#include <qquickitem.h>
+
+namespace qs::debug {
+
+void lintObjectTree(QObject* object);
+void lintItemTree(QQuickItem* item);
+
+} // namespace qs::debug
diff --git a/src/io/CMakeLists.txt b/src/io/CMakeLists.txt
index 6fe0f409..17628d38 100644
--- a/src/io/CMakeLists.txt
+++ b/src/io/CMakeLists.txt
@@ -1,20 +1,33 @@
 qt_add_library(quickshell-io STATIC
 	datastream.cpp
+	processcore.cpp
 	process.cpp
+	fileview.cpp
+	jsonadapter.cpp
+	ipccomm.cpp
+	ipc.cpp
+	ipchandler.cpp
 )
 
-add_library(quickshell-io-init OBJECT init.cpp)
-
 if (SOCKETS)
 	target_sources(quickshell-io PRIVATE socket.cpp)
 endif()
 
-qt_add_qml_module(quickshell-io URI Quickshell.Io VERSION 0.1)
+qt_add_qml_module(quickshell-io
+	URI Quickshell.Io
+	VERSION 0.1
+	DEPENDENCIES QtQml
+	QML_FILES
+		FileView.qml
+)
 
-target_link_libraries(quickshell-io PRIVATE ${QT_DEPS})
-target_link_libraries(quickshell-io-init PRIVATE ${QT_DEPS})
+qs_add_module_deps_light(quickshell-io Quickshell)
+install_qml_module(quickshell-io)
 
-target_link_libraries(quickshell PRIVATE quickshell-ioplugin quickshell-io-init)
+target_link_libraries(quickshell-io PRIVATE Qt::Quick)
+target_link_libraries(quickshell PRIVATE quickshell-ioplugin)
+
+qs_module_pch(quickshell-io)
 
 if (BUILD_TESTING)
 	add_subdirectory(test)
diff --git a/src/io/FileView.qml b/src/io/FileView.qml
new file mode 100644
index 00000000..05f4c7b7
--- /dev/null
+++ b/src/io/FileView.qml
@@ -0,0 +1,53 @@
+import Quickshell.Io
+
+FileViewInternal {
+	property bool preload: this.__preload;
+	property bool blockLoading: this.__blockLoading;
+	property bool blockAllReads: this.__blockAllReads;
+	property bool printErrors: this.__printErrors;
+	property string path: this.__path;
+
+	onPreloadChanged: this.__preload = preload;
+	onBlockLoadingChanged: this.__blockLoading = this.blockLoading;
+	onBlockAllReadsChanged: this.__blockAllReads = this.blockAllReads;
+	onPrintErrorsChanged: this.__printErrors = this.printErrors;
+
+	// Unfortunately path can't be kept as an empty string until the file loads
+	// without using QQmlPropertyValueInterceptor which is private. If we lean fully
+	// into using private code in the future, there will be no reason not to do it here.
+
+	onPathChanged: {
+		if (!this.preload) this.__preload = false;
+		this.__printErrors = this.printErrors;
+		this.__path = this.path;
+		if (this.preload) this.__preload = true;
+	}
+
+	// The C++ side can't force bindings to be resolved in a specific order so
+	// its done here. Functions are used to avoid the eager loading aspect of properties.
+
+	// Preload is set as it is below to avoid starting an async read from a preload
+	// if the user wants an initial blocking read.
+
+	function text(): string {
+		if (!this.preload) this.__preload = false;
+		this.__blockLoading = this.blockLoading;
+		this.__blockAllReads = this.blockAllReads;
+		this.__printErrors = this.printErrors;
+		this.__path = this.path;
+		const text = this.__text;
+		if (this.preload) this.__preload = true;
+		return text;
+	}
+
+	function data(): var {
+		if (!this.preload) this.__preload = false;
+		this.__blockLoading = this.blockLoading;
+		this.__blockAllReads = this.blockAllReads;
+		this.__printErrors = this.printErrors;
+		this.__path = this.path;
+		const data = this.__data;
+		if (this.preload) this.__preload = true;
+		return data;
+	}
+}
diff --git a/src/io/datastream.cpp b/src/io/datastream.cpp
index c6559215..393f3330 100644
--- a/src/io/datastream.cpp
+++ b/src/io/datastream.cpp
@@ -98,6 +98,10 @@ void SplitParser::parseBytes(QByteArray& incoming, QByteArray& buffer) {
 	}
 }
 
+void SplitParser::streamEnded(QByteArray& buffer) {
+	if (!buffer.isEmpty()) emit this->read(QString(buffer));
+}
+
 QString SplitParser::splitMarker() const { return this->mSplitMarker; }
 
 void SplitParser::setSplitMarker(QString marker) {
@@ -107,3 +111,27 @@ void SplitParser::setSplitMarker(QString marker) {
 	this->mSplitMarkerChanged = true;
 	emit this->splitMarkerChanged();
 }
+
+void StdioCollector::parseBytes(QByteArray& incoming, QByteArray& buffer) {
+	buffer.append(incoming);
+
+	if (!this->mWaitForEnd) {
+		this->mData = buffer;
+		emit this->dataChanged();
+	}
+}
+
+void StdioCollector::streamEnded(QByteArray& buffer) {
+	if (this->mWaitForEnd) {
+		this->mData = buffer;
+		emit this->dataChanged();
+	}
+
+	emit this->streamFinished();
+}
+
+void StdioCollector::setWaitForEnd(bool waitForEnd) {
+	if (waitForEnd == this->mWaitForEnd) return;
+	this->mWaitForEnd = waitForEnd;
+	emit this->waitForEndChanged();
+}
diff --git a/src/io/datastream.hpp b/src/io/datastream.hpp
index 24aa54a4..b91ec044 100644
--- a/src/io/datastream.hpp
+++ b/src/io/datastream.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <qbytearray.h>
+#include <qcontainerfwd.h>
 #include <qlocalsocket.h>
 #include <qobject.h>
 #include <qqmlintegration.h>
@@ -10,7 +11,7 @@
 class DataStreamParser;
 
 ///! Data source that can be streamed into a parser.
-/// See also: [DataStreamParser](../datastreamparser)
+/// See also: @@DataStreamParser
 class DataStream: public QObject {
 	Q_OBJECT;
 	/// The parser to stream data from this source into.
@@ -43,7 +44,7 @@ protected:
 };
 
 ///! Parser for streamed input data.
-/// See also: [DataStream](../datastream), [SplitParser](../splitparser)
+/// See also: @@DataStream, @@SplitParser.
 class DataStreamParser: public QObject {
 	Q_OBJECT;
 	QML_ELEMENT;
@@ -54,16 +55,15 @@ public:
 
 	// the buffer will be sent in both slots if there is data remaining from a previous parser
 	virtual void parseBytes(QByteArray& incoming, QByteArray& buffer) = 0;
+	virtual void streamEnded(QByteArray& /*buffer*/) {}
 
 signals:
 	/// Emitted when data is read from the stream.
 	void read(QString data);
 };
 
-///! Parser for delimited data streams.
-/// Parser for delimited data streams. [read()] is emitted once per delimited chunk of the stream.
-///
-/// [read()]: ../datastreamparser#sig.read
+///! DataStreamParser for delimited data streams.
+/// DataStreamParser for delimited data streams. @@DataStreamParser.read(s) is emitted once per delimited chunk of the stream.
 class SplitParser: public DataStreamParser {
 	Q_OBJECT;
 	/// The delimiter for parsed data. May be multiple characters. Defaults to `\n`.
@@ -77,6 +77,7 @@ public:
 	explicit SplitParser(QObject* parent = nullptr): DataStreamParser(parent) {}
 
 	void parseBytes(QByteArray& incoming, QByteArray& buffer) override;
+	void streamEnded(QByteArray& buffer) override;
 
 	[[nodiscard]] QString splitMarker() const;
 	void setSplitMarker(QString marker);
@@ -88,3 +89,41 @@ private:
 	QString mSplitMarker = "\n";
 	bool mSplitMarkerChanged = false;
 };
+
+///! DataStreamParser that collects all output into a buffer
+/// StdioCollector collects all process output into a buffer exposed as @@text or @@data.
+class StdioCollector: public DataStreamParser {
+	Q_OBJECT;
+	QML_ELEMENT;
+	/// The stdio buffer exposed as text. if @@waitForEnd is true, this will not change
+	/// until the stream ends.
+	Q_PROPERTY(QString text READ text NOTIFY dataChanged);
+	/// The stdio buffer exposed as an [ArrayBuffer]. if @@waitForEnd is true, this will not change
+	/// until the stream ends.
+	///
+	/// [ArrayBuffer]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer
+	Q_PROPERTY(QByteArray data READ data NOTIFY dataChanged);
+	/// If true, @@text and @@data will not be updated until the stream ends. Defaults to true.
+	Q_PROPERTY(bool waitForEnd READ waitForEnd WRITE setWaitForEnd NOTIFY waitForEndChanged);
+
+public:
+	explicit StdioCollector(QObject* parent = nullptr): DataStreamParser(parent) {}
+
+	void parseBytes(QByteArray& incoming, QByteArray& buffer) override;
+	void streamEnded(QByteArray& buffer) override;
+
+	[[nodiscard]] QString text() const { return this->mData; }
+	[[nodiscard]] QByteArray data() const { return this->mData; }
+
+	[[nodiscard]] bool waitForEnd() const { return this->mWaitForEnd; }
+	void setWaitForEnd(bool waitForEnd);
+
+signals:
+	void waitForEndChanged();
+	void dataChanged();
+	void streamFinished();
+
+private:
+	bool mWaitForEnd = true;
+	QByteArray mData;
+};
diff --git a/src/io/fileview.cpp b/src/io/fileview.cpp
new file mode 100644
index 00000000..1585f26f
--- /dev/null
+++ b/src/io/fileview.cpp
@@ -0,0 +1,702 @@
+#include "fileview.hpp"
+#include <array>
+#include <utility>
+
+#include <qatomic.h>
+#include <qdir.h>
+#include <qfiledevice.h>
+#include <qfileinfo.h>
+#include <qfilesystemwatcher.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qmutex.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qobjectdefs.h>
+#include <qqmlinfo.h>
+#include <qsavefile.h>
+#include <qscopedpointer.h>
+#include <qthreadpool.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../core/logcat.hpp"
+#include "../core/util.hpp"
+
+namespace qs::io {
+
+namespace {
+QS_LOGGING_CATEGORY(logFileView, "quickshell.io.fileview", QtWarningMsg);
+}
+
+QString FileViewError::toString(FileViewError::Enum value) {
+	switch (value) {
+	case Success: return "Success";
+	case Unknown: return "An unknown error has occurred";
+	case FileNotFound: return "The specified file does not exist";
+	case PermissionDenied: return "Permission denied";
+	case NotAFile: return "The specified path was not a file";
+	default: return "Invalid error";
+	}
+}
+
+bool FileViewData::operator==(const FileViewData& other) const {
+	if (this->data == other.data && !this->data.isEmpty()) return true;
+	if (this->text == other.text && !this->text.isEmpty()) return true;
+	return this->operator const QByteArray&() == other.operator const QByteArray&();
+}
+
+bool FileViewData::isEmpty() const { return this->data.isEmpty() && this->text.isEmpty(); }
+
+FileViewData::operator const QString&() const {
+	if (this->text.isEmpty() && !this->data.isEmpty()) {
+		this->text = QString::fromUtf8(this->data);
+	}
+
+	return this->text;
+}
+
+FileViewData::operator const QByteArray&() const {
+	if (this->data.isEmpty() && !this->text.isEmpty()) {
+		this->data = this->text.toUtf8();
+	}
+
+	return this->data;
+}
+
+FileViewOperation::FileViewOperation(FileView* owner): owner(owner) {
+	this->setAutoDelete(false);
+	this->blockMutex.lock();
+}
+
+void FileViewOperation::block() {
+	// block until a lock can be acauired, then immediately drop it
+	auto unused = QMutexLocker(&this->blockMutex);
+}
+
+void FileViewOperation::tryCancel() { this->shouldCancel.storeRelease(true); }
+
+void FileViewOperation::finishRun() {
+	this->blockMutex.unlock();
+	QMetaObject::invokeMethod(this, &FileViewOperation::finished, Qt::QueuedConnection);
+}
+
+void FileViewOperation::finished() {
+	emit this->done();
+	// Delete happens on the main thread, after done(), meaning no operation accesses
+	// will be a UAF.
+	delete this;
+}
+
+void FileViewReader::run() {
+	if (!this->shouldCancel) {
+		FileViewReader::read(this->owner, this->state, this->doStringConversion, this->shouldCancel);
+
+		if (this->shouldCancel.loadAcquire()) {
+			qCDebug(logFileView) << "Read" << this << "of" << state.path << "canceled for" << this->owner;
+		}
+	}
+
+	this->finishRun();
+}
+
+void FileViewReader::read(
+    FileView* view,
+    FileViewState& state,
+    bool doStringConversion,
+    const QAtomicInteger<bool>& shouldCancel
+) {
+	qCDebug(logFileView) << "Reader started for" << state.path;
+
+	auto info = QFileInfo(state.path);
+	state.exists = info.exists();
+
+	if (!state.exists) {
+		if (state.printErrors) {
+			qmlWarning(view) << "Read of " << state.path << " failed: File does not exist.";
+		}
+
+		state.error = FileViewError::FileNotFound;
+		return;
+	}
+
+	if (!info.isFile()) {
+		if (state.printErrors) {
+			qmlWarning(view) << "Read of " << state.path << " failed: Not a file.";
+		}
+
+		state.error = FileViewError::NotAFile;
+		return;
+	} else if (!info.isReadable()) {
+		if (state.printErrors) {
+			qmlWarning(view) << "Read of " << state.path << " failed: Permission denied.";
+		}
+
+		state.error = FileViewError::PermissionDenied;
+		return;
+	}
+
+	if (shouldCancel.loadAcquire()) return;
+
+	auto file = QFile(state.path);
+
+	if (!file.open(QFile::ReadOnly)) {
+		qmlWarning(view) << "Read of " << state.path << " failed: Unknown failure when opening file.";
+		state.error = FileViewError::Unknown;
+		return;
+	}
+
+	if (shouldCancel.loadAcquire()) return;
+
+	if (file.size() != 0) {
+		auto data = QByteArray(file.size(), Qt::Uninitialized);
+		qint64 i = 0;
+
+		while (true) {
+			if (shouldCancel.loadAcquire()) return;
+
+			auto r = file.read(data.data() + i, data.length() - i); // NOLINT
+
+			if (r == -1) {
+				qmlWarning(view) << "Read of " << state.path << " failed: read() failed.";
+
+				state.error = FileViewError::Unknown;
+				return;
+			} else if (r == 0) {
+				data.resize(i);
+				break;
+			}
+
+			i += r;
+		}
+
+		state.data = data;
+	} else { // Mostly happens in /proc and friends, which have zero sized files with content.
+		QByteArray data;
+		auto buf = std::array<char, 4096>();
+
+		while (true) {
+			if (shouldCancel.loadAcquire()) return;
+
+			auto r = file.read(buf.data(), buf.size()); // NOLINT
+
+			if (r == -1) {
+				qmlWarning(view) << "Read of " << state.path << " failed: read() failed.";
+
+				state.error = FileViewError::Unknown;
+				return;
+			} else {
+				data.append(buf.data(), r);
+				if (r == 0) break;
+			}
+		}
+
+		state.data = data;
+	}
+
+	if (shouldCancel.loadAcquire()) return;
+
+	if (doStringConversion) {
+		state.data.operator const QString&();
+	}
+}
+
+void FileViewWriter::run() {
+	if (!this->shouldCancel.loadAcquire()) {
+		FileViewWriter::write(this->owner, this->state, this->doAtomicWrite, this->shouldCancel);
+
+		if (this->shouldCancel.loadAcquire()) {
+			qCDebug(logFileView) << "Write" << this << "of" << state.path << "canceled for"
+			                     << this->owner;
+		}
+	}
+
+	this->finishRun();
+}
+
+void FileViewWriter::write(
+    FileView* view,
+    FileViewState& state,
+    bool doAtomicWrite,
+    const QAtomicInteger<bool>& shouldCancel
+) {
+	qCDebug(logFileView) << "Writer started for" << state.path;
+
+	auto info = QFileInfo(state.path);
+	state.exists = info.exists();
+
+	if (!state.exists) {
+		auto dir = info.dir();
+		if (!dir.mkpath(".")) {
+			if (state.printErrors) {
+				qmlWarning(view) << "Write of " << state.path
+				                 << " failed: Could not create parent directories of file.";
+			}
+
+			state.error = FileViewError::PermissionDenied;
+			return;
+		}
+	} else if (!info.isWritable()) {
+		if (state.printErrors) {
+			qmlWarning(view) << "Write of " << state.path << " failed: Permission denied.";
+		}
+
+		state.error = FileViewError::PermissionDenied;
+		return;
+	}
+
+	if (shouldCancel.loadAcquire()) return;
+
+	QScopedPointer<QFileDevice> file;
+	if (doAtomicWrite) {
+		file.reset(new QSaveFile(state.path));
+	} else {
+		file.reset(new QFile(state.path));
+	}
+
+	if (!file->open(QFile::WriteOnly)) {
+		qmlWarning(view) << "Write of " << state.path << " failed: Unknown error when opening file.";
+		state.error = FileViewError::Unknown;
+		return;
+	}
+
+	if (shouldCancel.loadAcquire()) return;
+
+	const QByteArray& data = state.data;
+	qint64 i = 0;
+
+	while (true) {
+		if (shouldCancel.loadAcquire()) return;
+
+		auto r = file->write(data.data() + i, data.length() - i); // NOLINT
+
+		if (r == -1) {
+			qmlWarning(view) << "Write of " << state.path << " failed: write() failed.";
+
+			state.error = FileViewError::Unknown;
+			return;
+		} else {
+			i += r;
+			if (i == data.length()) break;
+		}
+	}
+
+	if (shouldCancel.loadAcquire()) return;
+
+	if (doAtomicWrite) {
+		if (!reinterpret_cast<QSaveFile*>(file.get())->commit()) {
+			qmlWarning(view) << "Write of " << state.path << " failed: Atomic commit failed.";
+		}
+	}
+}
+
+FileView::~FileView() {
+	if (this->mAdapter) {
+		this->mAdapter->setFileView(nullptr);
+	}
+}
+
+void FileView::loadAsync(bool doStringConversion) {
+	// Writes update via operationFinished, making a read both invalid and outdated.
+	if (!this->liveOperation || this->pathInFlight != this->targetPath) {
+		this->cancelAsync();
+		this->pathInFlight = this->targetPath;
+
+		if (this->targetPath.isEmpty()) {
+			auto state = FileViewState();
+			this->updateState(state);
+		} else {
+			qCDebug(logFileView) << "Starting async load for" << this << "of" << this->targetPath;
+			auto* reader = new FileViewReader(this, doStringConversion);
+			reader->state.path = this->targetPath;
+			reader->state.printErrors = this->bPrintErrors;
+			QObject::connect(reader, &FileViewOperation::done, this, &FileView::operationFinished);
+			QThreadPool::globalInstance()->start(reader); // takes ownership
+			this->liveOperation = reader;
+		}
+	}
+}
+
+void FileView::saveAsync() {
+	if (this->targetPath.isEmpty()) {
+		qmlWarning(this) << "Cannot write file, as no path has been specified.";
+		this->writeData = FileViewData();
+	} else {
+		// cancel will blank the data if waiting
+		auto data = this->writeData;
+
+		this->cancelAsync();
+
+		qCDebug(logFileView) << "Starting async save for" << this << "of" << this->targetPath;
+		auto* writer = new FileViewWriter(this, this->bAtomicWrites);
+		writer->state.path = this->targetPath;
+		writer->state.data = std::move(data);
+		writer->state.printErrors = this->bPrintErrors;
+		QObject::connect(writer, &FileViewOperation::done, this, &FileView::operationFinished);
+		QThreadPool::globalInstance()->start(writer); // takes ownership
+		this->liveOperation = writer;
+	}
+}
+
+void FileView::cancelAsync() {
+	if (!this->liveOperation) return;
+	this->liveOperation->tryCancel();
+
+	if (this->liveReader()) {
+		qCDebug(logFileView) << "Disowning async read for" << this;
+		QObject::disconnect(this->liveOperation, nullptr, this, nullptr);
+		this->liveOperation = nullptr;
+	} else if (this->liveWriter()) {
+		// We don't want to start a read or write operation in the middle of a write.
+		// This really shouldn't block but it isn't worth fixing for now.
+		qCDebug(logFileView) << "Blocking on write for" << this;
+		this->waitForJob();
+	}
+}
+
+void FileView::operationFinished() {
+	if (this->sender() != this->liveOperation) {
+		qCWarning(logFileView) << "got operation finished from dropped operation" << this->sender();
+		return;
+	}
+
+	qCDebug(logFileView) << "Async operation finished for" << this;
+	this->writeData = FileViewData();
+	this->updateState(this->liveOperation->state);
+
+	if (this->liveReader()) {
+		if (this->state.error) emit this->loadFailed(this->state.error);
+		else emit this->loaded();
+	} else {
+		if (this->state.error) emit this->saveFailed(this->state.error);
+		else emit this->saved();
+	}
+
+	this->liveOperation = nullptr;
+}
+
+void FileView::reload() { this->updatePath(); }
+
+bool FileView::waitForJob() {
+	if (this->liveOperation != nullptr) {
+		QObject::disconnect(this->liveOperation, nullptr, this, nullptr);
+		this->liveOperation->block();
+		this->writeData = FileViewData();
+		this->updateState(this->liveOperation->state);
+
+		if (this->liveReader()) {
+			if (this->state.error) emit this->loadFailed(this->state.error);
+			else emit this->loaded();
+		} else {
+			if (this->state.error) emit this->saveFailed(this->state.error);
+			else emit this->saved();
+		}
+
+		this->liveOperation = nullptr;
+		return true;
+	} else return false;
+}
+
+void FileView::loadSync() {
+	if (this->targetPath.isEmpty()) {
+		auto state = FileViewState();
+		this->updateState(state);
+	} else if (!this->waitForJob()) {
+		auto state = FileViewState(this->targetPath);
+		state.printErrors = this->bPrintErrors;
+		FileViewReader::read(this, state, false);
+		this->updateState(state);
+
+		if (this->state.error) emit this->loadFailed(this->state.error);
+		else emit this->loaded();
+	}
+}
+
+void FileView::saveSync() {
+	if (this->targetPath.isEmpty()) {
+		qmlWarning(this) << "Cannot write file, as no path has been specified.";
+		this->writeData = FileViewData();
+	} else {
+		// Both reads and writes will be outdated.
+		if (this->liveOperation) this->cancelAsync();
+
+		auto state = FileViewState(this->targetPath);
+		state.data = this->writeData;
+		state.printErrors = this->bPrintErrors;
+		FileViewWriter::write(this, state, this->bAtomicWrites);
+		this->writeData = FileViewData();
+		this->updateState(state);
+
+		if (this->state.error) emit this->saveFailed(this->state.error);
+		else emit this->saved();
+	}
+}
+
+void FileView::updateState(FileViewState& newState) {
+	DEFINE_DROP_EMIT_IF(newState.path != this->state.path, this, pathChanged);
+	// assume if the path was changed the data also changed
+	auto dataChanged = pathChanged || newState.data != this->state.data;
+	// DEFINE_DROP_EMIT_IF(newState.exists != this->state.exists, this, existsChanged);
+
+	this->mPrepared = true;
+	auto loadedChanged = this->setLoadedOrAsync(!newState.path.isEmpty() && newState.exists);
+
+	this->state.path = std::move(newState.path);
+
+	if (dataChanged) {
+		this->state.data = newState.data;
+	}
+
+	this->state.exists = newState.exists;
+	this->state.error = newState.error;
+
+	DropEmitter::call(
+	    pathChanged,
+	    // existsChanged,
+	    loadedChanged
+	);
+
+	if (dataChanged) this->emitDataChanged();
+}
+
+QString FileView::path() const { return this->state.path; }
+
+void FileView::setPath(const QString& path) {
+	auto p = path.startsWith("file://") ? path.sliced(7) : path;
+	if (p == this->targetPath) return;
+
+	if (this->liveWriter()) {
+		this->waitForJob();
+	} else {
+		this->cancelAsync();
+	}
+
+	this->targetPath = p;
+	this->updatePath();
+}
+
+void FileView::updatePath() {
+	this->mPrepared = false;
+
+	if (this->targetPath.isEmpty()) {
+		auto state = FileViewState();
+		this->updateState(state);
+	} else if (this->mPreload) {
+		this->loadAsync(true);
+	} else {
+		this->emitDataChanged();
+	}
+
+	this->updateWatchedFiles();
+}
+
+void FileView::updateWatchedFiles() {
+	// If inotify events are sent to the watcher after deletion and deleteLater
+	// isn't used, a use after free in the QML engine will occur.
+	if (this->watcher) {
+		this->watcher->deleteLater();
+		this->watcher = nullptr;
+	}
+
+	if (!this->targetPath.isEmpty() && this->bWatchChanges) {
+		qCDebug(logFileView) << "Creating watcher for" << this << "at" << this->targetPath;
+		this->watcher = new QFileSystemWatcher(this);
+		this->watcher->addPath(this->targetPath);
+
+		auto dirPath = this->targetPath;
+		if (!dirPath.contains("/")) dirPath = "./" % dirPath;
+
+		if (auto lastIndex = dirPath.lastIndexOf('/'); lastIndex != -1) {
+			dirPath = dirPath.sliced(0, lastIndex);
+			this->watcher->addPath(dirPath);
+		}
+
+		QObject::connect(
+		    this->watcher,
+		    &QFileSystemWatcher::fileChanged,
+		    this,
+		    &FileView::onWatchedFileChanged
+		);
+
+		QObject::connect(
+		    this->watcher,
+		    &QFileSystemWatcher::directoryChanged,
+		    this,
+		    &FileView::onWatchedDirectoryChanged
+		);
+	}
+}
+
+void FileView::onWatchedFileChanged() {
+	if (!this->watcher->files().contains(this->targetPath)) {
+		this->watcher->addPath(this->targetPath);
+	}
+
+	emit this->fileChanged();
+}
+
+void FileView::onWatchedDirectoryChanged() {
+	if (!this->watcher->files().contains(this->targetPath) && QFileInfo(this->targetPath).exists()) {
+		// the file was just created
+		this->watcher->addPath(this->targetPath);
+		emit this->fileChanged();
+	}
+}
+
+bool FileView::shouldBlockRead() const {
+	return this->mBlockAllReads || (this->mBlockLoading && !this->mLoadedOrAsync);
+}
+
+FileViewReader* FileView::liveReader() const {
+	return dynamic_cast<FileViewReader*>(this->liveOperation);
+}
+
+FileViewWriter* FileView::liveWriter() const {
+	return dynamic_cast<FileViewWriter*>(this->liveOperation);
+}
+
+const FileViewData& FileView::writeCmpData() const {
+	return this->writeData.isEmpty() ? this->state.data : this->writeData;
+}
+
+QByteArray FileView::data() {
+	auto guard = this->dataChangedEmitter.block();
+
+	if (!this->mPrepared) {
+		if (this->shouldBlockRead()) this->loadSync();
+		else this->loadAsync(false);
+	}
+
+	return this->state.data;
+}
+
+QString FileView::text() {
+	auto guard = this->textChangedEmitter.block();
+
+	if (!this->mPrepared) {
+		if (this->shouldBlockRead()) this->loadSync();
+		else this->loadAsync(true);
+	}
+
+	return this->state.data;
+}
+
+void FileView::setData(const QByteArray& data) {
+	if (this->writeCmpData().operator const QByteArray&() == data) return;
+	this->writeData = data;
+
+	if (this->bBlockWrites) this->saveSync();
+	else this->saveAsync();
+}
+
+void FileView::setText(const QString& text) {
+	if (this->writeCmpData().operator const QString&() == text) return;
+	this->writeData = text;
+
+	if (this->bBlockWrites) this->saveSync();
+	else this->saveAsync();
+}
+
+void FileView::emitDataChanged() {
+	this->dataChangedEmitter.call(this);
+	this->textChangedEmitter.call(this);
+	emit this->dataChanged();
+	emit this->textChanged();
+}
+
+DEFINE_MEMBER_GETSET(FileView, isLoadedOrAsync, setLoadedOrAsync);
+DEFINE_MEMBER_GET(FileView, shouldPreload);
+DEFINE_MEMBER_GET(FileView, blockLoading);
+DEFINE_MEMBER_GET(FileView, blockAllReads);
+
+void FileView::setPreload(bool preload) {
+	if (preload != this->mPreload) {
+		this->mPreload = preload;
+		emit this->preloadChanged();
+
+		if (preload) this->emitDataChanged();
+
+		if (!this->mPrepared && this->mPreload) {
+			this->loadAsync(false);
+		}
+	}
+}
+
+void FileView::setBlockLoading(bool blockLoading) {
+	if (blockLoading != this->mBlockLoading) {
+		auto wasBlocking = this->shouldBlockRead();
+
+		this->mBlockLoading = blockLoading;
+		emit this->blockLoadingChanged();
+
+		if (!wasBlocking && this->shouldBlockRead()) {
+			this->emitDataChanged();
+		}
+	}
+}
+
+void FileView::setBlockAllReads(bool blockAllReads) {
+	if (blockAllReads != this->mBlockAllReads) {
+		auto wasBlocking = this->shouldBlockRead();
+
+		this->mBlockAllReads = blockAllReads;
+		emit this->blockAllReadsChanged();
+
+		if (!wasBlocking && this->shouldBlockRead()) {
+			this->emitDataChanged();
+		}
+	}
+}
+
+FileViewAdapter* FileView::adapter() const { return this->mAdapter; }
+
+void FileView::setAdapter(FileViewAdapter* adapter) {
+	if (adapter == this->mAdapter) return;
+
+	if (this->mAdapter) {
+		this->mAdapter->setFileView(nullptr);
+		QObject::disconnect(this->mAdapter, nullptr, this, nullptr);
+	}
+
+	this->mAdapter = adapter;
+
+	if (adapter) {
+		this->mAdapter->setFileView(this);
+		QObject::connect(adapter, &FileViewAdapter::adapterUpdated, this, &FileView::adapterUpdated);
+		QObject::connect(adapter, &QObject::destroyed, this, &FileView::onAdapterDestroyed);
+	}
+
+	emit this->adapterChanged();
+}
+
+void FileView::writeAdapter() {
+	if (!this->mAdapter) {
+		qmlWarning(this) << "Cannot call writeAdapter without an adapter.";
+		return;
+	}
+
+	this->setData(this->mAdapter->serializeAdapter());
+}
+
+void FileView::onAdapterDestroyed() { this->mAdapter = nullptr; }
+
+void FileViewAdapter::setFileView(FileView* fileView) {
+	if (fileView == this->mFileView) return;
+
+	if (this->mFileView) {
+		QObject::disconnect(this->mFileView, nullptr, this, nullptr);
+	}
+
+	this->mFileView = fileView;
+
+	if (fileView) {
+		QObject::connect(fileView, &FileView::dataChanged, this, &FileViewAdapter::onDataChanged);
+		this->setFileView(fileView);
+	} else {
+		this->setFileView(nullptr);
+	}
+}
+
+void FileViewAdapter::onDataChanged() { this->deserializeAdapter(this->mFileView->data()); }
+
+} // namespace qs::io
diff --git a/src/io/fileview.hpp b/src/io/fileview.hpp
new file mode 100644
index 00000000..4d6128ca
--- /dev/null
+++ b/src/io/fileview.hpp
@@ -0,0 +1,457 @@
+#pragma once
+
+#include <utility>
+
+#include <qatomic.h>
+#include <qdebug.h>
+#include <qfilesystemwatcher.h>
+#include <qlogging.h>
+#include <qmutex.h>
+#include <qobject.h>
+#include <qpointer.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qqmlparserstatus.h>
+#include <qrunnable.h>
+#include <qstringview.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+
+#include "../core/doc.hpp"
+#include "../core/util.hpp"
+
+namespace qs::io {
+
+class FileViewError: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		/// No error occured.
+		Success = 0,
+		/// An unknown error occured. Check the logs for details.
+		Unknown = 1,
+		/// The file to read does not exist.
+		FileNotFound = 2,
+		/// Permission to read/write the file was not granted, or permission
+		/// to create parent directories was not granted when writing the file.
+		PermissionDenied = 3,
+		/// The specified path to read/write exists and was not a file.
+		NotAFile = 4,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(qs::io::FileViewError::Enum value);
+};
+
+struct FileViewData {
+	FileViewData() = default;
+	FileViewData(QString text): text(std::move(text)) {}
+	FileViewData(QByteArray data): data(std::move(data)) {}
+
+	[[nodiscard]] bool operator==(const FileViewData& other) const;
+	[[nodiscard]] bool isEmpty() const;
+
+	operator const QString&() const;
+	operator const QByteArray&() const;
+
+private:
+	mutable QString text;
+	mutable QByteArray data;
+};
+
+struct FileViewState {
+	FileViewState() = default;
+	explicit FileViewState(QString path): path(std::move(path)) {}
+
+	QString path;
+	FileViewData data;
+	bool exists = false;
+	bool printErrors = true;
+	FileViewError::Enum error = FileViewError::Success;
+};
+
+class FileView;
+
+class FileViewOperation
+    : public QObject
+    , public QRunnable {
+	Q_OBJECT;
+
+public:
+	explicit FileViewOperation(FileView* owner);
+
+	void block();
+
+	// Attempt to cancel the operation, which may or may not be possible.
+	// If possible, block() returns sooner.
+	void tryCancel();
+
+	FileViewState state;
+
+signals:
+	void done();
+
+private slots:
+	void finished();
+
+protected:
+	QMutex blockMutex;
+	QPointer<FileView> owner;
+	QAtomicInteger<bool> shouldCancel = false;
+
+	void finishRun();
+};
+
+class FileViewReader: public FileViewOperation {
+public:
+	explicit FileViewReader(FileView* owner, bool doStringConversion)
+	    : FileViewOperation(owner)
+	    , doStringConversion(doStringConversion) {}
+
+	void run() override;
+
+	static void read(
+	    FileView* view,
+	    FileViewState& state,
+	    bool doStringConversion,
+	    const QAtomicInteger<bool>& shouldCancel = false
+	);
+
+	bool doStringConversion;
+};
+
+class FileViewWriter: public FileViewOperation {
+public:
+	explicit FileViewWriter(FileView* owner, bool doAtomicWrite)
+	    : FileViewOperation(owner)
+	    , doAtomicWrite(doAtomicWrite) {}
+
+	void run() override;
+
+	static void write(
+	    FileView* view,
+	    FileViewState& state,
+	    bool doAtomicWrite,
+	    const QAtomicInteger<bool>& shouldCancel = false
+	);
+
+	bool doAtomicWrite;
+};
+
+class FileViewAdapter;
+
+///! Simple accessor for small files.
+/// A reader for small to medium files that don't need seeking/cursor access,
+/// suitable for most text files.
+///
+/// #### Example: Reading a JSON as text
+/// ```qml
+/// FileView {
+///   id: jsonFile
+///   path: Qt.resolvedUrl("./your.json")
+///   // Forces the file to be loaded by the time we call JSON.parse().
+///   // see blockLoading's property documentation for details.
+///   blockLoading: true
+/// }
+///
+/// readonly property var jsonData: JSON.parse(jsonFile.text())
+/// ```
+///
+/// Also see @@JsonAdapter for an alternative way to handle reading and writing JSON files.
+class FileView: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// The path to the file that should be read, or an empty string to unload the file.
+	QSDOC_PROPERTY_OVERRIDE(QString path READ path WRITE setPath NOTIFY pathChanged);
+	/// If the file should be loaded in the background immediately when set. Defaults to true.
+	///
+	/// This may either increase or decrease the amount of time it takes to load the file
+	/// depending on how large the file is, how fast its storage is, and how you access its data.
+	QSDOC_PROPERTY_OVERRIDE(bool preload READ shouldPreload WRITE setPreload NOTIFY preloadChanged);
+	/// If @@text() and @@data() should block all operations until the file is loaded. Defaults to false.
+	///
+	/// If the file is already loaded, no blocking will occur.
+	/// If a file was loaded, and @@path was changed to a new file, no blocking will occur.
+	///
+	/// > [!WARNING] Blocking operations should be used carefully to avoid stutters and other performance
+	/// > degradations. Blocking means that your interface **WILL NOT FUNCTION** during the call.
+	/// >
+	/// > **We recommend you use a blocking load ONLY for files loaded before the windows of your shell
+	/// > are loaded, which happens after `Component.onCompleted` runs for the root component of your shell.**
+	/// >
+	/// > The most reasonable use case would be to load things like configuration files that the program
+	/// > must have available.
+	QSDOC_PROPERTY_OVERRIDE(bool blockLoading READ blockLoading WRITE setBlockLoading NOTIFY blockLoadingChanged);
+	/// If @@text() and @@data() should block all operations while a file loads. Defaults to false.
+	///
+	/// This is nearly identical to @@blockLoading, but will additionally block when
+	/// a file is loaded and @@path changes.
+	///
+	/// > [!WARNING] We cannot think of a valid use case for this.
+	/// > You almost definitely want @@blockLoading.
+	QSDOC_PROPERTY_OVERRIDE(bool blockAllReads READ blockAllReads WRITE setBlockAllReads NOTIFY blockAllReadsChanged);
+	/// If true (default false), all calls to @@setText() or @@setData() will block the
+	/// UI thread until the write succeeds or fails.
+	///
+	/// > [!WARNING] Blocking operations should be used carefully to avoid stutters and other performance
+	/// > degradations. Blocking means that your interface **WILL NOT FUNCTION** during the call.
+	Q_PROPERTY(bool blockWrites READ default WRITE default NOTIFY blockWritesChanged BINDABLE bindableBlockWrites);
+	/// If true (default), all calls to @@setText() or @@setData() will be performed atomically,
+	/// meaning if the write fails for any reason, the file will not be modified.
+	///
+	/// > [!NOTE] This works by creating another file with the desired content, and renaming
+	/// > it over the existing file if successful.
+	Q_PROPERTY(bool atomicWrites READ default WRITE default NOTIFY blockWritesChanged BINDABLE bindableAtomicWrites);
+	/// If true (default), read or write errors will be printed to the quickshell logs.
+	/// If false, all known errors will not be printed.
+	QSDOC_PROPERTY_OVERRIDE(bool printErrors READ default WRITE default NOTIFY printErrorsChanged);
+	/// If true (defaule false), @@fileChanged() will be called whenever the content of the file
+	/// changes on disk, including when @@setText() or @@setData() are used.
+	///
+	/// > [!NOTE] You can reload the file's content whenever it changes on disk like so:
+	/// > ```qml
+	/// > FileView {
+	/// >   // ...
+	/// >   watchChanges: true
+	/// >   onFileChanged: this.reload()
+	/// > }
+	/// > ```
+	Q_PROPERTY(bool watchChanges READ default WRITE default NOTIFY watchChangesChanged BINDABLE bindableWatchChanges);
+	/// In addition to directly reading/writing the file as text, *adapters* can be used to
+	/// expose a file's content in new ways.
+	///
+	/// An adapter will automatically be given the loaded file's content.
+	/// Its state may be saved with @@writeAdapter().
+	///
+	/// Currently the only adapter is @@JsonAdapter.
+	Q_PROPERTY(FileViewAdapter* adapter READ adapter WRITE setAdapter NOTIFY adapterChanged);
+
+	QSDOC_HIDE Q_PROPERTY(QString __path READ path WRITE setPath NOTIFY pathChanged);
+	QSDOC_HIDE Q_PROPERTY(QString __text READ text NOTIFY internalTextChanged);
+	QSDOC_HIDE Q_PROPERTY(QByteArray __data READ data NOTIFY internalDataChanged);
+	QSDOC_HIDE Q_PROPERTY(bool __preload READ shouldPreload WRITE setPreload NOTIFY preloadChanged);
+	/// If a file is currently loaded, which may or may not be the one currently specified by @@path.
+	///
+	/// > [!INFO] If a file is loaded, @@path is changed, and a new file is loaded,
+	/// > this property will stay true the whole time.
+	/// > If @@path is set to an empty string to unload the file it will become false.
+	Q_PROPERTY(bool loaded READ isLoadedOrAsync NOTIFY loadedOrAsyncChanged);
+	QSDOC_HIDE Q_PROPERTY(bool __blockLoading READ blockLoading WRITE setBlockLoading NOTIFY blockLoadingChanged);
+	QSDOC_HIDE Q_PROPERTY(bool __blockAllReads READ blockAllReads WRITE setBlockAllReads NOTIFY blockAllReadsChanged);
+	QSDOC_HIDE Q_PROPERTY(bool __printErrors READ default WRITE default NOTIFY printErrorsChanged BINDABLE bindablePrintErrors);
+	// clang-format on
+	Q_CLASSINFO("DefaultProperty", "adapter");
+	QML_NAMED_ELEMENT(FileViewInternal);
+	QSDOC_NAMED_ELEMENT(FileView);
+
+public:
+	explicit FileView(QObject* parent = nullptr): QObject(parent) {}
+	~FileView() override;
+	Q_DISABLE_COPY_MOVE(FileView);
+
+	/// Returns the data of the file specified by @@path as text.
+	///
+	/// If @@blockAllReads is true, all changes to @@path will cause the program to block
+	/// when this function is called.
+	///
+	/// If @@blockLoading is true, reading this property before the file has been loaded
+	/// will block, but changing @@path or calling @@reload() will return the old data
+	/// until the load completes.
+	///
+	/// If neither is true, an empty string will be returned if no file is loaded,
+	/// otherwise it will behave as in the case above.
+	///
+	/// > [!INFO] Due to technical limitations, @@text() could not be a property,
+	/// > however you can treat it like a property, it will trigger property updates
+	/// > as a property would, and the signal `textChanged()` is present.
+	//@ Q_INVOKABLE QString text();
+	/// Returns the data of the file specified by @@path as an [ArrayBuffer].
+	///
+	/// If @@blockAllReads is true, all changes to @@path will cause the program to block
+	/// when this function is called.
+	///
+	/// If @@blockLoading is true, reading this property before the file has been loaded
+	/// will block, but changing @@path or calling @@reload() will return the old data
+	/// until the load completes.
+	///
+	/// If neither is true, an empty buffer will be returned if no file is loaded,
+	/// otherwise it will behave as in the case above.
+	///
+	/// > [!INFO] Due to technical limitations, @@data() could not be a property,
+	/// > however you can treat it like a property, it will trigger property updates
+	/// > as a property would, and the signal `dataChanged()` is present.
+	///
+	/// [ArrayBuffer]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer
+	//@ Q_INVOKABLE QByteArray data();
+
+	/// Block all operations until the currently running load completes.
+	///
+	/// > [!WARNING] See @@blockLoading for an explanation and warning about blocking.
+	Q_INVOKABLE bool waitForJob();
+	/// Unload the loaded file and reload it, usually in response to changes.
+	///
+	/// This will not block if @@blockLoading is set, only if @@blockAllReads is true.
+	/// It acts the same as changing @@path to a new file, except loading the same file.
+	Q_INVOKABLE void reload();
+	/// Write the content of the current @@adapter to the selected file.
+	Q_INVOKABLE void writeAdapter();
+
+	[[nodiscard]] QString path() const;
+	void setPath(const QString& path);
+
+	[[nodiscard]] QByteArray data();
+	[[nodiscard]] QString text();
+
+	// These generally should not be called prior to component completion, making it safe not to force
+	// property resolution.
+
+	/// Sets the content of the file specified by @@path as an [ArrayBuffer].
+	///
+	/// @@atomicWrites and @@blockWrites affect the behavior of this function.
+	///
+	/// @@saved(s) or @@saveFailed(s) will be emitted on completion.
+	Q_INVOKABLE void setData(const QByteArray& data);
+	/// Sets the content of the file specified by @@path as text.
+	///
+	/// @@atomicWrites and @@blockWrites affect the behavior of this function.
+	///
+	/// @@saved(s) or @@saveFailed(s) will be emitted on completion.
+	///
+	/// [ArrayBuffer]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer
+	Q_INVOKABLE void setText(const QString& text);
+
+	// Const bindables functions silently do nothing on setValue.
+	[[nodiscard]] QBindable<bool> bindableBlockWrites() { return &this->bBlockWrites; }
+	[[nodiscard]] QBindable<bool> bindableAtomicWrites() { return &this->bAtomicWrites; }
+
+	[[nodiscard]] QBindable<bool> bindablePrintErrors() { return &this->bPrintErrors; }
+	[[nodiscard]] QBindable<bool> bindableWatchChanges() { return &this->bWatchChanges; }
+
+	[[nodiscard]] FileViewAdapter* adapter() const;
+	void setAdapter(FileViewAdapter* adapter);
+
+signals:
+	/// Emitted if the file was loaded successfully.
+	void loaded();
+	/// Emitted if the file failed to load.
+	void loadFailed(qs::io::FileViewError::Enum error);
+	/// Emitted if the file was saved successfully.
+	void saved();
+	/// Emitted if the file failed to save.
+	void saveFailed(qs::io::FileViewError::Enum error);
+	/// Emitted if the file changes on disk and @@watchChanges is true.
+	void fileChanged();
+	/// Emitted when the active @@adapter$'s data is changed.
+	void adapterUpdated();
+
+	void pathChanged();
+	QSDOC_HIDE void internalTextChanged();
+	QSDOC_HIDE void internalDataChanged();
+	QSDOC_HIDE void textChanged();
+	QSDOC_HIDE void dataChanged();
+	void preloadChanged();
+	void loadedOrAsyncChanged();
+	void blockLoadingChanged();
+	void blockAllReadsChanged();
+	void blockWritesChanged();
+	void atomicWritesChanged();
+	void printErrorsChanged();
+	void watchChangesChanged();
+	void adapterChanged();
+
+private slots:
+	void operationFinished();
+	void onAdapterDestroyed();
+
+private:
+	void loadAsync(bool doStringConversion);
+	void saveAsync();
+	void cancelAsync();
+	void loadSync();
+	void saveSync();
+	void updateState(FileViewState& newState);
+	void updatePath();
+	void updateWatchedFiles();
+	void onWatchedFileChanged();
+	void onWatchedDirectoryChanged();
+
+	[[nodiscard]] bool shouldBlockRead() const;
+	[[nodiscard]] FileViewReader* liveReader() const;
+	[[nodiscard]] FileViewWriter* liveWriter() const;
+	[[nodiscard]] const FileViewData& writeCmpData() const;
+
+	FileViewState state;
+	FileViewData writeData;
+	FileViewOperation* liveOperation = nullptr;
+	QString pathInFlight;
+
+	QString targetPath;
+	bool mAsyncUpdate = true;
+	bool mWritable = false;
+	bool mCreate = false;
+	bool mPreload = true;
+	bool mPrepared = false;
+	bool mLoadedOrAsync = false;
+	bool mBlockLoading = false;
+	bool mBlockAllReads = false;
+
+	FileViewAdapter* mAdapter = nullptr;
+	QFileSystemWatcher* watcher = nullptr;
+
+	GuardedEmitter<&FileView::internalTextChanged> textChangedEmitter;
+	GuardedEmitter<&FileView::internalDataChanged> dataChangedEmitter;
+	void emitDataChanged();
+
+	DECLARE_PRIVATE_MEMBER(
+	    FileView,
+	    isLoadedOrAsync,
+	    setLoadedOrAsync,
+	    mLoadedOrAsync,
+	    loadedOrAsyncChanged
+	);
+
+public:
+	DECLARE_MEMBER_WITH_GET(FileView, shouldPreload, mPreload, preloadChanged);
+	DECLARE_MEMBER_WITH_GET(FileView, blockLoading, mBlockLoading, blockLoadingChanged);
+	DECLARE_MEMBER_WITH_GET(FileView, blockAllReads, mBlockAllReads, blockAllReadsChanged);
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(FileView, bool, bBlockWrites, &FileView::blockWritesChanged);
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(FileView, bool, bAtomicWrites, true, &FileView::atomicWritesChanged);
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(FileView, bool, bPrintErrors, true, &FileView::printErrorsChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(FileView, bool, bWatchChanges, &FileView::watchChangesChanged);
+	// clang-format on
+
+	QS_BINDING_SUBSCRIBE_METHOD(FileView, bWatchChanges, updateWatchedFiles, onValueChanged);
+
+	void setPreload(bool preload);
+	void setBlockLoading(bool blockLoading);
+	void setBlockAllReads(bool blockAllReads);
+};
+
+/// See @@FileView.adapter.
+class FileViewAdapter: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_UNCREATABLE("");
+
+public:
+	void setFileView(FileView* fileView);
+	virtual void deserializeAdapter(const QByteArray& data) = 0;
+	[[nodiscard]] virtual QByteArray serializeAdapter() = 0;
+
+signals:
+	/// This signal is fired when data in the adapter changes, and triggers @@FileView.adapterUpdated(s).
+	void adapterUpdated();
+
+private slots:
+	void onDataChanged();
+
+protected:
+	FileView* mFileView = nullptr;
+};
+
+} // namespace qs::io
diff --git a/src/io/init.cpp b/src/io/init.cpp
deleted file mode 100644
index ea2bba7b..00000000
--- a/src/io/init.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "../core/plugin.hpp"
-#include "process.hpp"
-
-namespace {
-
-class IoPlugin: public QuickshellPlugin {
-	void onReload() override { DisownedProcessContext::destroyInstance(); }
-};
-
-QS_REGISTER_PLUGIN(IoPlugin);
-
-} // namespace
diff --git a/src/io/ipc.cpp b/src/io/ipc.cpp
new file mode 100644
index 00000000..768299ed
--- /dev/null
+++ b/src/io/ipc.cpp
@@ -0,0 +1,207 @@
+#include "ipc.hpp"
+#include <cstring>
+#include <utility>
+
+#include <qcolor.h>
+#include <qmetatype.h>
+#include <qobjectdefs.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+namespace qs::io::ipc {
+
+const VoidIpcType VoidIpcType::INSTANCE {};
+const StringIpcType StringIpcType::INSTANCE {};
+const IntIpcType IntIpcType::INSTANCE {};
+const BoolIpcType BoolIpcType::INSTANCE {};
+const DoubleIpcType DoubleIpcType::INSTANCE {};
+const ColorIpcType ColorIpcType::INSTANCE {};
+
+void* IpcType::copyStorage(const void* data) const {
+	auto* storage = this->createStorage();
+	memcpy(storage, data, this->size());
+	return storage;
+}
+
+const IpcType* IpcType::ipcType(const QMetaType& metaType) {
+	if (metaType.id() == QMetaType::Void) return &VoidIpcType::INSTANCE;
+	if (metaType.id() == QMetaType::QString) return &StringIpcType::INSTANCE;
+	if (metaType.id() == QMetaType::Int) return &IntIpcType::INSTANCE;
+	if (metaType.id() == QMetaType::Bool) return &BoolIpcType::INSTANCE;
+	if (metaType.id() == QMetaType::Double) return &DoubleIpcType::INSTANCE;
+	if (metaType.id() == QMetaType::QColor) return &ColorIpcType::INSTANCE;
+	return nullptr;
+}
+
+IpcTypeSlot::IpcTypeSlot(IpcTypeSlot&& other) noexcept { *this = std::move(other); }
+
+IpcTypeSlot& IpcTypeSlot::operator=(IpcTypeSlot&& other) noexcept {
+	this->mType = other.mType;
+	this->storage = other.storage;
+	other.mType = nullptr;
+	other.storage = nullptr;
+	return *this;
+}
+
+IpcTypeSlot::~IpcTypeSlot() { this->replace(nullptr); }
+
+const IpcType* IpcTypeSlot::type() const { return this->mType; }
+
+void* IpcTypeSlot::get() {
+	if (this->storage == nullptr) {
+		this->storage = this->mType->createStorage();
+	}
+
+	return this->storage;
+}
+
+QGenericArgument IpcTypeSlot::asGenericArgument() {
+	if (this->mType) {
+		return QGenericArgument(this->mType->genericArgumentName(), this->get());
+	} else {
+		return QGenericArgument();
+	}
+}
+
+QGenericReturnArgument IpcTypeSlot::asGenericReturnArgument() {
+	if (this->mType) {
+		return QGenericReturnArgument(this->mType->genericArgumentName(), this->get());
+	} else {
+		return QGenericReturnArgument();
+	}
+}
+
+void IpcTypeSlot::replace(void* value) {
+	if (this->storage != nullptr) {
+		this->mType->destroyStorage(this->storage);
+	}
+
+	this->storage = value;
+}
+
+void IpcTypeSlot::replace(const QVariant& value) {
+	this->replace(this->mType->copyStorage(value.constData()));
+}
+
+const char* VoidIpcType::name() const { return "void"; }
+const char* VoidIpcType::genericArgumentName() const { return "void"; }
+qsizetype VoidIpcType::size() const { return 0; }
+
+// string
+const char* StringIpcType::name() const { return "string"; }
+const char* StringIpcType::genericArgumentName() const { return "QString"; }
+qsizetype StringIpcType::size() const { return sizeof(QString); }
+void* StringIpcType::fromString(const QString& string) const { return new QString(string); }
+QString StringIpcType::toString(void* slot) const { return *static_cast<QString*>(slot); }
+void* StringIpcType::createStorage() const { return new QString(); }
+void StringIpcType::destroyStorage(void* slot) const { delete static_cast<QString*>(slot); }
+
+// int
+const char* IntIpcType::name() const { return "int"; }
+const char* IntIpcType::genericArgumentName() const { return "int"; }
+qsizetype IntIpcType::size() const { return sizeof(int); }
+
+void* IntIpcType::fromString(const QString& string) const {
+	auto ok = false;
+	auto v = string.toInt(&ok);
+
+	return ok ? new int(v) : nullptr;
+}
+
+QString IntIpcType::toString(void* slot) const { return QString::number(*static_cast<int*>(slot)); }
+
+void* IntIpcType::createStorage() const { return new int(); }
+void IntIpcType::destroyStorage(void* slot) const { delete static_cast<int*>(slot); }
+
+// bool
+const char* BoolIpcType::name() const { return "bool"; }
+const char* BoolIpcType::genericArgumentName() const { return "bool"; }
+qsizetype BoolIpcType::size() const { return sizeof(bool); }
+
+void* BoolIpcType::fromString(const QString& string) const {
+	if (string == "true") return new bool(true);
+	if (string == "false") return new bool(false);
+
+	auto isInt = false;
+	auto iv = string.toInt(&isInt);
+
+	return isInt ? new bool(iv != 0) : nullptr;
+}
+
+QString BoolIpcType::toString(void* slot) const {
+	return *static_cast<bool*>(slot) ? "true" : "false";
+}
+
+void* BoolIpcType::createStorage() const { return new bool(); }
+void BoolIpcType::destroyStorage(void* slot) const { delete static_cast<bool*>(slot); }
+
+// double
+const char* DoubleIpcType::name() const { return "real"; }
+const char* DoubleIpcType::genericArgumentName() const { return "double"; }
+qsizetype DoubleIpcType::size() const { return sizeof(double); }
+
+void* DoubleIpcType::fromString(const QString& string) const {
+	auto ok = false;
+	auto v = string.toDouble(&ok);
+
+	return ok ? new double(v) : nullptr;
+}
+
+QString DoubleIpcType::toString(void* slot) const {
+	return QString::number(*static_cast<double*>(slot));
+}
+
+void* DoubleIpcType::createStorage() const { return new double(); }
+void DoubleIpcType::destroyStorage(void* slot) const { delete static_cast<double*>(slot); }
+
+// color
+const char* ColorIpcType::name() const { return "color"; }
+const char* ColorIpcType::genericArgumentName() const { return "QColor"; }
+qsizetype ColorIpcType::size() const { return sizeof(QColor); }
+
+void* ColorIpcType::fromString(const QString& string) const {
+	auto color = QColor::fromString(string);
+
+	if (!color.isValid() && !string.startsWith('#')) {
+		color = QColor::fromString('#' % string);
+	}
+
+	return color.isValid() ? new QColor(color) : nullptr;
+}
+
+QString ColorIpcType::toString(void* slot) const {
+	return static_cast<QColor*>(slot)->name(QColor::HexArgb);
+}
+
+void* ColorIpcType::createStorage() const { return new bool(); }
+void ColorIpcType::destroyStorage(void* slot) const { delete static_cast<bool*>(slot); }
+
+QString WireFunctionDefinition::toString() const {
+	QString paramString;
+	for (const auto& [name, type]: this->arguments) {
+		if (!paramString.isEmpty()) paramString += ", ";
+		paramString += name % ": " % type;
+	}
+
+	return "function " % this->name % '(' % paramString % "): " % this->returnType;
+}
+
+QString WirePropertyDefinition::toString() const {
+	return "property " % this->name % ": " % this->type;
+}
+
+QString WireTargetDefinition::toString() const {
+	QString accum = "target " % this->name;
+
+	for (const auto& func: this->functions) {
+		accum += "\n  " % func.toString();
+	}
+
+	for (const auto& prop: this->properties) {
+		accum += "\n  " % prop.toString();
+	}
+
+	return accum;
+}
+
+} // namespace qs::io::ipc
diff --git a/src/io/ipc.hpp b/src/io/ipc.hpp
new file mode 100644
index 00000000..d2b865a2
--- /dev/null
+++ b/src/io/ipc.hpp
@@ -0,0 +1,159 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qobjectdefs.h>
+#include <qtclasshelpermacros.h>
+#include <qtypes.h>
+
+#include "../ipc/ipc.hpp"
+
+namespace qs::io::ipc {
+
+class IpcTypeSlot;
+
+class IpcType {
+public:
+	IpcType() = default;
+	virtual ~IpcType() = default;
+	IpcType(const IpcType&) = default;
+	IpcType(IpcType&&) = default;
+	IpcType& operator=(const IpcType&) = default;
+	IpcType& operator=(IpcType&&) = default;
+
+	[[nodiscard]] virtual const char* name() const = 0;
+	[[nodiscard]] virtual const char* genericArgumentName() const = 0;
+	[[nodiscard]] virtual qsizetype size() const = 0;
+	[[nodiscard]] virtual void* fromString(const QString& /*string*/) const { return nullptr; }
+	[[nodiscard]] virtual QString toString(void* /*slot*/) const { return ""; }
+	[[nodiscard]] virtual void* createStorage() const { return nullptr; }
+	virtual void destroyStorage(void* /*slot*/) const {}
+	void* copyStorage(const void* data) const;
+
+	static const IpcType* ipcType(const QMetaType& metaType);
+};
+
+class IpcTypeSlot {
+public:
+	explicit IpcTypeSlot(const IpcType* type = nullptr): mType(type) {}
+	~IpcTypeSlot();
+	Q_DISABLE_COPY(IpcTypeSlot);
+	IpcTypeSlot(IpcTypeSlot&& other) noexcept;
+	IpcTypeSlot& operator=(IpcTypeSlot&& other) noexcept;
+
+	[[nodiscard]] const IpcType* type() const;
+	[[nodiscard]] void* get();
+	[[nodiscard]] QGenericArgument asGenericArgument();
+	[[nodiscard]] QGenericReturnArgument asGenericReturnArgument();
+
+	void replace(void* value);
+	void replace(const QVariant& value);
+
+private:
+	const IpcType* mType = nullptr;
+	void* storage = nullptr;
+};
+
+class VoidIpcType: public IpcType {
+public:
+	[[nodiscard]] const char* name() const override;
+	[[nodiscard]] const char* genericArgumentName() const override;
+	[[nodiscard]] qsizetype size() const override;
+
+	static const VoidIpcType INSTANCE;
+};
+
+class StringIpcType: public IpcType {
+public:
+	[[nodiscard]] const char* name() const override;
+	[[nodiscard]] const char* genericArgumentName() const override;
+	[[nodiscard]] qsizetype size() const override;
+	[[nodiscard]] void* fromString(const QString& string) const override;
+	[[nodiscard]] QString toString(void* slot) const override;
+	[[nodiscard]] void* createStorage() const override;
+	void destroyStorage(void* slot) const override;
+
+	static const StringIpcType INSTANCE;
+};
+
+class IntIpcType: public IpcType {
+public:
+	[[nodiscard]] const char* name() const override;
+	[[nodiscard]] const char* genericArgumentName() const override;
+	[[nodiscard]] qsizetype size() const override;
+	[[nodiscard]] void* fromString(const QString& string) const override;
+	[[nodiscard]] QString toString(void* slot) const override;
+	[[nodiscard]] void* createStorage() const override;
+	void destroyStorage(void* slot) const override;
+
+	static const IntIpcType INSTANCE;
+};
+
+class BoolIpcType: public IpcType {
+public:
+	[[nodiscard]] const char* name() const override;
+	[[nodiscard]] const char* genericArgumentName() const override;
+	[[nodiscard]] qsizetype size() const override;
+	[[nodiscard]] void* fromString(const QString& string) const override;
+	[[nodiscard]] QString toString(void* slot) const override;
+	[[nodiscard]] void* createStorage() const override;
+	void destroyStorage(void* slot) const override;
+
+	static const BoolIpcType INSTANCE;
+};
+
+class DoubleIpcType: public IpcType {
+public:
+	[[nodiscard]] const char* name() const override;
+	[[nodiscard]] const char* genericArgumentName() const override;
+	[[nodiscard]] qsizetype size() const override;
+	[[nodiscard]] void* fromString(const QString& string) const override;
+	[[nodiscard]] QString toString(void* slot) const override;
+	[[nodiscard]] void* createStorage() const override;
+	void destroyStorage(void* slot) const override;
+
+	static const DoubleIpcType INSTANCE;
+};
+
+class ColorIpcType: public IpcType {
+public:
+	[[nodiscard]] const char* name() const override;
+	[[nodiscard]] const char* genericArgumentName() const override;
+	[[nodiscard]] qsizetype size() const override;
+	[[nodiscard]] void* fromString(const QString& string) const override;
+	[[nodiscard]] QString toString(void* slot) const override;
+	[[nodiscard]] void* createStorage() const override;
+	void destroyStorage(void* slot) const override;
+
+	static const ColorIpcType INSTANCE;
+};
+
+struct WireFunctionDefinition {
+	QString name;
+	QString returnType;
+	QVector<QPair<QString, QString>> arguments;
+
+	[[nodiscard]] QString toString() const;
+};
+
+DEFINE_SIMPLE_DATASTREAM_OPS(WireFunctionDefinition, data.name, data.returnType, data.arguments);
+
+struct WirePropertyDefinition {
+	QString name;
+	QString type;
+
+	[[nodiscard]] QString toString() const;
+};
+
+DEFINE_SIMPLE_DATASTREAM_OPS(WirePropertyDefinition, data.name, data.type);
+
+struct WireTargetDefinition {
+	QString name;
+	QVector<WireFunctionDefinition> functions;
+	QVector<WirePropertyDefinition> properties;
+
+	[[nodiscard]] QString toString() const;
+};
+
+DEFINE_SIMPLE_DATASTREAM_OPS(WireTargetDefinition, data.name, data.functions, data.properties);
+
+} // namespace qs::io::ipc
diff --git a/src/io/ipccomm.cpp b/src/io/ipccomm.cpp
new file mode 100644
index 00000000..7203a307
--- /dev/null
+++ b/src/io/ipccomm.cpp
@@ -0,0 +1,317 @@
+#include "ipccomm.hpp"
+#include <cstdio>
+#include <variant>
+
+#include <qcontainerfwd.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qtextstream.h>
+#include <qtypes.h>
+
+#include "../core/generation.hpp"
+#include "../core/logging.hpp"
+#include "../ipc/ipc.hpp"
+#include "../ipc/ipccommand.hpp"
+#include "ipc.hpp"
+#include "ipchandler.hpp"
+
+using namespace qs::ipc;
+
+namespace qs::io::ipc::comm {
+
+struct NoCurrentGeneration: std::monostate {};
+struct TargetNotFound: std::monostate {};
+struct EntryNotFound: std::monostate {};
+
+using QueryResponse = std::variant<
+    std::monostate,
+    NoCurrentGeneration,
+    TargetNotFound,
+    EntryNotFound,
+    QVector<WireTargetDefinition>,
+    WireTargetDefinition,
+    WireFunctionDefinition,
+    WirePropertyDefinition>;
+
+void QueryMetadataCommand::exec(qs::ipc::IpcServerConnection* conn) const {
+	auto resp = conn->responseStream<QueryResponse>();
+
+	if (auto* generation = EngineGeneration::currentGeneration()) {
+		auto* registry = IpcHandlerRegistry::forGeneration(generation);
+
+		if (this->target.isEmpty()) {
+			resp << registry->wireTargets();
+		} else {
+			auto* handler = registry->findHandler(this->target);
+
+			if (handler) {
+				if (this->name.isEmpty()) {
+					resp << handler->wireDef();
+				} else {
+					auto* func = handler->findFunction(this->name);
+
+					if (func) {
+						resp << func->wireDef();
+						return;
+					}
+
+					auto* prop = handler->findProperty(this->name);
+
+					if (prop) {
+						resp << prop->wireDef();
+						return;
+					}
+
+					resp << EntryNotFound();
+				}
+			} else {
+				resp << TargetNotFound();
+			}
+		}
+	} else {
+		resp << NoCurrentGeneration();
+	}
+}
+
+int queryMetadata(IpcClient* client, const QString& target, const QString& name) {
+	client->sendMessage(IpcCommand(QueryMetadataCommand {.target = target, .name = name}));
+
+	QueryResponse slot;
+	if (!client->waitForResponse(slot)) return -1;
+
+	if (std::holds_alternative<QVector<WireTargetDefinition>>(slot)) {
+		const auto& targets = std::get<QVector<WireTargetDefinition>>(slot);
+
+		for (const auto& target: targets) {
+			qCInfo(logBare).noquote() << target.toString();
+		}
+
+		return 0;
+	} else if (std::holds_alternative<WireTargetDefinition>(slot)) {
+		qCInfo(logBare).noquote() << std::get<WireTargetDefinition>(slot).toString();
+	} else if (std::holds_alternative<WireFunctionDefinition>(slot)) {
+		qCInfo(logBare).noquote() << std::get<WireFunctionDefinition>(slot).toString();
+	} else if (std::holds_alternative<WirePropertyDefinition>(slot)) {
+		qCInfo(logBare).noquote() << std::get<WirePropertyDefinition>(slot).toString();
+	} else if (std::holds_alternative<TargetNotFound>(slot)) {
+		qCCritical(logBare) << "Target not found.";
+	} else if (std::holds_alternative<EntryNotFound>(slot)) {
+		qCCritical(logBare) << "Function not found.";
+	} else if (std::holds_alternative<NoCurrentGeneration>(slot)) {
+		qCCritical(logBare) << "Not ready to accept queries yet.";
+	} else {
+		qCCritical(logIpc) << "Received invalid IPC response from" << client;
+	}
+
+	return -1;
+}
+
+struct ArgParseFailed {
+	WireFunctionDefinition definition;
+	bool isCountMismatch = false;
+	quint8 paramIndex = 0;
+};
+
+DEFINE_SIMPLE_DATASTREAM_OPS(
+    ArgParseFailed,
+    data.definition,
+    data.isCountMismatch,
+    data.paramIndex
+);
+
+struct Completed {
+	bool isVoid = false;
+	QString returnValue;
+};
+
+DEFINE_SIMPLE_DATASTREAM_OPS(Completed, data.isVoid, data.returnValue);
+
+using StringCallResponse = std::variant<
+    std::monostate,
+    NoCurrentGeneration,
+    TargetNotFound,
+    EntryNotFound,
+    ArgParseFailed,
+    Completed>;
+
+void StringCallCommand::exec(qs::ipc::IpcServerConnection* conn) const {
+	auto resp = conn->responseStream<StringCallResponse>();
+
+	if (auto* generation = EngineGeneration::currentGeneration()) {
+		auto* registry = IpcHandlerRegistry::forGeneration(generation);
+
+		auto* handler = registry->findHandler(this->target);
+		if (!handler) {
+			resp << TargetNotFound();
+			return;
+		}
+
+		auto* func = handler->findFunction(this->function);
+		if (!func) {
+			resp << EntryNotFound();
+			return;
+		}
+
+		if (func->argumentTypes.length() != this->arguments.length()) {
+			resp << ArgParseFailed {
+			    .definition = func->wireDef(),
+			    .isCountMismatch = true,
+			};
+
+			return;
+		}
+
+		auto storage = IpcCallStorage(*func);
+		for (auto i = 0; i < this->arguments.length(); i++) {
+			if (!storage.setArgumentStr(i, this->arguments.value(i))) {
+				resp << ArgParseFailed {
+				    .definition = func->wireDef(),
+				    .paramIndex = static_cast<quint8>(i),
+				};
+
+				return;
+			}
+		}
+
+		func->invoke(handler, storage);
+
+		resp << Completed {
+		    .isVoid = func->returnType == &VoidIpcType::INSTANCE,
+		    .returnValue = storage.getReturnStr(),
+		};
+	} else {
+		conn->respond(StringCallResponse(NoCurrentGeneration()));
+	}
+}
+
+int callFunction(
+    IpcClient* client,
+    const QString& target,
+    const QString& function,
+    const QVector<QString>& arguments
+) {
+	if (target.isEmpty()) {
+		qCCritical(logBare) << "Target required to send message.";
+		return -1;
+	} else if (function.isEmpty()) {
+		qCCritical(logBare) << "Function required to send message.";
+		return -1;
+	}
+
+	client->sendMessage(
+	    IpcCommand(StringCallCommand {.target = target, .function = function, .arguments = arguments})
+	);
+
+	StringCallResponse slot;
+	if (!client->waitForResponse(slot)) return -1;
+
+	if (std::holds_alternative<Completed>(slot)) {
+		auto& result = std::get<Completed>(slot);
+		if (!result.isVoid) {
+			QTextStream(stdout) << result.returnValue << Qt::endl;
+		}
+
+		return 0;
+	} else if (std::holds_alternative<ArgParseFailed>(slot)) {
+		auto& error = std::get<ArgParseFailed>(slot);
+
+		if (error.isCountMismatch) {
+			auto correctCount = error.definition.arguments.length();
+
+			qCCritical(logBare).nospace()
+			    << "Too " << (correctCount < arguments.length() ? "many" : "few")
+			    << " arguments provided (" << correctCount << " required but " << arguments.length()
+			    << " were provided.)";
+		} else {
+			const auto& provided = arguments.at(error.paramIndex);
+			const auto& definition = error.definition.arguments.at(error.paramIndex);
+
+			qCCritical(logBare).nospace()
+			    << "Unable to parse argument " << (error.paramIndex + 1) << " as " << definition.second
+			    << ". Provided argument: " << provided;
+		}
+
+		qCCritical(logBare).noquote() << "Function definition:" << error.definition.toString();
+	} else if (std::holds_alternative<TargetNotFound>(slot)) {
+		qCCritical(logBare) << "Target not found.";
+	} else if (std::holds_alternative<EntryNotFound>(slot)) {
+		qCCritical(logBare) << "Function not found.";
+	} else if (std::holds_alternative<NoCurrentGeneration>(slot)) {
+		qCCritical(logBare) << "Not ready to accept queries yet.";
+	} else {
+		qCCritical(logIpc) << "Received invalid IPC response from" << client;
+	}
+
+	return -1;
+}
+
+struct PropertyValue {
+	QString value;
+};
+
+DEFINE_SIMPLE_DATASTREAM_OPS(PropertyValue, data.value);
+
+using StringPropReadResponse =
+    std::variant<std::monostate, NoCurrentGeneration, TargetNotFound, EntryNotFound, PropertyValue>;
+
+void StringPropReadCommand::exec(qs::ipc::IpcServerConnection* conn) const {
+	auto resp = conn->responseStream<StringPropReadResponse>();
+
+	if (auto* generation = EngineGeneration::currentGeneration()) {
+		auto* registry = IpcHandlerRegistry::forGeneration(generation);
+
+		auto* handler = registry->findHandler(this->target);
+		if (!handler) {
+			resp << TargetNotFound();
+			return;
+		}
+
+		auto* prop = handler->findProperty(this->property);
+		if (!prop) {
+			resp << EntryNotFound();
+			return;
+		}
+
+		auto slot = IpcTypeSlot(prop->type);
+		prop->read(handler, slot);
+
+		resp << PropertyValue {
+		    .value = slot.type()->toString(slot.get()),
+		};
+	} else {
+		conn->respond(StringCallResponse(NoCurrentGeneration()));
+	}
+}
+
+int getProperty(IpcClient* client, const QString& target, const QString& property) {
+	if (target.isEmpty()) {
+		qCCritical(logBare) << "Target required to send message.";
+		return -1;
+	} else if (property.isEmpty()) {
+		qCCritical(logBare) << "Property required to send message.";
+		return -1;
+	}
+
+	client->sendMessage(IpcCommand(StringPropReadCommand {.target = target, .property = property}));
+
+	StringPropReadResponse slot;
+	if (!client->waitForResponse(slot)) return -1;
+
+	if (std::holds_alternative<PropertyValue>(slot)) {
+		auto& result = std::get<PropertyValue>(slot);
+		QTextStream(stdout) << result.value << Qt::endl;
+		return 0;
+	} else if (std::holds_alternative<TargetNotFound>(slot)) {
+		qCCritical(logBare) << "Target not found.";
+	} else if (std::holds_alternative<EntryNotFound>(slot)) {
+		qCCritical(logBare) << "Property not found.";
+	} else if (std::holds_alternative<NoCurrentGeneration>(slot)) {
+		qCCritical(logBare) << "Not ready to accept queries yet.";
+	} else {
+		qCCritical(logIpc) << "Received invalid IPC response from" << client;
+	}
+
+	return -1;
+}
+
+} // namespace qs::io::ipc::comm
diff --git a/src/io/ipccomm.hpp b/src/io/ipccomm.hpp
new file mode 100644
index 00000000..bc7dbf97
--- /dev/null
+++ b/src/io/ipccomm.hpp
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qflags.h>
+#include <qtypes.h>
+
+#include "../ipc/ipc.hpp"
+
+namespace qs::io::ipc::comm {
+
+struct QueryMetadataCommand {
+	QString target;
+	QString name;
+
+	void exec(qs::ipc::IpcServerConnection* conn) const;
+};
+
+DEFINE_SIMPLE_DATASTREAM_OPS(QueryMetadataCommand, data.target, data.name);
+
+struct StringCallCommand {
+	QString target;
+	QString function;
+	QVector<QString> arguments;
+
+	void exec(qs::ipc::IpcServerConnection* conn) const;
+};
+
+DEFINE_SIMPLE_DATASTREAM_OPS(StringCallCommand, data.target, data.function, data.arguments);
+
+void handleMsg(qs::ipc::IpcServerConnection* conn);
+int queryMetadata(qs::ipc::IpcClient* client, const QString& target, const QString& name);
+
+int callFunction(
+    qs::ipc::IpcClient* client,
+    const QString& target,
+    const QString& function,
+    const QVector<QString>& arguments
+);
+
+struct StringPropReadCommand {
+	QString target;
+	QString property;
+
+	void exec(qs::ipc::IpcServerConnection* conn) const;
+};
+
+DEFINE_SIMPLE_DATASTREAM_OPS(StringPropReadCommand, data.target, data.property);
+
+int getProperty(qs::ipc::IpcClient* client, const QString& target, const QString& property);
+
+} // namespace qs::io::ipc::comm
diff --git a/src/io/ipchandler.cpp b/src/io/ipchandler.cpp
new file mode 100644
index 00000000..5ffa0ad4
--- /dev/null
+++ b/src/io/ipchandler.cpp
@@ -0,0 +1,385 @@
+#include "ipchandler.hpp"
+#include <cstddef>
+
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qmetaobject.h>
+#include <qobject.h>
+#include <qobjectdefs.h>
+#include <qpair.h>
+#include <qqmlinfo.h>
+#include <qstringbuilder.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../core/generation.hpp"
+#include "../core/logcat.hpp"
+#include "ipc.hpp"
+
+namespace qs::io::ipc {
+
+namespace {
+QS_LOGGING_CATEGORY(logIpcHandler, "quickshell.ipchandler", QtWarningMsg)
+}
+
+bool IpcFunction::resolve(QString& error) {
+	if (this->method.parameterCount() > 10) {
+		error = "Due to technical limitations, IPC functions can only have 10 arguments.";
+		return false;
+	}
+
+	for (auto i = 0; i < this->method.parameterCount(); i++) {
+		const auto& metaType = this->method.parameterMetaType(i);
+		const auto* type = IpcType::ipcType(metaType);
+
+		if (type == nullptr) {
+			error = QString("Type of argument %1 (%2: %3) cannot be used across IPC.")
+			            .arg(i + 1)
+			            .arg(this->method.parameterNames().value(i))
+			            .arg(metaType.name());
+
+			return false;
+		}
+
+		this->argumentTypes.append(type);
+	}
+
+	const auto& metaType = this->method.returnMetaType();
+	const auto* type = IpcType::ipcType(metaType);
+
+	if (type == nullptr) {
+		// void and var get mixed by qml engine in return types
+		if (metaType.id() == QMetaType::QVariant) type = &VoidIpcType::INSTANCE;
+
+		if (type == nullptr) {
+			error = QString("Return type (%1) cannot be used across IPC.").arg(metaType.name());
+			return false;
+		}
+	}
+
+	this->returnType = type;
+
+	return true;
+}
+
+void IpcFunction::invoke(QObject* target, IpcCallStorage& storage) const {
+	auto getArg = [&](size_t i) {
+		return i < storage.argumentSlots.size() ? storage.argumentSlots.at(i).asGenericArgument()
+		                                        : QGenericArgument();
+	};
+
+	this->method.invoke(
+	    target,
+	    storage.returnSlot.asGenericReturnArgument(),
+	    getArg(0),
+	    getArg(1),
+	    getArg(2),
+	    getArg(3),
+	    getArg(4),
+	    getArg(5),
+	    getArg(6),
+	    getArg(7),
+	    getArg(8),
+	    getArg(9)
+	);
+}
+
+QString IpcFunction::toString() const {
+	QString paramString;
+	auto paramNames = this->method.parameterNames();
+	for (auto i = 0; i < this->argumentTypes.length(); i++) {
+		paramString += paramNames.value(i) % ": " % this->argumentTypes.value(i)->name();
+
+		if (i + 1 != this->argumentTypes.length()) {
+			paramString += ", ";
+		}
+	}
+
+	return "function " % this->method.name() % '(' % paramString % "): " % this->returnType->name();
+}
+
+WireFunctionDefinition IpcFunction::wireDef() const {
+	WireFunctionDefinition wire;
+	wire.name = this->method.name();
+	wire.returnType = this->returnType->name();
+
+	auto paramNames = this->method.parameterNames();
+	for (auto i = 0; i < this->argumentTypes.length(); i++) {
+		wire.arguments += qMakePair(paramNames.value(i), this->argumentTypes.value(i)->name());
+	}
+
+	return wire;
+}
+
+bool IpcProperty::resolve(QString& error) {
+	this->type = IpcType::ipcType(this->property.metaType());
+
+	if (!this->type) {
+		error = QString("Type %1 cannot be used across IPC.").arg(this->property.metaType().name());
+		return false;
+	}
+
+	return true;
+}
+
+void IpcProperty::read(QObject* target, IpcTypeSlot& slot) const {
+	slot.replace(this->property.read(target));
+}
+
+QString IpcProperty::toString() const {
+	return QString("property ") % this->property.name() % ": " % this->type->name();
+}
+
+WirePropertyDefinition IpcProperty::wireDef() const {
+	WirePropertyDefinition wire;
+	wire.name = this->property.name();
+	wire.type = this->type->name();
+	return wire;
+}
+
+IpcCallStorage::IpcCallStorage(const IpcFunction& function): returnSlot(function.returnType) {
+	for (const auto& arg: function.argumentTypes) {
+		this->argumentSlots.emplace_back(arg);
+	}
+}
+
+bool IpcCallStorage::setArgumentStr(size_t i, const QString& value) {
+	auto& slot = this->argumentSlots.at(i);
+
+	auto* data = slot.type()->fromString(value);
+	slot.replace(data);
+	return data != nullptr;
+}
+
+QString IpcCallStorage::getReturnStr() {
+	return this->returnSlot.type()->toString(this->returnSlot.get());
+}
+
+IpcHandler::~IpcHandler() {
+	if (this->registeredState.enabled) {
+		this->targetState.enabled = false;
+		this->updateRegistration(true);
+	}
+}
+
+void IpcHandler::onPostReload() {
+	const auto& smeta = IpcHandler::staticMetaObject;
+	const auto* meta = this->metaObject();
+
+	// Start at the first function following IpcHandler's slots,
+	// which should handle inheritance on the qml side.
+	for (auto i = smeta.methodCount(); i != meta->methodCount(); i++) {
+		const auto& method = meta->method(i);
+		if (method.methodType() != QMetaMethod::Slot) continue;
+
+		auto ipcFunc = IpcFunction(method);
+		QString error;
+
+		if (!ipcFunc.resolve(error)) {
+			qmlWarning(this).nospace().noquote()
+			    << "Error parsing function \"" << method.name() << "\": " << error;
+		} else {
+			this->functionMap.insert(method.name(), ipcFunc);
+		}
+	}
+
+	for (auto i = smeta.propertyCount(); i != meta->propertyCount(); i++) {
+		const auto& property = meta->property(i);
+		if (!property.isReadable() || !property.hasNotifySignal()) continue;
+
+		auto ipcProp = IpcProperty(property);
+		QString error;
+
+		if (!ipcProp.resolve(error)) {
+			qmlWarning(this).nospace().noquote()
+			    << "Error parsing property \"" << property.name() << "\": " << error;
+		} else {
+			this->propertyMap.insert(property.name(), ipcProp);
+		}
+	}
+
+	this->complete = true;
+	this->updateRegistration();
+
+	if (this->targetState.enabled && this->targetState.target.isEmpty()) {
+		qmlWarning(this) << "This IPC handler is enabled but no target is set. This means it is "
+		                    "effectively inoperable.";
+	}
+}
+
+IpcHandlerRegistry* IpcHandlerRegistry::forGeneration(EngineGeneration* generation) {
+	static const int key = 0;
+	auto* ext = generation->findExtension(&key);
+
+	if (!ext) {
+		ext = new IpcHandlerRegistry();
+		generation->registerExtension(&key, ext);
+		qCDebug(logIpcHandler) << "Created new IPC handler registry" << ext << "for" << generation;
+	}
+
+	return dynamic_cast<IpcHandlerRegistry*>(ext);
+}
+
+void IpcHandler::updateRegistration(bool destroying) {
+	if (!this->complete) return;
+
+	auto* generation = EngineGeneration::findObjectGeneration(this);
+
+	if (!generation) {
+		if (!destroying) {
+			qmlWarning(this) << "Unable to identify engine generation, cannot register.";
+		}
+
+		return;
+	}
+
+	auto* registry = IpcHandlerRegistry::forGeneration(generation);
+
+	if (this->registeredState.enabled) {
+		registry->deregisterHandler(this);
+		qCDebug(logIpcHandler) << "Deregistered" << this << "from registry" << registry;
+	}
+
+	if (this->targetState.enabled && !this->targetState.target.isEmpty()) {
+		registry->registerHandler(this);
+		qCDebug(logIpcHandler) << "Registered" << this << "to registry" << registry;
+	}
+}
+
+bool IpcHandler::enabled() const { return this->targetState.enabled; }
+
+void IpcHandler::setEnabled(bool enabled) {
+	if (enabled != this->targetState.enabled) {
+		this->targetState.enabled = enabled;
+		emit this->enabledChanged();
+		this->updateRegistration();
+	}
+}
+
+QString IpcHandler::target() const { return this->targetState.target; }
+
+void IpcHandler::setTarget(const QString& target) {
+	if (target != this->targetState.target) {
+		this->targetState.target = target;
+		emit this->targetChanged();
+		this->updateRegistration();
+	}
+}
+
+void IpcHandlerRegistry::registerHandler(IpcHandler* handler) {
+	// inserting a new vec if not present is the desired behavior
+	auto& targetVec = this->knownHandlers[handler->targetState.target];
+	targetVec.append(handler);
+
+	if (this->handlers.contains(handler->targetState.target)) {
+		qmlWarning(handler) << "Handler was registered but will not be used because another handler "
+		                       "is registered for target "
+		                    << handler->targetState.target;
+	} else {
+		this->handlers.insert(handler->targetState.target, handler);
+	}
+
+	handler->registeredState = handler->targetState;
+	handler->registeredState.enabled = true;
+}
+
+void IpcHandlerRegistry::deregisterHandler(IpcHandler* handler) {
+	auto& targetVec = this->knownHandlers[handler->registeredState.target];
+	targetVec.removeOne(handler);
+
+	if (this->handlers.value(handler->registeredState.target) == handler) {
+		if (targetVec.isEmpty()) {
+			this->handlers.remove(handler->registeredState.target);
+		} else {
+			this->handlers.insert(handler->registeredState.target, targetVec.first());
+		}
+	}
+
+	handler->registeredState = IpcHandler::RegistrationState(false);
+}
+
+QString IpcHandler::listMembers(qsizetype indent) {
+	auto indentStr = QString(indent, ' ');
+	QString accum;
+
+	for (const auto& func: this->functionMap.values()) {
+		if (!accum.isEmpty()) accum += '\n';
+		accum += indentStr % func.toString();
+	}
+
+	return accum;
+}
+
+WireTargetDefinition IpcHandler::wireDef() const {
+	WireTargetDefinition wire;
+	wire.name = this->registeredState.target;
+
+	for (const auto& func: this->functionMap.values()) {
+		wire.functions += func.wireDef();
+	}
+
+	for (const auto& prop: this->propertyMap.values()) {
+		wire.properties += prop.wireDef();
+	}
+
+	return wire;
+}
+
+QString IpcHandlerRegistry::listMembers(const QString& target, qsizetype indent) {
+	if (auto* handler = this->handlers.value(target)) {
+		return handler->listMembers(indent);
+	} else {
+		QString accum;
+
+		for (auto* handler: this->knownHandlers.value(target)) {
+			if (!accum.isEmpty()) accum += '\n';
+			accum += handler->listMembers(indent);
+		}
+
+		return accum;
+	}
+}
+
+QString IpcHandlerRegistry::listTargets(qsizetype indent) {
+	auto indentStr = QString(indent, ' ');
+	QString accum;
+
+	for (const auto& target: this->knownHandlers.keys()) {
+		if (!accum.isEmpty()) accum += '\n';
+		accum += indentStr % "Target " % target % '\n' % this->listMembers(target, indent + 2);
+	}
+
+	return accum;
+}
+
+IpcFunction* IpcHandler::findFunction(const QString& name) {
+	auto itr = this->functionMap.find(name);
+
+	if (itr == this->functionMap.end()) return nullptr;
+	else return &*itr;
+}
+
+IpcProperty* IpcHandler::findProperty(const QString& name) {
+	auto itr = this->propertyMap.find(name);
+
+	if (itr == this->propertyMap.end()) return nullptr;
+	else return &*itr;
+}
+
+IpcHandler* IpcHandlerRegistry::findHandler(const QString& target) {
+	return this->handlers.value(target);
+}
+
+QVector<WireTargetDefinition> IpcHandlerRegistry::wireTargets() const {
+	QVector<WireTargetDefinition> wire;
+
+	for (const auto* handler: this->handlers.values()) {
+		wire += handler->wireDef();
+	}
+
+	return wire;
+}
+
+} // namespace qs::io::ipc
diff --git a/src/io/ipchandler.hpp b/src/io/ipchandler.hpp
new file mode 100644
index 00000000..4c5d9bc1
--- /dev/null
+++ b/src/io/ipchandler.hpp
@@ -0,0 +1,230 @@
+#pragma once
+
+#include <cstddef>
+#include <vector>
+
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qhash.h>
+#include <qmetaobject.h>
+#include <qobject.h>
+#include <qobjectdefs.h>
+#include <qqmlintegration.h>
+#include <qqmlparserstatus.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+#include "../core/generation.hpp"
+#include "../core/reload.hpp"
+#include "ipc.hpp"
+
+namespace qs::io::ipc {
+
+class IpcCallStorage;
+
+class IpcFunction {
+public:
+	explicit IpcFunction(QMetaMethod method): method(method) {}
+
+	bool resolve(QString& error);
+	void invoke(QObject* target, IpcCallStorage& storage) const;
+
+	[[nodiscard]] QString toString() const;
+	[[nodiscard]] WireFunctionDefinition wireDef() const;
+
+	QMetaMethod method;
+	QVector<const IpcType*> argumentTypes;
+	const IpcType* returnType = nullptr;
+};
+
+class IpcCallStorage {
+public:
+	explicit IpcCallStorage(const IpcFunction& function);
+
+	bool setArgumentStr(size_t i, const QString& value);
+	[[nodiscard]] QString getReturnStr();
+
+private:
+	std::vector<IpcTypeSlot> argumentSlots;
+	IpcTypeSlot returnSlot;
+
+	friend class IpcFunction;
+};
+
+class IpcProperty {
+public:
+	explicit IpcProperty(QMetaProperty property): property(property) {}
+
+	bool resolve(QString& error);
+	void read(QObject* target, IpcTypeSlot& slot) const;
+
+	[[nodiscard]] QString toString() const;
+	[[nodiscard]] WirePropertyDefinition wireDef() const;
+
+	QMetaProperty property;
+	const IpcType* type = nullptr;
+};
+
+class IpcHandlerRegistry;
+
+///! Handler for IPC message calls.
+/// Each IpcHandler is registered into a per-instance map by its unique @@target.
+/// Functions and properties defined on the IpcHandler can be accessed via `qs ipc`.
+///
+/// #### Handler Functions
+/// IPC handler functions can be called by `qs ipc call` as long as they have at most 10
+/// arguments, and all argument types along with the return type are listed below.
+///
+/// **Argument and return types must be explicitly specified or they will not
+/// be registered.**
+///
+/// ##### Arguments
+/// - `string` will be passed to the parameter as is.
+/// - `int` will only accept parameters that can be parsed as an integer.
+/// - `bool` will only accept parameters that are "true", "false", or an integer,
+///   where 0 will be converted to false, and anything else to true.
+/// - `real` will only accept parameters that can be parsed as a number with
+///   or without a decimal.
+/// - `color` will accept [named colors] or hex strings (RGB, RRGGBB, AARRGGBB) with
+///   an optional `#` prefix.
+///
+/// [named colors]: https://doc.qt.io/qt-6/qml-color.html#svg-color-reference
+///
+/// ##### Return Type
+/// - `void` will return nothing.
+/// - `string` will be returned as is.
+/// - `int` will be converted to a string and returned.
+/// - `bool` will be converted to "true" or "false" and returned.
+/// - `real` will be converted to a string and returned.
+/// - `color` will be converted to a hex string in the form `#AARRGGBB` and returned.
+///
+/// #### Example
+/// The following example creates ipc functions to control and retrieve the appearance
+/// of a Rectangle.
+///
+/// ```qml
+/// FloatingWindow {
+///   Rectangle {
+///     id: rect
+///     anchors.centerIn: parent
+///     width: 100
+///     height: 100
+///     color: "red"
+///   }
+///
+///   IpcHandler {
+///     target: "rect"
+///
+///     function setColor(color: color): void { rect.color = color; }
+///     function getColor(): color { return rect.color; }
+///     function setAngle(angle: real): void { rect.rotation = angle; }
+///     function getAngle(): real { return rect.rotation; }
+///     function setRadius(radius: int): void { rect.radius = radius; }
+///     function getRadius(): int { return rect.radius; }
+///   }
+/// }
+/// ```
+/// The list of registered targets can be inspected using `qs ipc show`.
+/// ```sh
+/// $ qs ipc show
+/// target rect
+///   function setColor(color: color): void
+///   function getColor(): color
+///   function setAngle(angle: real): void
+///   function getAngle(): real
+///   function setRadius(radius: int): void
+///   function getRadius(): int
+/// ```
+///
+/// and then invoked using `qs ipc call`.
+/// ```sh
+/// $ qs ipc call rect setColor orange
+/// $ qs ipc call rect setAngle 40.5
+/// $ qs ipc call rect setRadius 30
+/// $ qs ipc call rect getColor
+/// #ffffa500
+/// $ qs ipc call rect getAngle
+/// 40.5
+/// $ qs ipc call rect getRadius
+/// 30
+/// ```
+///
+/// #### Properties
+/// Properties of an IpcHanlder can be read using `qs ipc prop get` as long as they are
+/// of an IPC compatible type. See the table above for compatible types.
+class IpcHandler: public PostReloadHook {
+	Q_OBJECT;
+	/// If the handler should be able to receive calls. Defaults to true.
+	Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged);
+	/// The target this handler should be accessible from.
+	/// Required and must be unique. May be changed at runtime.
+	Q_PROPERTY(QString target READ target WRITE setTarget NOTIFY targetChanged);
+	QML_ELEMENT;
+
+public:
+	explicit IpcHandler(QObject* parent = nullptr): PostReloadHook(parent) {}
+	~IpcHandler() override;
+	Q_DISABLE_COPY_MOVE(IpcHandler);
+
+	void onPostReload() override;
+
+	[[nodiscard]] bool enabled() const;
+	void setEnabled(bool enabled);
+
+	[[nodiscard]] QString target() const;
+	void setTarget(const QString& target);
+
+	QString listMembers(qsizetype indent);
+	[[nodiscard]] IpcFunction* findFunction(const QString& name);
+	[[nodiscard]] IpcProperty* findProperty(const QString& name);
+	[[nodiscard]] WireTargetDefinition wireDef() const;
+
+signals:
+	void enabledChanged();
+	void targetChanged();
+
+private slots:
+	//void handleIpcPropertyChange();
+
+private:
+	void updateRegistration(bool destroying = false);
+
+	struct RegistrationState {
+		explicit RegistrationState(bool enabled = false): enabled(enabled) {}
+
+		bool enabled = false;
+		QString target;
+	};
+
+	RegistrationState registeredState;
+	RegistrationState targetState {true};
+	bool complete = false;
+
+	QHash<QString, IpcFunction> functionMap;
+	QHash<QString, IpcProperty> propertyMap;
+
+	friend class IpcHandlerRegistry;
+};
+
+class IpcHandlerRegistry: public EngineGenerationExt {
+public:
+	static IpcHandlerRegistry* forGeneration(EngineGeneration* generation);
+
+	void registerHandler(IpcHandler* handler);
+	void deregisterHandler(IpcHandler* handler);
+
+	QString listMembers(const QString& target, qsizetype indent);
+	QString listTargets(qsizetype indent);
+
+	IpcHandler* findHandler(const QString& target);
+
+	[[nodiscard]] QVector<WireTargetDefinition> wireTargets() const;
+
+private:
+	QHash<QString, IpcHandler*> handlers;
+	QHash<QString, QVector<IpcHandler*>> knownHandlers;
+};
+
+} // namespace qs::io::ipc
diff --git a/src/io/jsonadapter.cpp b/src/io/jsonadapter.cpp
new file mode 100644
index 00000000..80ac0912
--- /dev/null
+++ b/src/io/jsonadapter.cpp
@@ -0,0 +1,262 @@
+#include "jsonadapter.hpp"
+
+#include <qcontainerfwd.h>
+#include <qjsonarray.h>
+#include <qjsondocument.h>
+#include <qjsonobject.h>
+#include <qjsonvalue.h>
+#include <qjsvalue.h>
+#include <qmetaobject.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qobjectdefs.h>
+#include <qqml.h>
+#include <qqmlengine.h>
+#include <qqmlinfo.h>
+#include <qqmllist.h>
+#include <qstringview.h>
+#include <qvariant.h>
+
+namespace qs::io {
+
+void JsonAdapter::componentComplete() { this->connectNotifiers(); }
+
+void JsonAdapter::deserializeAdapter(const QByteArray& data) {
+	if (data.isEmpty()) return;
+
+	// Importing this makes CI builds fail for some reason.
+	QJsonParseError error; // NOLINT (misc-include-cleaner)
+	auto json = QJsonDocument::fromJson(data, &error);
+
+	if (error.error != QJsonParseError::NoError) {
+		qmlWarning(this) << "Failed to deserialize json: " << error.errorString();
+		return;
+	}
+
+	if (!json.isObject()) {
+		qmlWarning(this) << "Failed to deserialize json: not an object";
+		return;
+	}
+
+	this->changesBlocked = true;
+	this->oldCreatedObjects = this->createdObjects;
+	this->createdObjects.clear();
+
+	this->deserializeRec(json.object(), this, &JsonAdapter::staticMetaObject);
+
+	for (auto* object: oldCreatedObjects) {
+		delete object; // FIXME: QMetaType::destroy?
+	}
+
+	this->oldCreatedObjects.clear();
+	this->changesBlocked = false;
+
+	this->connectNotifiers();
+}
+
+void JsonAdapter::connectNotifiers() {
+	auto notifySlot = JsonAdapter::staticMetaObject.indexOfSlot("onPropertyChanged()");
+	connectNotifiersRec(notifySlot, this, &JsonAdapter::staticMetaObject);
+}
+
+void JsonAdapter::connectNotifiersRec(int notifySlot, QObject* obj, const QMetaObject* base) {
+	const auto* metaObject = obj->metaObject();
+
+	for (auto i = base->propertyOffset(); i != metaObject->propertyCount(); i++) {
+		const auto prop = metaObject->property(i);
+
+		if (prop.isReadable() && prop.hasNotifySignal()) {
+			QMetaObject::connect(obj, prop.notifySignalIndex(), this, notifySlot, Qt::UniqueConnection);
+
+			auto val = prop.read(obj);
+			if (val.canView<JsonObject*>()) {
+				auto* pobj = prop.read(obj).view<JsonObject*>();
+				if (pobj) connectNotifiersRec(notifySlot, pobj, &JsonObject::staticMetaObject);
+			} else if (val.canConvert<QQmlListProperty<JsonObject>>()) {
+				auto listVal = val.value<QQmlListProperty<JsonObject>>();
+
+				auto len = listVal.count(&listVal);
+				for (auto i = 0; i != len; i++) {
+					auto* pobj = listVal.at(&listVal, i);
+
+					if (pobj) connectNotifiersRec(notifySlot, pobj, &JsonObject::staticMetaObject);
+				}
+			}
+		}
+	}
+}
+
+void JsonAdapter::onPropertyChanged() {
+	if (this->changesBlocked) return;
+
+	this->connectNotifiers();
+	this->adapterUpdated();
+}
+
+QByteArray JsonAdapter::serializeAdapter() {
+	return QJsonDocument(this->serializeRec(this, &JsonAdapter::staticMetaObject))
+	    .toJson(QJsonDocument::Indented);
+}
+
+QJsonObject JsonAdapter::serializeRec(const QObject* obj, const QMetaObject* base) const {
+	QJsonObject json;
+	const auto* metaObject = obj->metaObject();
+
+	for (auto i = base->propertyOffset(); i != metaObject->propertyCount(); i++) {
+		const auto prop = metaObject->property(i);
+
+		if (prop.isReadable() && prop.hasNotifySignal()) {
+			auto val = prop.read(obj);
+			if (val.canView<JsonObject*>()) {
+				auto* pobj = val.view<JsonObject*>();
+
+				if (pobj) {
+					json.insert(prop.name(), serializeRec(pobj, &JsonObject::staticMetaObject));
+				} else {
+					json.insert(prop.name(), QJsonValue::Null);
+				}
+			} else if (val.canConvert<QQmlListProperty<JsonObject>>()) {
+				QJsonArray array;
+				auto listVal = val.value<QQmlListProperty<JsonObject>>();
+
+				auto len = listVal.count(&listVal);
+				for (auto i = 0; i != len; i++) {
+					auto* pobj = listVal.at(&listVal, i);
+
+					if (pobj) {
+						array.push_back(serializeRec(pobj, &JsonObject::staticMetaObject));
+					} else {
+						array.push_back(QJsonValue::Null);
+					}
+				}
+
+				json.insert(prop.name(), array);
+			} else if (val.canConvert<QJSValue>()) {
+				auto variant = val.value<QJSValue>().toVariant();
+				auto jv = QJsonValue::fromVariant(variant);
+				json.insert(prop.name(), jv);
+			} else {
+				auto jv = QJsonValue::fromVariant(val);
+				json.insert(prop.name(), jv);
+			}
+		}
+	}
+
+	return json;
+}
+
+void JsonAdapter::deserializeRec(const QJsonObject& json, QObject* obj, const QMetaObject* base) {
+	const auto* metaObject = obj->metaObject();
+
+	for (auto i = base->propertyOffset(); i != metaObject->propertyCount(); i++) {
+		const auto prop = metaObject->property(i);
+		if (json.contains(prop.name())) {
+			auto jval = json.value(prop.name());
+
+			if (prop.metaType() == QMetaType::fromType<QVariant>()) {
+				auto variant = jval.toVariant();
+				auto oldValue = prop.read(this).value<QJSValue>();
+
+				// Calling prop.write with a new QJSValue will cause a property update
+				// even if content is identical.
+				if (jval.toVariant() != oldValue.toVariant()) {
+					auto jsValue = qmlEngine(this)->fromVariant<QJSValue>(jval.toVariant());
+					prop.write(this, QVariant::fromValue(jsValue));
+				}
+			} else if (QMetaType::canView(prop.metaType(), QMetaType::fromType<JsonObject*>())) {
+				// FIXME: This doesn't support creating descendants of JsonObject, as QMetaType.metaObject()
+				// returns null for QML types.
+
+				if (jval.isObject()) {
+					auto* currentValue = prop.read(obj).view<JsonObject*>();
+					auto isNew = currentValue == nullptr;
+
+					if (isNew) {
+						// metaObject->metaType removes the pointer
+						currentValue =
+						    static_cast<JsonObject*>(prop.metaType().metaObject()->metaType().create());
+
+						currentValue->setParent(this);
+						this->createdObjects.push_back(currentValue);
+					} else if (oldCreatedObjects.removeOne(currentValue)) {
+						createdObjects.push_back(currentValue);
+					}
+
+					this->deserializeRec(jval.toObject(), currentValue, &JsonObject::staticMetaObject);
+
+					if (isNew) prop.write(obj, QVariant::fromValue(currentValue));
+				} else if (jval.isNull()) {
+					prop.write(obj, QVariant::fromValue(nullptr));
+				} else {
+					qmlWarning(this) << "Failed to deserialize property " << prop.name() << " as object. Got "
+					                 << jval.toVariant().typeName();
+				}
+			} else if (QMetaType::canConvert(
+			               prop.metaType(),
+			               QMetaType::fromType<QQmlListProperty<JsonObject>>()
+			           ))
+			{
+				auto pval = prop.read(this);
+
+				if (pval.canConvert<QQmlListProperty<JsonObject>>()) {
+					auto lp = pval.value<QQmlListProperty<JsonObject>>();
+					auto array = jval.toArray();
+					auto lpCount = lp.count(&lp);
+
+					auto i = 0;
+					for (; i != array.count(); i++) {
+						JsonObject* currentValue = nullptr;
+						auto isNew = i >= lpCount;
+
+						const auto& jsonValue = array.at(i);
+						if (jsonValue.isObject()) {
+							if (isNew) {
+								currentValue = lp.at(&lp, i);
+								if (oldCreatedObjects.removeOne(currentValue)) {
+									createdObjects.push_back(currentValue);
+								}
+							} else {
+								// FIXME: should be the type inside the QQmlListProperty but how can we get that?
+								currentValue = static_cast<JsonObject*>(QMetaType::fromType<JsonObject>().create());
+								currentValue->setParent(this);
+								this->createdObjects.push_back(currentValue);
+							}
+
+							this->deserializeRec(
+							    jsonValue.toObject(),
+							    currentValue,
+							    &JsonObject::staticMetaObject
+							);
+						} else if (!jsonValue.isNull()) {
+							qmlWarning(this) << "Failed to deserialize property" << prop.name()
+							                 << ": Member of object array is not an object: "
+							                 << jsonValue.toVariant().typeName();
+						}
+
+						if (isNew) {
+							lp.append(&lp, currentValue);
+						}
+					}
+
+					for (; i < lpCount; i++) {
+						lp.removeLast(&lp);
+					}
+				} else {
+					qmlWarning(this) << "Failed to deserialize property " << prop.name()
+					                 << ": property is a list<JsonObject> but contains null.";
+				}
+			} else {
+				auto variant = jval.toVariant();
+
+				if (variant.convert(prop.metaType())) {
+					prop.write(obj, variant);
+				} else {
+					qmlWarning(this) << "Failed to deserialize property " << prop.name() << ": expected "
+					                 << prop.metaType().name() << " but got " << jval.toVariant().typeName();
+				}
+			}
+		}
+	}
+}
+
+} // namespace qs::io
diff --git a/src/io/jsonadapter.hpp b/src/io/jsonadapter.hpp
new file mode 100644
index 00000000..276d6a7f
--- /dev/null
+++ b/src/io/jsonadapter.hpp
@@ -0,0 +1,117 @@
+#pragma once
+
+#include <qjsondocument.h>
+#include <qjsonobject.h>
+#include <qjsonvalue.h>
+#include <qjsvalue.h>
+#include <qlist.h>
+#include <qobjectdefs.h>
+#include <qqmlintegration.h>
+#include <qqmlparserstatus.h>
+#include <qstringview.h>
+#include <qtmetamacros.h>
+
+#include "fileview.hpp"
+
+namespace qs::io {
+
+/// See @@JsonAdapter.
+class JsonObject: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+};
+
+///! FileView adapter for accessing JSON files.
+/// JsonAdapter is a @@FileView adapter that exposes a JSON file as a set of QML
+/// properties that can be read and written to.
+///
+/// Each property defined in a JsonAdapter corresponds to a key in the JSON file.
+/// Supported property types are:
+/// - Primitves (`int`, `bool`, `string`, `real`)
+/// - Sub-object adapters (@@JsonObject$)
+/// - JSON objects and arrays, as a `var` type
+/// - Lists of any of the above (`list<string>` etc)
+///
+/// When the @@FileView$'s data is loaded, properties of a JsonAdapter or
+/// sub-object adapter (@@JsonObject$) are updated if their values have changed.
+///
+/// When properties of a JsonAdapter or sub-object adapter are changed from QML,
+/// @@FileView.adapterUpdated(s) is emitted, which may be used to save the file's new
+/// state (see @@FileView.writeAdapter()$).
+///
+/// ### Example
+/// ```qml
+/// @@FileView {
+///   path: "/path/to/file"
+///
+///   // when changes are made on disk, reload the file's content
+///   watchChanges: true
+///   onFileChanged: reload()
+///
+///   // when changes are made to properties in the adapter, save them
+///   onAdapterUpdated: writeAdapter()
+///
+///   JsonAdapter {
+///     property string myStringProperty: "default value"
+///     onMyStringPropertyChanged: {
+///       console.log("myStringProperty was changed via qml or on disk")
+///     }
+///
+///     property list<string> stringList: [ "default", "value" ]
+///
+///     property JsonObject subObject: JsonObject {
+///       property string subObjectProperty: "default value"
+///       onSubObjectPropertyChanged: console.log("same as above")
+///     }
+///
+///     // works the same way as subObject
+///     property var inlineJson: { "a": "b" }
+///   }
+/// }
+/// ```
+///
+/// The above snippet produces the JSON document below:
+/// ```json
+/// {
+///    "myStringProperty": "default value",
+///    "stringList": [
+///      "default",
+///      "value"
+///    ],
+///    "subObject": {
+///      "subObjectProperty": "default value"
+///    },
+///    "inlineJson": {
+///      "a": "b"
+///    }
+/// }
+/// ```
+class JsonAdapter
+    : public FileViewAdapter
+    , public QQmlParserStatus {
+	Q_OBJECT;
+	QML_ELEMENT;
+	Q_INTERFACES(QQmlParserStatus);
+
+public:
+	void classBegin() override {}
+	void componentComplete() override;
+
+	void deserializeAdapter(const QByteArray& data) override;
+	[[nodiscard]] QByteArray serializeAdapter() override;
+
+private slots:
+	void onPropertyChanged();
+
+private:
+	void connectNotifiers();
+	void connectNotifiersRec(int notifySlot, QObject* obj, const QMetaObject* base);
+	void deserializeRec(const QJsonObject& json, QObject* obj, const QMetaObject* base);
+	[[nodiscard]] QJsonObject serializeRec(const QObject* obj, const QMetaObject* base) const;
+
+	bool changesBlocked = false;
+	QList<JsonObject*> createdObjects;
+	QList<JsonObject*> oldCreatedObjects;
+};
+
+} // namespace qs::io
diff --git a/src/io/module.md b/src/io/module.md
index 676cff73..2fb8688f 100644
--- a/src/io/module.md
+++ b/src/io/module.md
@@ -4,5 +4,8 @@ headers = [
 	"datastream.hpp",
 	"socket.hpp",
 	"process.hpp",
+	"fileview.hpp",
+	"jsonadapter.hpp",
+	"ipchandler.hpp",
 ]
 -----
diff --git a/src/io/process.cpp b/src/io/process.cpp
index 9fae90e2..6055e2c9 100644
--- a/src/io/process.cpp
+++ b/src/io/process.cpp
@@ -3,23 +3,23 @@
 #include <utility>
 
 #include <qdir.h>
+#include <qhash.h>
 #include <qlist.h>
 #include <qlogging.h>
-#include <qmap.h>
 #include <qobject.h>
 #include <qprocess.h>
+#include <qqmlinfo.h>
 #include <qtmetamacros.h>
 #include <qtypes.h>
 #include <qvariant.h>
 
+#include "../core/generation.hpp"
 #include "../core/qmlglobal.hpp"
+#include "../core/reload.hpp"
 #include "datastream.hpp"
+#include "processcore.hpp"
 
-// When the process ends this have no parent and is just leaked,
-// meaning the destructor never runs and they are never killed.
-static DisownedProcessContext* disownedCtx; // NOLINT
-
-Process::Process(QObject* parent): QObject(parent) {
+Process::Process(QObject* parent): PostReloadHook(parent) {
 	QObject::connect(
 	    QuickshellSettings::instance(),
 	    &QuickshellSettings::workingDirectoryChanged,
@@ -29,12 +29,17 @@ Process::Process(QObject* parent): QObject(parent) {
 }
 
 Process::~Process() {
-	if (!this->mLifetimeManaged && this->process != nullptr) {
-		if (disownedCtx == nullptr) disownedCtx = new DisownedProcessContext(); // NOLINT
-		disownedCtx->reparent(this->process);
+	if (this->process != nullptr && this->process->processId() != 0) {
+		// Deleting after the process finishes hides the process destroyed warning in logs
+		QObject::connect(this->process, &QProcess::finished, [p = this->process] { delete p; });
+
+		this->process->setParent(nullptr);
+		this->process->kill();
 	}
 }
 
+void Process::onPostReload() { this->startProcessIfReady(); }
+
 bool Process::isRunning() const { return this->process != nullptr; }
 
 void Process::setRunning(bool running) {
@@ -53,8 +58,8 @@ QList<QString> Process::command() const { return this->mCommand; }
 void Process::setCommand(QList<QString> command) {
 	if (this->mCommand == command) return;
 	this->mCommand = std::move(command);
-	emit this->commandChanged();
 
+	emit this->commandChanged();
 	this->startProcessIfReady();
 }
 
@@ -77,9 +82,9 @@ void Process::onGlobalWorkingDirectoryChanged() {
 	}
 }
 
-QMap<QString, QVariant> Process::environment() const { return this->mEnvironment; }
+QHash<QString, QVariant> Process::environment() const { return this->mEnvironment; }
 
-void Process::setEnvironment(QMap<QString, QVariant> environment) {
+void Process::setEnvironment(QHash<QString, QVariant> environment) {
 	if (environment == this->mEnvironment) return;
 	this->mEnvironment = std::move(environment);
 	emit this->environmentChanged();
@@ -172,19 +177,22 @@ void Process::setStdinEnabled(bool enabled) {
 	emit this->stdinEnabledChanged();
 }
 
-bool Process::isLifetimeManaged() const { return this->mLifetimeManaged; }
-
-void Process::setLifetimeManaged(bool managed) {
-	if (managed == this->mLifetimeManaged) return;
-	this->mLifetimeManaged = managed;
-	emit this->lifetimeManagedChanged();
-}
-
 void Process::startProcessIfReady() {
-	if (this->process != nullptr || !this->targetRunning || this->mCommand.isEmpty()) return;
+	if (this->process != nullptr || !this->isPostReload || !this->targetRunning
+	    || this->mCommand.isEmpty())
+		return;
+
 	this->targetRunning = false;
 
 	auto& cmd = this->mCommand.first();
+	if (cmd.startsWith("file://")) {
+		cmd = cmd.sliced(7);
+	} else if (cmd.startsWith("root://")) {
+		cmd = cmd.sliced(7);
+		auto& root = EngineGeneration::findObjectGeneration(this)->rootPath;
+		cmd = root.filePath(cmd.startsWith('/') ? cmd.sliced(1) : cmd);
+	}
+
 	auto args = this->mCommand.sliced(1);
 
 	this->process = new QProcess(this);
@@ -204,34 +212,59 @@ void Process::startProcessIfReady() {
 	if (this->mStderrParser == nullptr) this->process->closeReadChannel(QProcess::StandardError);
 	if (!this->mStdinEnabled) this->process->closeWriteChannel();
 
-	if (!this->mWorkingDirectory.isEmpty()) {
-		this->process->setWorkingDirectory(this->mWorkingDirectory);
-	}
-
-	if (!this->mEnvironment.isEmpty() || this->mClearEnvironment) {
-		auto sysenv = QProcessEnvironment::systemEnvironment();
-		auto env = this->mClearEnvironment ? QProcessEnvironment() : sysenv;
-
-		for (auto& name: this->mEnvironment.keys()) {
-			auto value = this->mEnvironment.value(name);
-			if (!value.isValid()) continue;
-
-			if (this->mClearEnvironment) {
-				if (value.isNull()) {
-					if (sysenv.contains(name)) env.insert(name, sysenv.value(name));
-				} else env.insert(name, value.toString());
-			} else {
-				if (value.isNull()) env.remove(name);
-				else env.insert(name, value.toString());
-			}
-		}
-
-		this->process->setProcessEnvironment(env);
-	}
-
+	this->setupEnvironment(this->process);
 	this->process->start(cmd, args);
 }
 
+void Process::exec(QList<QString> command) {
+	this->exec(qs::io::process::ProcessContext(std::move(command)));
+}
+
+void Process::exec(const qs::io::process::ProcessContext& context) {
+	this->setRunning(false);
+	if (context.commandSet) this->setCommand(context.command);
+	if (context.environmentSet) this->setEnvironment(context.environment);
+	if (context.clearEnvironmentSet) this->setEnvironmentCleared(context.clearEnvironment);
+	if (context.workingDirectorySet) this->setWorkingDirectory(context.workingDirectory);
+
+	if (this->mCommand.isEmpty()) {
+		qmlWarning(this) << "Cannot start process as command is empty.";
+		return;
+	}
+
+	this->setRunning(true);
+}
+
+void Process::startDetached() {
+	if (this->mCommand.isEmpty()) {
+		qmlWarning(this) << "Cannot start process as command is empty.";
+		return;
+	}
+
+	auto& cmd = this->mCommand.first();
+	auto args = this->mCommand.sliced(1);
+
+	QProcess process;
+
+	this->setupEnvironment(&process);
+	process.setProgram(cmd);
+	process.setArguments(args);
+
+	process.setStandardInputFile(QProcess::nullDevice());
+	process.setStandardOutputFile(QProcess::nullDevice());
+	process.setStandardErrorFile(QProcess::nullDevice());
+
+	process.startDetached();
+}
+
+void Process::setupEnvironment(QProcess* process) {
+	if (!this->mWorkingDirectory.isEmpty()) {
+		process->setWorkingDirectory(this->mWorkingDirectory);
+	}
+
+	qs::io::process::setupProcessEnvironment(process, this->mClearEnvironment, this->mEnvironment);
+}
+
 void Process::onStarted() {
 	emit this->processIdChanged();
 	emit this->runningChanged();
@@ -241,12 +274,16 @@ void Process::onStarted() {
 void Process::onFinished(qint32 exitCode, QProcess::ExitStatus exitStatus) {
 	this->process->deleteLater();
 	this->process = nullptr;
+	if (this->mStdoutParser) this->mStdoutParser->streamEnded(this->stdoutBuffer);
+	if (this->mStderrParser) this->mStderrParser->streamEnded(this->stderrBuffer);
 	this->stdoutBuffer.clear();
 	this->stderrBuffer.clear();
 
 	emit this->exited(exitCode, exitStatus);
 	emit this->runningChanged();
 	emit this->processIdChanged();
+
+	this->startProcessIfReady(); // for `running = false; running = true`
 }
 
 void Process::onErrorOccurred(QProcess::ProcessError error) {
@@ -280,13 +317,3 @@ void Process::write(const QString& data) {
 	if (this->process == nullptr) return;
 	this->process->write(data.toUtf8());
 }
-
-void DisownedProcessContext::reparent(QProcess* process) {
-	process->setParent(this);
-	QObject::connect(process, &QProcess::finished, this, [process]() { process->deleteLater(); });
-}
-
-void DisownedProcessContext::destroyInstance() {
-	delete disownedCtx;
-	disownedCtx = nullptr;
-}
diff --git a/src/io/process.hpp b/src/io/process.hpp
index 120c431b..ab8763ee 100644
--- a/src/io/process.hpp
+++ b/src/io/process.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <qcontainerfwd.h>
+#include <qhash.h>
 #include <qobject.h>
 #include <qprocess.h>
 #include <qqmlintegration.h>
@@ -9,7 +10,15 @@
 #include <qtypes.h>
 #include <qvariant.h>
 
+#include "../core/doc.hpp"
+#include "../core/reload.hpp"
 #include "datastream.hpp"
+#include "processcore.hpp"
+
+// Needed when compiling with clang musl-libc++.
+// Default include paths contain macros that cause name collisions.
+#undef stdout
+#undef stderr
 
 ///! Child process.
 /// #### Example
@@ -17,12 +26,12 @@
 /// Process {
 ///   running: true
 ///   command: [ "some-command", "arg" ]
-///   stdout: SplitParser {
-///     onRead: data => console.log(`line read: ${data}`)
+///   stdout: @@StdioCollector {
+///     onStreamFinished: console.log(`line read: ${this.text}`)
 ///   }
 /// }
 /// ```
-class Process: public QObject {
+class Process: public PostReloadHook {
 	Q_OBJECT;
 	// clang-format off
 	/// If the process is currently running. Defaults to false.
@@ -30,7 +39,7 @@ class Process: public QObject {
 	/// Setting this property to true will start the process if command has at least
 	/// one element.
 	/// Setting it to false will send SIGTERM. To immediately kill the process,
-	/// use [signal](#func.signal) with SIGKILL. The process will be killed when
+	/// use @@signal() with SIGKILL. The process will be killed when
 	/// quickshell dies.
 	///
 	/// If you want to run the process in a loop, use the onRunningChanged signal handler
@@ -41,8 +50,11 @@ class Process: public QObject {
 	///   onRunningChanged: if (!running) running = true
 	/// }
 	/// ```
+	///
+	/// > [!NOTE] See @@startDetached() to prevent the process from being killed by Quickshell
+	/// > if Quickshell is killed or the configuration is reloaded.
 	Q_PROPERTY(bool running READ isRunning WRITE setRunning NOTIFY runningChanged);
-	/// The process ID of the running process or `null` if `running` is false.
+	/// The process ID of the running process or `null` if @@running is false.
 	Q_PROPERTY(QVariant processId READ processId NOTIFY processIdChanged);
 	/// The command to execute. Each argument is its own string, which means you don't have
 	/// to deal with quoting anything.
@@ -51,6 +63,14 @@ class Process: public QObject {
 	/// started process. If the property has been changed after starting a process it will
 	/// return the new value, not the one for the currently running process.
 	///
+	/// > [!WARNING] This does not run command in a shell. All arguments to the command
+	/// > must be in separate values in the list, e.g. `["echo", "hello"]`
+	/// > and not `["echo hello"]`.
+	/// >
+	/// > Additionally, shell scripts must be run by your shell,
+	/// > e.g. `["sh", "script.sh"]` instead of `["script.sh"]` unless the script
+	/// > has a shebang.
+	///
 	/// > [!INFO] You can use `["sh", "-c", <your command>]` to execute your command with
 	/// > the system shell.
 	Q_PROPERTY(QList<QString> command READ command WRITE setCommand NOTIFY commandChanged);
@@ -65,8 +85,8 @@ class Process: public QObject {
 	/// Environment of the executed process.
 	///
 	/// This is a javascript object (json). Environment variables can be added by setting
-	/// them to a string and removed by setting them to null (except when [clearEnvironment] is true,
-	/// in which case this behavior is inverted, see [clearEnvironment] for details).
+	/// them to a string and removed by setting them to null (except when @@clearEnvironment is true,
+	/// in which case this behavior is inverted, see @@clearEnvironment for details).
 	///
 	///
 	/// ```qml
@@ -82,13 +102,11 @@ class Process: public QObject {
 	/// If the process is already running changing this property will affect the next
 	/// started process. If the property has been changed after starting a process it will
 	/// return the new value, not the one for the currently running process.
-	///
-	/// [clearEnvironment]: #prop.clearEnvironment
-	Q_PROPERTY(QMap<QString, QVariant> environment READ environment WRITE setEnvironment NOTIFY environmentChanged);
-	/// If the process's environment should be cleared prior to applying [environment](#prop.environment).
+	Q_PROPERTY(QHash<QString, QVariant> environment READ environment WRITE setEnvironment NOTIFY environmentChanged);
+	/// If the process's environment should be cleared prior to applying @@environment.
 	/// Defaults to false.
 	///
-	/// If true, all environment variables will be removed before the [environment](#prop.environment)
+	/// If true, all environment variables will be removed before the @@environment
 	/// object is applied, meaning the variables listed will be the only ones visible to the process.
 	/// This changes the behavior of `null` to pass in the system value of the variable if present instead
 	/// of removing it.
@@ -111,17 +129,9 @@ class Process: public QObject {
 	/// The parser for stderr. If the parser is null the process's stdout channel will be closed
 	/// and no further data will be read, even if a new parser is attached.
 	Q_PROPERTY(DataStreamParser* stderr READ stderrParser WRITE setStderrParser NOTIFY stderrParserChanged);
-	/// If stdin is enabled. Defaults to true. If this property is set to false the process's stdin channel
-	/// will be closed and [write](#func.write) will do nothing, even if set back to true.
+	/// If stdin is enabled. Defaults to false. If this property is false the process's stdin channel
+	/// will be closed and @@write() will do nothing, even if set back to true.
 	Q_PROPERTY(bool stdinEnabled READ stdinEnabled WRITE setStdinEnabled NOTIFY stdinEnabledChanged);
-	/// If the process should be killed when the Process object is destroyed or quickshell exits.
-	/// Defaults to true.
-	///
-	/// This property may be changed while the process is running and will affect it.
-	///
-	/// > [!WARNING] If set to false the process will still be killed if the quickshell config reloads.
-	/// > It will not be killed if quickshell exits normally or crashes.
-	Q_PROPERTY(bool manageLifetime READ isLifetimeManaged WRITE setLifetimeManaged NOTIFY lifetimeManagedChanged);
 	// clang-format on
 	QML_ELEMENT;
 
@@ -130,12 +140,56 @@ public:
 	~Process() override;
 	Q_DISABLE_COPY_MOVE(Process);
 
-	/// Sends a signal to the process if `running` is true, otherwise does nothing.
+	void onPostReload() override;
+
+	// MUST be before exec(ctx) or the other will be called with a default constructed obj.
+	QSDOC_HIDE Q_INVOKABLE void exec(QList<QString> command);
+	/// Launch a process with the given arguments, stopping any currently running process.
+	///
+	/// The context parameter can either be a list of command arguments or a JS object with the following fields:
+	/// - `command`: A list containing the command and all its arguments. See @@Quickshell.Io.Process.command.
+	/// - `environment`: Changes to make to the process environment. See @@Quickshell.Io.Process.environment.
+	/// - `clearEnvironment`: Removes all variables from the environment if true.
+	/// - `workingDirectory`: The working directory the command should run in.
+	///
+	/// Passed parameters will change the values currently set in the process.
+	///
+	/// > [!WARNING] This does not run command in a shell. All arguments to the command
+	/// > must be in separate values in the list, e.g. `["echo", "hello"]`
+	/// > and not `["echo hello"]`.
+	/// >
+	/// > Additionally, shell scripts must be run by your shell,
+	/// > e.g. `["sh", "script.sh"]` instead of `["script.sh"]` unless the script
+	/// > has a shebang.
+	///
+	/// > [!INFO] You can use `["sh", "-c", <your command>]` to execute your command with
+	/// > the system shell.
+	///
+	/// Calling this function is equivalent to running:
+	/// ```qml
+	/// process.running = false;
+	/// process.command = ...
+	/// process.environment = ...
+	/// process.clearEnvironment = ...
+	/// process.workingDirectory = ...
+	/// process.running = true;
+	/// ```
+	Q_INVOKABLE void exec(const qs::io::process::ProcessContext& context);
+
+	/// Sends a signal to the process if @@running is true, otherwise does nothing.
 	Q_INVOKABLE void signal(qint32 signal);
 
-	/// Writes to the process's stdin. Does nothing if `running` is false.
+	/// Writes to the process's stdin. Does nothing if @@running is false.
 	Q_INVOKABLE void write(const QString& data);
 
+	/// Launches an instance of the process detached from Quickshell.
+	///
+	/// The subprocess will not be tracked, @@running will be false,
+	/// and the subprocess will not be killed by Quickshell.
+	///
+	/// This function is equivalent to @@Quickshell.Quickshell.execDetached().
+	Q_INVOKABLE void startDetached();
+
 	[[nodiscard]] bool isRunning() const;
 	void setRunning(bool running);
 
@@ -147,8 +201,8 @@ public:
 	[[nodiscard]] QString workingDirectory() const;
 	void setWorkingDirectory(const QString& workingDirectory);
 
-	[[nodiscard]] QMap<QString, QVariant> environment() const;
-	void setEnvironment(QMap<QString, QVariant> environment);
+	[[nodiscard]] QHash<QString, QVariant> environment() const;
+	void setEnvironment(QHash<QString, QVariant> environment);
 
 	[[nodiscard]] bool environmentCleared() const;
 	void setEnvironmentCleared(bool cleared);
@@ -162,9 +216,6 @@ public:
 	[[nodiscard]] bool stdinEnabled() const;
 	void setStdinEnabled(bool enabled);
 
-	[[nodiscard]] bool isLifetimeManaged() const;
-	void setLifetimeManaged(bool managed);
-
 signals:
 	void started();
 	void exited(qint32 exitCode, QProcess::ExitStatus exitStatus);
@@ -178,7 +229,6 @@ signals:
 	void stdoutParserChanged();
 	void stderrParserChanged();
 	void stdinEnabledChanged();
-	void lifetimeManagedChanged();
 
 private slots:
 	void onStarted();
@@ -192,11 +242,12 @@ private slots:
 
 private:
 	void startProcessIfReady();
+	void setupEnvironment(QProcess* process);
 
 	QProcess* process = nullptr;
 	QList<QString> mCommand;
 	QString mWorkingDirectory;
-	QMap<QString, QVariant> mEnvironment;
+	QHash<QString, QVariant> mEnvironment;
 	DataStreamParser* mStdoutParser = nullptr;
 	DataStreamParser* mStderrParser = nullptr;
 	QByteArray stdoutBuffer;
@@ -205,15 +256,4 @@ private:
 	bool targetRunning = false;
 	bool mStdinEnabled = false;
 	bool mClearEnvironment = false;
-	bool mLifetimeManaged = true;
-};
-
-class DisownedProcessContext: public QObject {
-	Q_OBJECT;
-
-	void reparent(QProcess* process);
-	friend class Process;
-
-public:
-	static void destroyInstance();
 };
diff --git a/src/io/processcore.cpp b/src/io/processcore.cpp
new file mode 100644
index 00000000..8b5e80eb
--- /dev/null
+++ b/src/io/processcore.cpp
@@ -0,0 +1,37 @@
+#include "processcore.hpp"
+
+#include <qcontainerfwd.h>
+#include <qhash.h>
+#include <qprocess.h>
+#include <qvariant.h>
+
+#include "../core/common.hpp"
+
+namespace qs::io::process {
+
+void setupProcessEnvironment(
+    QProcess* process,
+    bool clear,
+    const QHash<QString, QVariant>& envChanges
+) {
+	const auto& sysenv = qs::Common::INITIAL_ENVIRONMENT;
+	auto env = clear ? QProcessEnvironment() : sysenv;
+
+	for (auto& name: envChanges.keys()) {
+		auto value = envChanges.value(name);
+		if (!value.isValid()) continue;
+
+		if (clear) {
+			if (value.isNull()) {
+				if (sysenv.contains(name)) env.insert(name, sysenv.value(name));
+			} else env.insert(name, value.toString());
+		} else {
+			if (value.isNull()) env.remove(name);
+			else env.insert(name, value.toString());
+		}
+	}
+
+	process->setProcessEnvironment(env);
+}
+
+} // namespace qs::io::process
diff --git a/src/io/processcore.hpp b/src/io/processcore.hpp
new file mode 100644
index 00000000..37ec4093
--- /dev/null
+++ b/src/io/processcore.hpp
@@ -0,0 +1,69 @@
+#pragma once
+
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qhash.h>
+#include <qlist.h>
+#include <qprocess.h>
+#include <qqmlintegration.h>
+#include <qvariant.h>
+
+namespace qs::io::process {
+
+class ProcessContext {
+	Q_PROPERTY(QList<QString> command MEMBER command WRITE setCommand);
+	Q_PROPERTY(QHash<QString, QVariant> environment MEMBER environment WRITE setEnvironment);
+	Q_PROPERTY(bool clearEnvironment MEMBER clearEnvironment WRITE setClearEnvironment);
+	Q_PROPERTY(QString workingDirectory MEMBER workingDirectory WRITE setWorkingDirectory);
+	Q_PROPERTY(bool unbindStdout MEMBER unbindStdout WRITE setUnbindStdout);
+	Q_GADGET;
+	QML_STRUCTURED_VALUE;
+	QML_VALUE_TYPE(processContext);
+
+public:
+	ProcessContext() = default;
+	// Making this a Q_INVOKABLE does not work with QML_STRUCTURED_VALUe in Qt 6.9.
+	explicit ProcessContext(QList<QString> command): command(std::move(command)), commandSet(true) {}
+
+	void setCommand(QList<QString> command) {
+		this->command = std::move(command);
+		this->commandSet = true;
+	}
+
+	void setEnvironment(QHash<QString, QVariant> environment) {
+		this->environment = std::move(environment);
+		this->environmentSet = true;
+	}
+
+	void setClearEnvironment(bool clearEnvironment) {
+		this->clearEnvironment = clearEnvironment;
+		this->clearEnvironmentSet = true;
+	}
+
+	void setWorkingDirectory(QString workingDirectory) {
+		this->workingDirectory = std::move(workingDirectory);
+		this->workingDirectorySet = true;
+	}
+
+	void setUnbindStdout(bool unbindStdout) { this->unbindStdout = unbindStdout; }
+
+	QList<QString> command;
+	QHash<QString, QVariant> environment;
+	bool clearEnvironment = false;
+	QString workingDirectory;
+
+	bool commandSet : 1 = false;
+	bool environmentSet : 1 = false;
+	bool clearEnvironmentSet : 1 = false;
+	bool workingDirectorySet : 1 = false;
+	bool unbindStdout : 1 = true;
+};
+
+void setupProcessEnvironment(
+    QProcess* process,
+    bool clear,
+    const QHash<QString, QVariant>& envChanges
+);
+
+} // namespace qs::io::process
diff --git a/src/io/socket.cpp b/src/io/socket.cpp
index f5e0b538..371f6873 100644
--- a/src/io/socket.cpp
+++ b/src/io/socket.cpp
@@ -5,13 +5,17 @@
 #include <qlocalserver.h>
 #include <qlocalsocket.h>
 #include <qlogging.h>
+#include <qloggingcategory.h>
 #include <qobject.h>
 #include <qqmlcomponent.h>
 #include <qqmlengine.h>
 #include <qtmetamacros.h>
 
+#include "../core/logcat.hpp"
 #include "datastream.hpp"
 
+QS_LOGGING_CATEGORY(logSocket, "quickshell.io.socket", QtWarningMsg);
+
 void Socket::setSocket(QLocalSocket* socket) {
 	if (this->socket != nullptr) this->socket->deleteLater();
 	this->socket = socket;
@@ -22,7 +26,7 @@ void Socket::setSocket(QLocalSocket* socket) {
 		// clang-format off
 		QObject::connect(this->socket, &QLocalSocket::connected, this, &Socket::onSocketConnected);
 		QObject::connect(this->socket, &QLocalSocket::disconnected, this, &Socket::onSocketDisconnected);
-		QObject::connect(this->socket, &QLocalSocket::errorOccurred, this, &Socket::error);
+		QObject::connect(this->socket, &QLocalSocket::errorOccurred, this, &Socket::onSocketError);
 		QObject::connect(this->socket, &QLocalSocket::readyRead, this, &DataStream::onBytesAvailable);
 		// clang-format on
 
@@ -45,10 +49,12 @@ void Socket::onSocketConnected() {
 	this->connected = true;
 	this->targetConnected = false;
 	this->disconnecting = false;
+	qCDebug(logSocket) << "Socket connected:" << this;
 	emit this->connectionStateChanged();
 }
 
 void Socket::onSocketDisconnected() {
+	qCDebug(logSocket) << "Socket disconnected:" << this;
 	this->connected = false;
 	this->disconnecting = false;
 	this->socket->deleteLater();
@@ -59,6 +65,11 @@ void Socket::onSocketDisconnected() {
 	if (this->targetConnected) this->connectPathSocket();
 }
 
+void Socket::onSocketError(QLocalSocket::LocalSocketError error) {
+	qCWarning(logSocket) << "Socket error for" << this << error;
+	emit this->error(error);
+}
+
 bool Socket::isConnected() const { return this->connected; }
 
 void Socket::setConnected(bool connected) {
@@ -89,9 +100,19 @@ void Socket::write(const QString& data) {
 	}
 }
 
+void Socket::flush() {
+	if (this->socket != nullptr) {
+		this->socket->flush();
+	}
+}
+
 SocketServer::~SocketServer() { this->disableServer(); }
 
-void SocketServer::onPostReload() {
+void SocketServer::onReload(QObject* oldInstance) {
+	if (auto* old = qobject_cast<SocketServer*>(oldInstance)) {
+		old->disableServer();
+	}
+
 	this->postReload = true;
 	if (this->isActivatable()) this->enableServer();
 }
@@ -136,6 +157,8 @@ bool SocketServer::isActivatable() {
 void SocketServer::enableServer() {
 	this->disableServer();
 
+	qCDebug(logSocket) << "Enabling socket server" << this << "at" << this->mPath;
+
 	this->server = new QLocalServer(this);
 	QObject::connect(
 	    this->server,
@@ -144,31 +167,38 @@ void SocketServer::enableServer() {
 	    &SocketServer::onNewConnection
 	);
 
+	if (QFile::remove(this->mPath)) {
+		qCWarning(logSocket) << "Deleted existing file at" << this->mPath << "to create socket";
+	}
+
 	if (!this->server->listen(this->mPath)) {
-		qWarning() << "could not start socket server at" << this->mPath;
+		qCWarning(logSocket) << "Could not start socket server at" << this->mPath;
 		this->disableServer();
 	}
 
 	this->activeTarget = false;
+	this->activePath = this->mPath;
 	emit this->activeStatusChanged();
 }
 
 void SocketServer::disableServer() {
 	auto wasActive = this->server != nullptr;
 
-	if (this->server != nullptr) {
+	if (wasActive) {
+		qCDebug(logSocket) << "Disabling socket server" << this << "at" << this->activePath;
 		for (auto* socket: this->mSockets) {
 			socket->deleteLater();
 		}
 
 		this->mSockets.clear();
+		this->server->close();
 		this->server->deleteLater();
 		this->server = nullptr;
-	}
 
-	if (this->mPath != nullptr) {
-		if (QFile::exists(this->mPath) && !QFile::remove(this->mPath)) {
-			qWarning() << "failed to delete socket file at" << this->mPath;
+		if (!this->activePath.isEmpty()) {
+			if (QFile::exists(this->activePath) && !QFile::remove(this->activePath)) {
+				qWarning() << "Failed to delete socket file at" << this->activePath;
+			}
 		}
 	}
 
diff --git a/src/io/socket.hpp b/src/io/socket.hpp
index 25b8a1df..3fd230ef 100644
--- a/src/io/socket.hpp
+++ b/src/io/socket.hpp
@@ -1,16 +1,21 @@
 #pragma once
 
+#include <qcontainerfwd.h>
 #include <qlocalserver.h>
 #include <qlocalsocket.h>
+#include <qloggingcategory.h>
 #include <qobject.h>
 #include <qqmlcomponent.h>
 #include <qqmlintegration.h>
 #include <qtclasshelpermacros.h>
 #include <qtmetamacros.h>
 
+#include "../core/logcat.hpp"
 #include "../core/reload.hpp"
 #include "datastream.hpp"
 
+QS_DECLARE_LOGGING_CATEGORY(logSocket);
+
 ///! Unix socket listener.
 class Socket: public DataStream {
 	Q_OBJECT;
@@ -20,7 +25,7 @@ class Socket: public DataStream {
 	/// update the property immediately. Setting the property to false will begin disconnecting
 	/// the socket, and setting it to true will begin connecting the socket if path is not empty.
 	Q_PROPERTY(bool connected READ isConnected WRITE setConnected NOTIFY connectionStateChanged);
-	/// The path to connect this socket to when `connected` is set to true.
+	/// The path to connect this socket to when @@connected is set to true.
 	///
 	/// Changing this property will have no effect while the connection is active.
 	Q_PROPERTY(QString path READ path WRITE setPath NOTIFY pathChanged);
@@ -30,8 +35,13 @@ public:
 	explicit Socket(QObject* parent = nullptr): DataStream(parent) {}
 
 	/// Write data to the socket. Does nothing if not connected.
+	///
+	/// Remember to call flush after your last write.
 	Q_INVOKABLE void write(const QString& data);
 
+	/// Flush any queued writes to the socket.
+	Q_INVOKABLE void flush();
+
 	// takes ownership
 	void setSocket(QLocalSocket* socket);
 
@@ -54,6 +64,7 @@ protected:
 private slots:
 	void onSocketConnected();
 	void onSocketDisconnected();
+	void onSocketError(QLocalSocket::LocalSocketError error);
 
 private:
 	void connectPathSocket();
@@ -81,9 +92,7 @@ private:
 ///   }
 /// }
 /// ```
-class SocketServer
-    : public QObject
-    , public PostReloadHook {
+class SocketServer: public Reloadable {
 	Q_OBJECT;
 	/// If the socket server is currently active. Defaults to false.
 	///
@@ -96,9 +105,9 @@ class SocketServer
 	///
 	/// Setting this property while the server is active will have no effect.
 	Q_PROPERTY(QString path READ path WRITE setPath NOTIFY pathChanged);
-	/// Connection handler component. Must creeate a `Socket`.
+	/// Connection handler component. Must creeate a @@Socket.
 	///
-	/// The created socket should not set `connected` or `path` or the incoming
+	/// The created socket should not set @@connected or @@path or the incoming
 	/// socket connection will be dropped (they will be set by the socket server.)
 	/// Setting `connected` to false on the created socket after connection will
 	/// close and delete it.
@@ -106,11 +115,11 @@ class SocketServer
 	QML_ELEMENT;
 
 public:
-	explicit SocketServer(QObject* parent = nullptr): QObject(parent) {}
+	explicit SocketServer(QObject* parent = nullptr): Reloadable(parent) {}
 	~SocketServer() override;
 	Q_DISABLE_COPY_MOVE(SocketServer);
 
-	void onPostReload() override;
+	void onReload(QObject* oldInstance) override;
 
 	[[nodiscard]] bool isActive() const;
 	void setActive(bool active);
@@ -140,4 +149,5 @@ private:
 	bool activeTarget = false;
 	bool postReload = false;
 	QString mPath;
+	QString activePath;
 };
diff --git a/src/io/test/CMakeLists.txt b/src/io/test/CMakeLists.txt
index 0c0cfc55..8b3da6a0 100644
--- a/src/io/test/CMakeLists.txt
+++ b/src/io/test/CMakeLists.txt
@@ -1,7 +1,8 @@
 function (qs_test name)
 	add_executable(${name} ${ARGN})
-	target_link_libraries(${name} PRIVATE ${QT_DEPS} Qt6::Test)
+	target_link_libraries(${name} PRIVATE Qt::Quick Qt::Network Qt::Test quickshell-io quickshell-core quickshell-window quickshell-ui)
 	add_test(NAME ${name} WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" COMMAND $<TARGET_FILE:${name}>)
 endfunction()
 
 qs_test(datastream datastream.cpp ../datastream.cpp)
+qs_test(process process.cpp ../process.cpp ../datastream.cpp ../processcore.cpp)
diff --git a/src/io/test/datastream.cpp b/src/io/test/datastream.cpp
index f0f36bef..c83d8ad6 100644
--- a/src/io/test/datastream.cpp
+++ b/src/io/test/datastream.cpp
@@ -1,4 +1,4 @@
-#include "../datastream.hpp"
+#include "datastream.hpp"
 
 #include <qbytearray.h>
 #include <qlist.h>
@@ -7,104 +7,100 @@
 #include <qsignalspy.h>
 #include <qtest.h>
 #include <qtestcase.h>
-#include <qtmetamacros.h>
 
-class TestSplitParser: public QObject {
-	Q_OBJECT;
-private slots:
-	void splits_data() { // NOLINT
-		QTest::addColumn<QString>("mark");
-		QTest::addColumn<QString>("buffer");   // max that can go in the buffer
-		QTest::addColumn<QString>("incoming"); // data that has to be tested on the end in one go
-		QTest::addColumn<QList<QString>>("results");
-		QTest::addColumn<QString>("remainder");
+#include "../datastream.hpp"
 
-		// NOLINTBEGIN
-		// clang-format off
-		QTest::addRow("simple") << "-"
-			<< "foo" << "-"
-			<< QList<QString>("foo") << "";
+void TestSplitParser::splits_data() { // NOLINT
+	QTest::addColumn<QString>("mark");
+	QTest::addColumn<QString>("buffer");   // max that can go in the buffer
+	QTest::addColumn<QString>("incoming"); // data that has to be tested on the end in one go
+	QTest::addColumn<QList<QString>>("results");
+	QTest::addColumn<QString>("remainder");
 
-		QTest::addRow("multiple") << "-"
-			<< "foo" << "-bar-baz-"
-			<< QList<QString>({ "foo", "bar", "baz" }) << "";
+	// NOLINTBEGIN
+	// clang-format off
+	QTest::addRow("simple") << "-"
+		<< "foo" << "-"
+		<< QList<QString>("foo") << "";
 
-		QTest::addRow("incomplete") << "-"
-			<< "foo" << "-bar-baz"
-			<< QList<QString>({ "foo", "bar" }) << "baz";
+	QTest::addRow("multiple") << "-"
+		<< "foo" << "-bar-baz-"
+		<< QList<QString>({ "foo", "bar", "baz" }) << "";
 
-		QTest::addRow("longsplit") << "12345"
-			<< "foo1234" << "5bar12345"
-			<< QList<QString>({ "foo", "bar" }) << "";
+	QTest::addRow("incomplete") << "-"
+		<< "foo" << "-bar-baz"
+		<< QList<QString>({ "foo", "bar" }) << "baz";
 
-		QTest::addRow("longsplit-incomplete") << "123"
-			<< "foo12" << "3bar123baz"
-			<< QList<QString>({ "foo", "bar" }) << "baz";
-		// clang-format on
-		// NOLINTEND
-	}
+	QTest::addRow("longsplit") << "12345"
+		<< "foo1234" << "5bar12345"
+		<< QList<QString>({ "foo", "bar" }) << "";
 
-	void splits() { // NOLINT
-		// NOLINTBEGIN
-		QFETCH(QString, mark);
-		QFETCH(QString, buffer);
-		QFETCH(QString, incoming);
-		QFETCH(QList<QString>, results);
-		QFETCH(QString, remainder);
-		// NOLINTEND
+	QTest::addRow("longsplit-incomplete") << "123"
+		<< "foo12" << "3bar123baz"
+		<< QList<QString>({ "foo", "bar" }) << "baz";
+	// clang-format on
+	// NOLINTEND
+}
 
-		auto bufferArray = buffer.toUtf8();
-		auto incomingArray = incoming.toUtf8();
+void TestSplitParser::splits() { // NOLINT
+	// NOLINTBEGIN
+	QFETCH(QString, mark);
+	QFETCH(QString, buffer);
+	QFETCH(QString, incoming);
+	QFETCH(QList<QString>, results);
+	QFETCH(QString, remainder);
+	// NOLINTEND
 
-		for (auto i = 0; i <= bufferArray.length(); i++) {
-			auto buffer = bufferArray.sliced(0, i);
-			auto incoming = bufferArray.sliced(i);
-			incoming.append(incomingArray);
+	auto bufferArray = buffer.toUtf8();
+	auto incomingArray = incoming.toUtf8();
 
-			qInfo() << "BUFFER" << QString(buffer);
-			qInfo() << "INCOMING" << QString(incoming);
+	for (auto i = 0; i <= bufferArray.length(); i++) {
+		auto buffer = bufferArray.sliced(0, i);
+		auto incoming = bufferArray.sliced(i);
+		incoming.append(incomingArray);
 
-			auto parser = SplitParser();
-			auto spy = QSignalSpy(&parser, &DataStreamParser::read);
+		qInfo() << "BUFFER" << QString(buffer);
+		qInfo() << "INCOMING" << QString(incoming);
 
-			parser.setSplitMarker(mark);
-			parser.parseBytes(incoming, buffer);
-
-			auto actualResults = QList<QString>();
-			for (auto& read: spy) {
-				actualResults.push_back(read[0].toString());
-			}
-
-			qInfo() << "EXPECTED RESULTS" << results;
-			qInfo() << "ACTUAL RESULTS" << actualResults;
-			qInfo() << "EXPECTED REMAINDER" << remainder;
-			qInfo() << "ACTUAL REMAINDER" << remainder;
-			QCOMPARE(actualResults, results);
-			QCOMPARE(buffer, remainder);
-		}
-	}
-
-	void initBuffer() { // NOLINT
 		auto parser = SplitParser();
 		auto spy = QSignalSpy(&parser, &DataStreamParser::read);
 
-		auto buf = QString("foo-bar-baz").toUtf8();
-		auto expected = QList<QString>({"foo", "bar"});
-
-		parser.setSplitMarker("-");
-		parser.parseBytes(buf, buf);
+		parser.setSplitMarker(mark);
+		parser.parseBytes(incoming, buffer);
 
 		auto actualResults = QList<QString>();
 		for (auto& read: spy) {
 			actualResults.push_back(read[0].toString());
 		}
 
-		qInfo() << "EXPECTED RESULTS" << expected;
+		qInfo() << "EXPECTED RESULTS" << results;
 		qInfo() << "ACTUAL RESULTS" << actualResults;
-		QCOMPARE(actualResults, expected);
-		QCOMPARE(buf, "baz");
+		qInfo() << "EXPECTED REMAINDER" << remainder;
+		qInfo() << "ACTUAL REMAINDER" << remainder;
+		QCOMPARE(actualResults, results);
+		QCOMPARE(buffer, remainder);
 	}
-};
+}
 
-QTEST_MAIN(TestSplitParser)
-#include "datastream.moc"
+void TestSplitParser::initBuffer() { // NOLINT
+	auto parser = SplitParser();
+	auto spy = QSignalSpy(&parser, &DataStreamParser::read);
+
+	auto buf = QString("foo-bar-baz").toUtf8();
+	auto expected = QList<QString>({"foo", "bar"});
+
+	parser.setSplitMarker("-");
+	parser.parseBytes(buf, buf);
+
+	auto actualResults = QList<QString>();
+	for (auto& read: spy) {
+		actualResults.push_back(read[0].toString());
+	}
+
+	qInfo() << "EXPECTED RESULTS" << expected;
+	qInfo() << "ACTUAL RESULTS" << actualResults;
+	QCOMPARE(actualResults, expected);
+	QCOMPARE(buf, "baz");
+}
+
+QTEST_MAIN(TestSplitParser);
diff --git a/src/io/test/datastream.hpp b/src/io/test/datastream.hpp
new file mode 100644
index 00000000..cd89bb8d
--- /dev/null
+++ b/src/io/test/datastream.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+class TestSplitParser: public QObject {
+	Q_OBJECT;
+
+private slots:
+	void splits_data(); // NOLINT
+	void splits();
+	void initBuffer();
+};
diff --git a/src/io/test/process.cpp b/src/io/test/process.cpp
new file mode 100644
index 00000000..09fc9f7d
--- /dev/null
+++ b/src/io/test/process.cpp
@@ -0,0 +1,47 @@
+#include "process.hpp"
+
+#include <qlist.h>
+#include <qsignalspy.h>
+#include <qtest.h>
+#include <qtestcase.h>
+
+#include "../process.hpp"
+
+void TestProcess::startAfterReload() {
+	auto process = Process();
+	auto startedSpy = QSignalSpy(&process, &Process::started);
+	auto exitedSpy = QSignalSpy(&process, &Process::exited);
+
+	process.setCommand({"true"});
+	process.setRunning(true);
+
+	QVERIFY(!process.isRunning());
+	QCOMPARE(startedSpy.count(), 0);
+
+	process.postReload();
+
+	QVERIFY(process.isRunning());
+	QVERIFY(startedSpy.wait(100));
+}
+
+void TestProcess::testExec() {
+	auto process = Process();
+	auto startedSpy = QSignalSpy(&process, &Process::started);
+	auto exitedSpy = QSignalSpy(&process, &Process::exited);
+
+	process.postReload();
+
+	process.setCommand({"sleep", "30"});
+	process.setRunning(true);
+
+	QVERIFY(process.isRunning());
+	QVERIFY(startedSpy.wait(100));
+
+	process.exec({"true"});
+
+	QVERIFY(exitedSpy.wait(100));
+	QVERIFY(startedSpy.wait(100));
+	QVERIFY(process.isRunning());
+}
+
+QTEST_MAIN(TestProcess);
diff --git a/src/io/test/process.hpp b/src/io/test/process.hpp
new file mode 100644
index 00000000..3525be22
--- /dev/null
+++ b/src/io/test/process.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+class TestProcess: public QObject {
+	Q_OBJECT;
+
+private slots:
+	static void startAfterReload();
+	static void testExec();
+};
diff --git a/src/ipc/CMakeLists.txt b/src/ipc/CMakeLists.txt
new file mode 100644
index 00000000..e3f9e25f
--- /dev/null
+++ b/src/ipc/CMakeLists.txt
@@ -0,0 +1,9 @@
+qt_add_library(quickshell-ipc STATIC
+	ipc.cpp
+)
+
+qs_pch(quickshell-ipc)
+
+target_link_libraries(quickshell-ipc PRIVATE Qt::Quick Qt::Network)
+
+target_link_libraries(quickshell PRIVATE quickshell-ipc)
diff --git a/src/ipc/ipc.cpp b/src/ipc/ipc.cpp
new file mode 100644
index 00000000..bf668015
--- /dev/null
+++ b/src/ipc/ipc.cpp
@@ -0,0 +1,126 @@
+#include "ipc.hpp"
+#include <functional>
+#include <variant>
+
+#include <qbuffer.h>
+#include <qlocalserver.h>
+#include <qlocalsocket.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+
+#include "../core/generation.hpp"
+#include "../core/logcat.hpp"
+#include "../core/paths.hpp"
+#include "ipccommand.hpp"
+
+namespace qs::ipc {
+
+QS_LOGGING_CATEGORY(logIpc, "quickshell.ipc", QtWarningMsg);
+
+IpcServer::IpcServer(const QString& path) {
+	QObject::connect(&this->server, &QLocalServer::newConnection, this, &IpcServer::onNewConnection);
+
+	QLocalServer::removeServer(path);
+
+	if (!this->server.listen(path)) {
+		qCCritical(logIpc) << "Failed to start IPC server on path" << path;
+		return;
+	}
+
+	qCInfo(logIpc) << "Started IPC server on path" << path;
+}
+
+void IpcServer::start() {
+	if (auto* run = QsPaths::instance()->instanceRunDir()) {
+		auto path = run->filePath("ipc.sock");
+		new IpcServer(path);
+	} else {
+		qCCritical(logIpc
+		) << "Could not start IPC server as the instance runtime path could not be created.";
+	}
+}
+
+void IpcServer::onNewConnection() {
+	while (auto* connection = this->server.nextPendingConnection()) {
+		new IpcServerConnection(connection, this);
+	}
+}
+
+IpcServerConnection::IpcServerConnection(QLocalSocket* socket, IpcServer* server)
+    : QObject(server)
+    , socket(socket) {
+	socket->setParent(this);
+	this->stream.setDevice(socket);
+	QObject::connect(socket, &QLocalSocket::disconnected, this, &IpcServerConnection::onDisconnected);
+	QObject::connect(socket, &QLocalSocket::readyRead, this, &IpcServerConnection::onReadyRead);
+
+	qCInfo(logIpc) << "New IPC connection" << this;
+}
+
+void IpcServerConnection::onDisconnected() {
+	qCInfo(logIpc) << "IPC connection disconnected" << this;
+}
+
+void IpcServerConnection::onReadyRead() {
+	this->stream.startTransaction();
+
+	this->stream.startTransaction();
+	IpcCommand command;
+	this->stream >> command;
+	if (!this->stream.commitTransaction()) return;
+
+	std::visit(
+	    [this]<typename Command>(Command& command) {
+		    if constexpr (std::is_same_v<std::monostate, Command>) {
+			    qCCritical(logIpc) << "Received invalid IPC command from" << this;
+			    this->socket->disconnectFromServer();
+		    } else {
+			    command.exec(this);
+		    }
+	    },
+	    command
+	);
+
+	if (!this->stream.commitTransaction()) return;
+}
+
+IpcClient::IpcClient(const QString& path) {
+	QObject::connect(&this->socket, &QLocalSocket::connected, this, &IpcClient::connected);
+	QObject::connect(&this->socket, &QLocalSocket::disconnected, this, &IpcClient::disconnected);
+	QObject::connect(&this->socket, &QLocalSocket::errorOccurred, this, &IpcClient::onError);
+
+	this->socket.connectToServer(path);
+	this->stream.setDevice(&this->socket);
+}
+
+bool IpcClient::isConnected() const { return this->socket.isValid(); }
+
+void IpcClient::waitForConnected() { this->socket.waitForConnected(); }
+void IpcClient::waitForDisconnected() { this->socket.waitForDisconnected(); }
+
+void IpcClient::kill() { this->sendMessage(IpcCommand(IpcKillCommand())); }
+
+void IpcClient::onError(QLocalSocket::LocalSocketError error) {
+	qCCritical(logIpc) << "Socket Error" << error;
+}
+
+int IpcClient::connect(const QString& id, const std::function<void(IpcClient& client)>& callback) {
+	auto path = QsPaths::ipcPath(id);
+	auto client = IpcClient(path);
+	qCDebug(logIpc) << "Connecting to instance" << id << "at" << path;
+
+	client.waitForConnected();
+	if (!client.isConnected()) return -1;
+	qCDebug(logIpc) << "Connected.";
+
+	callback(client);
+	return 0;
+}
+
+void IpcKillCommand::exec(IpcServerConnection* /*unused*/) {
+	qInfo() << "Exiting due to IPC request.";
+	EngineGeneration::currentGeneration()->quit();
+}
+
+} // namespace qs::ipc
diff --git a/src/ipc/ipc.hpp b/src/ipc/ipc.hpp
new file mode 100644
index 00000000..8ad4c42e
--- /dev/null
+++ b/src/ipc/ipc.hpp
@@ -0,0 +1,222 @@
+#pragma once
+
+#include <cmath>
+#include <functional>
+#include <limits>
+#include <utility>
+#include <variant>
+
+#include <qflags.h>
+#include <qlocalserver.h>
+#include <qlocalsocket.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../core/logcat.hpp"
+
+template <typename... Types>
+constexpr void assertSerializable() {
+	// monostate being zero ensures transactional reads wont break
+	static_assert(
+	    std::is_same_v<std::variant_alternative_t<0, std::variant<Types...>>, std::monostate>,
+	    "Serialization of variants without std::monostate at index 0 is disallowed."
+	);
+
+	static_assert(
+	    sizeof...(Types) <= std::numeric_limits<quint8>::max(),
+	    "Serialization of variants that can't fit the tag in a uint8 is disallowed."
+	);
+}
+
+template <typename... Types>
+QDataStream& operator<<(QDataStream& stream, const std::variant<Types...>& variant) {
+	assertSerializable<Types...>();
+
+	if (variant.valueless_by_exception()) {
+		stream << static_cast<quint8>(0); // must be monostate
+	} else {
+		stream << static_cast<quint8>(variant.index());
+		std::visit([&]<typename T>(const T& value) { stream << value; }, variant);
+	}
+
+	return stream;
+}
+
+template <typename... Types>
+constexpr bool forEachTypeIndex(const auto& f) {
+	return [&]<size_t... Index>(std::index_sequence<Index...>) {
+		return (f(std::in_place_index_t<Index>()) || ...);
+	}(std::index_sequence_for<Types...>());
+}
+
+template <typename... Types>
+std::variant<Types...> createIndexedOrMonostate(size_t index, std::variant<Types...>& variant) {
+	assertSerializable<Types...>();
+
+	const auto initialized =
+	    forEachTypeIndex<Types...>([index, &variant]<size_t Index>(std::in_place_index_t<Index>) {
+		    if (index == Index) {
+			    variant.template emplace<Index>();
+			    return true;
+		    } else {
+			    return false;
+		    }
+	    });
+
+	if (!initialized) {
+		variant = std::monostate();
+	}
+
+	return variant;
+}
+
+template <typename... Types>
+QDataStream& operator>>(QDataStream& stream, std::variant<Types...>& variant) {
+	assertSerializable<Types...>();
+
+	quint8 index = 0;
+	stream >> index;
+
+	createIndexedOrMonostate<Types...>(index, variant);
+	std::visit([&]<typename T>(T& value) { stream >> value; }, variant);
+
+	return stream;
+}
+
+template <typename... Types>
+QDataStream& streamInValues(QDataStream& stream, const Types&... types) {
+	return (stream << ... << types);
+}
+
+template <typename... Types>
+QDataStream& streamOutValues(QDataStream& stream, Types&... types) {
+	return (stream >> ... >> types);
+}
+
+// NOLINTBEGIN
+#define DEFINE_SIMPLE_DATASTREAM_OPS(Type, ...)                                                    \
+	inline QDataStream& operator<<(QDataStream& stream, const Type& __VA_OPT__(data)) {              \
+		return streamInValues(stream __VA_OPT__(, __VA_ARGS__));                                       \
+	}                                                                                                \
+                                                                                                   \
+	inline QDataStream& operator>>(QDataStream& stream, Type& __VA_OPT__(data)) {                    \
+		return streamOutValues(stream __VA_OPT__(, __VA_ARGS__));                                      \
+	}
+// NOLINTEND
+
+DEFINE_SIMPLE_DATASTREAM_OPS(std::monostate);
+
+namespace qs::ipc {
+
+QS_DECLARE_LOGGING_CATEGORY(logIpc);
+
+template <typename T>
+class MessageStream {
+public:
+	explicit MessageStream(QDataStream* stream, QLocalSocket* socket)
+	    : stream(stream)
+	    , socket(socket) {}
+
+	template <typename V>
+	MessageStream& operator<<(V value) {
+		*this->stream << T(value);
+		this->socket->flush();
+		return *this;
+	}
+
+private:
+	QDataStream* stream;
+	QLocalSocket* socket;
+};
+
+class IpcServer: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit IpcServer(const QString& path);
+
+	static void start();
+
+private slots:
+	void onNewConnection();
+
+private:
+	QLocalServer server;
+};
+
+class IpcServerConnection: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit IpcServerConnection(QLocalSocket* socket, IpcServer* server);
+
+	template <typename T>
+	void respond(const T& message) {
+		this->stream << message;
+		this->socket->flush();
+	}
+
+	template <typename T>
+	MessageStream<T> responseStream() {
+		return MessageStream<T>(&this->stream, this->socket);
+	}
+
+	// public for access by nonlocal handlers
+	QLocalSocket* socket;
+	QDataStream stream;
+
+private slots:
+	void onDisconnected();
+	void onReadyRead();
+};
+
+class IpcClient: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit IpcClient(const QString& path);
+
+	[[nodiscard]] bool isConnected() const;
+	void waitForConnected();
+	void waitForDisconnected();
+
+	void kill();
+
+	template <typename T>
+	void sendMessage(const T& message) {
+		this->stream << message;
+		this->socket.flush();
+	}
+
+	template <typename T>
+	bool waitForResponse(T& slot) {
+		while (this->socket.waitForReadyRead(-1)) {
+			this->stream.startTransaction();
+			this->stream >> slot;
+			if (!this->stream.commitTransaction()) continue;
+			return true;
+		}
+
+		qCCritical(logIpc) << "Error occurred while waiting for response.";
+		return false;
+	}
+
+	[[nodiscard]] static int
+	connect(const QString& id, const std::function<void(IpcClient& client)>& callback);
+
+	// public for access by nonlocal handlers
+	QLocalSocket socket;
+	QDataStream stream;
+
+signals:
+	void connected();
+	void disconnected();
+
+private slots:
+	static void onError(QLocalSocket::LocalSocketError error);
+};
+
+} // namespace qs::ipc
diff --git a/src/ipc/ipccommand.hpp b/src/ipc/ipccommand.hpp
new file mode 100644
index 00000000..b221b460
--- /dev/null
+++ b/src/ipc/ipccommand.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <variant>
+
+#include "../io/ipccomm.hpp"
+#include "ipc.hpp"
+
+namespace qs::ipc {
+
+struct IpcKillCommand: std::monostate {
+	static void exec(IpcServerConnection* /*unused*/);
+};
+
+using IpcCommand = std::variant<
+    std::monostate,
+    IpcKillCommand,
+    qs::io::ipc::comm::QueryMetadataCommand,
+    qs::io::ipc::comm::StringCallCommand,
+    qs::io::ipc::comm::StringPropReadCommand>;
+
+} // namespace qs::ipc
diff --git a/src/launch/CMakeLists.txt b/src/launch/CMakeLists.txt
new file mode 100644
index 00000000..4db11bf0
--- /dev/null
+++ b/src/launch/CMakeLists.txt
@@ -0,0 +1,23 @@
+find_package(CLI11 CONFIG REQUIRED)
+
+qt_add_library(quickshell-launch STATIC
+	parsecommand.cpp
+	command.cpp
+	launch.cpp
+	main.cpp
+)
+
+target_link_libraries(quickshell-launch PRIVATE
+	Qt::Quick Qt::Widgets CLI11::CLI11 quickshell-build
+)
+
+qs_add_pchset(launch
+	DEPENDENCIES Qt::Core CLI11::CLI11
+	HEADERS
+		<CLI/App.hpp>
+		<qcoreapplication.h>
+)
+
+qs_pch(quickshell-launch SET launch)
+
+target_link_libraries(quickshell PRIVATE quickshell-launch)
diff --git a/src/launch/command.cpp b/src/launch/command.cpp
new file mode 100644
index 00000000..8a9c6de1
--- /dev/null
+++ b/src/launch/command.cpp
@@ -0,0 +1,548 @@
+#include <algorithm>
+#include <array>
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+#include <utility>
+
+#include <qconfig.h>
+#include <qcontainerfwd.h>
+#include <qcoreapplication.h>
+#include <qcryptographichash.h>
+#include <qdatetime.h>
+#include <qdebug.h>
+#include <qdir.h>
+#include <qfileinfo.h>
+#include <qjsonarray.h>
+#include <qjsondocument.h>
+#include <qjsonobject.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qnamespace.h>
+#include <qstandardpaths.h>
+#include <qtenvironmentvariables.h>
+#include <qtversion.h>
+#include <unistd.h>
+
+#include "../core/instanceinfo.hpp"
+#include "../core/logging.hpp"
+#include "../core/paths.hpp"
+#include "../io/ipccomm.hpp"
+#include "../ipc/ipc.hpp"
+#include "build.hpp"
+#include "launch_p.hpp"
+
+namespace qs::launch {
+
+using qs::ipc::IpcClient;
+
+namespace {
+
+QList<QString> configBaseDirs() {
+	auto configHome = qEnvironmentVariable("XDG_CONFIG_HOME");
+	if (configHome.isEmpty()) {
+		auto home = QDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
+		configHome = QDir(home).filePath(".config");
+	}
+
+	auto configDirs = qEnvironmentVariable("XDG_CONFIG_DIRS").split(':', Qt::SkipEmptyParts);
+	if (configDirs.isEmpty()) {
+		configDirs.append("/etc/xdg");
+	}
+
+	configDirs.prepend(configHome);
+
+	for (auto& dir: configDirs) {
+		dir.append("/quickshell");
+	}
+
+	return configDirs;
+}
+
+QString locateNamedConfig(const QString& name) {
+	for (const auto& baseDir: configBaseDirs()) {
+		auto shellPath = QDir(baseDir).filePath("shell.qml");
+		auto hasShell = QFileInfo(shellPath).isFile();
+
+		if (hasShell) {
+			if (name == "default") return shellPath;
+			else continue; // skip subfolders if shell.qml is present in folder
+		}
+
+		shellPath = QDir(QDir(baseDir).filePath(name)).filePath("shell.qml");
+		if (QFileInfo(shellPath).isFile()) return shellPath;
+	}
+
+	return QString();
+}
+
+int locateConfigFile(CommandState& cmd, QString& path) {
+	if (!cmd.config.path->isEmpty()) {
+		path = *cmd.config.path;
+	} else {
+		auto manifestPath = *cmd.config.manifest;
+		if (manifestPath.isEmpty()) {
+			auto configDir = QDir(QStandardPaths::writableLocation(QStandardPaths::AppConfigLocation));
+			auto path = configDir.filePath("manifest.conf");
+			if (QFileInfo(path).isFile()) manifestPath = path;
+		}
+
+		if (!manifestPath.isEmpty()) {
+			qWarning(
+			) << "Config manifests (manifest.conf) are deprecated and will be removed in a future "
+			     "release.";
+			qWarning() << "Consider using symlinks to a subfolder of quickshell's XDG config dirs.";
+
+			auto file = QFile(manifestPath);
+			if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+				auto stream = QTextStream(&file);
+				while (!stream.atEnd()) {
+					auto line = stream.readLine();
+					if (line.trimmed().startsWith("#")) continue;
+					if (line.trimmed().isEmpty()) continue;
+
+					auto split = line.split('=');
+					if (split.length() != 2) {
+						qCritical() << "Manifest line not in expected format 'name = relativepath':" << line;
+						return -1;
+					}
+
+					if (split[0].trimmed() == *cmd.config.name) {
+						path = QDir(QFileInfo(file).canonicalPath()).filePath(split[1].trimmed());
+						break;
+					}
+				}
+
+				if (path.isEmpty()) {
+					qCCritical(logBare) << "Configuration" << *cmd.config.name
+					                    << "not found when searching manifest" << manifestPath;
+					return -1;
+				}
+			} else {
+				qCCritical(logBare) << "Could not open maifest at path" << *cmd.config.manifest;
+				return -1;
+			}
+		} else {
+			const auto& name = cmd.config.name->isEmpty() ? "default" : *cmd.config.name;
+			path = locateNamedConfig(name);
+
+			if (path.isEmpty()) {
+				if (name == "default") {
+					qCCritical(logBare
+					) << "Could not find \"default\" config directory or shell.qml in any valid config path.";
+				} else {
+					qCCritical(logBare) << "Could not find" << name
+					                    << "config directory in any valid config path.";
+				}
+
+				return -1;
+			}
+
+			path = QFileInfo(path).canonicalFilePath();
+			return 0;
+		}
+	}
+
+	if (QFileInfo(path).isDir()) {
+		path = QDir(path).filePath("shell.qml");
+	}
+
+	if (!QFileInfo(path).isFile()) {
+		qCCritical(logBare) << "Could not open config file at" << path;
+		return -1;
+	}
+
+	path = QFileInfo(path).canonicalFilePath();
+	return 0;
+}
+
+void sortInstances(QVector<InstanceLockInfo>& list, bool newestFirst) {
+	std::ranges::sort(list, [=](const InstanceLockInfo& a, const InstanceLockInfo& b) {
+		auto r = a.instance.launchTime < b.instance.launchTime;
+		return newestFirst ? !r : r;
+	});
+};
+
+int selectInstance(CommandState& cmd, InstanceLockInfo* instance, bool deadFallback = false) {
+	auto* basePath = QsPaths::instance()->baseRunDir();
+	if (!basePath) return -1;
+
+	QString path;
+
+	if (cmd.instance.pid != -1) {
+		path = QDir(basePath->filePath("by-pid")).filePath(QString::number(cmd.instance.pid));
+		if (!QsPaths::checkLock(path, instance, deadFallback)) {
+			qCInfo(logBare) << "No instance found for pid" << cmd.instance.pid;
+			return -1;
+		}
+	} else if (!cmd.instance.id->isEmpty()) {
+		path = basePath->filePath("by-pid");
+		auto [liveInstances, deadInstances] = QsPaths::collectInstances(path);
+
+		liveInstances.removeIf([&](const InstanceLockInfo& info) {
+			return !info.instance.instanceId.startsWith(*cmd.instance.id);
+		});
+
+		deadInstances.removeIf([&](const InstanceLockInfo& info) {
+			return !info.instance.instanceId.startsWith(*cmd.instance.id);
+		});
+
+		auto instances = liveInstances.isEmpty() && deadFallback ? deadInstances : liveInstances;
+
+		if (instances.isEmpty()) {
+			if (deadFallback) {
+				qCInfo(logBare) << "No instances start with" << *cmd.instance.id;
+			} else {
+				qCInfo(logBare) << "No running instances start with" << *cmd.instance.id;
+
+				if (!deadInstances.isEmpty()) {
+					qCInfo(logBare) << "Some dead instances match:";
+
+					for (auto& instance: deadInstances) {
+						qCInfo(logBare).noquote() << " -" << instance.instance.instanceId;
+					}
+				}
+			}
+
+			return -1;
+		} else if (instances.length() != 1) {
+			qCInfo(logBare) << "More than one instance starts with" << *cmd.instance.id;
+
+			for (auto& instance: instances) {
+				qCInfo(logBare).noquote() << " -" << instance.instance.instanceId
+				                          << (instance.pid == -1 ? " (dead)" : "");
+			}
+
+			return -1;
+		} else {
+			*instance = instances.value(0);
+		}
+	} else {
+		QString configFilePath;
+		auto r = locateConfigFile(cmd, configFilePath);
+		if (r != 0) return r;
+
+		auto pathId =
+		    QCryptographicHash::hash(configFilePath.toUtf8(), QCryptographicHash::Md5).toHex();
+
+		path = QDir(basePath->filePath("by-path")).filePath(pathId);
+
+		auto [liveInstances, deadInstances] = QsPaths::collectInstances(path);
+
+		auto instances = liveInstances;
+		if (instances.isEmpty() && deadFallback) {
+			instances = deadInstances;
+		}
+
+		sortInstances(
+		    instances,
+		    cmd.config.newest || (!instances.empty() && instances.first().pid == -1)
+		);
+
+		if (instances.isEmpty()) {
+			if (liveInstances.isEmpty() && deadInstances.length() > 1) {
+				qCInfo(logBare) << "No running instances for" << configFilePath;
+				qCInfo(logBare) << "Dead instances:";
+				sortInstances(deadInstances, cmd.config.newest);
+				for (auto& instance: deadInstances) {
+					qCInfo(logBare).noquote() << " -" << instance.instance.instanceId;
+				}
+			} else {
+				qCInfo(logBare) << "No running instances for" << configFilePath;
+			}
+			return -1;
+		}
+
+		*instance = instances.value(0);
+	}
+
+	return 0;
+}
+
+int readLogFile(CommandState& cmd) {
+	auto path = *cmd.log.file;
+
+	if (path.isEmpty()) {
+		InstanceLockInfo instance;
+		auto r = selectInstance(cmd, &instance, true);
+		if (r != 0) return r;
+
+		path = QDir(QsPaths::basePath(instance.instance.instanceId)).filePath("log.qslog");
+	}
+
+	auto file = QFile(path);
+	if (!file.open(QFile::ReadOnly)) {
+		qCCritical(logBare) << "Failed to open log file" << path;
+		return -1;
+	}
+
+	return qs::log::readEncodedLogs(
+	           &file,
+	           path,
+	           cmd.log.timestamp,
+	           cmd.log.tail,
+	           cmd.log.follow,
+	           *cmd.log.readoutRules
+	       )
+	         ? 0
+	         : -1;
+}
+
+int listInstances(CommandState& cmd) {
+	auto* basePath = QsPaths::instance()->baseRunDir();
+	if (!basePath) return -1; // NOLINT
+
+	QString path;
+	QString configFilePath;
+	if (cmd.instance.all) {
+		path = basePath->filePath("by-pid");
+	} else {
+		auto r = locateConfigFile(cmd, configFilePath);
+
+		if (r != 0) {
+			qCInfo(logBare) << "Use --all to list all instances.";
+			return r;
+		}
+
+		auto pathId =
+		    QCryptographicHash::hash(configFilePath.toUtf8(), QCryptographicHash::Md5).toHex();
+
+		path = QDir(basePath->filePath("by-path")).filePath(pathId);
+	}
+
+	auto [liveInstances, deadInstances] = QsPaths::collectInstances(path);
+
+	sortInstances(liveInstances, cmd.config.newest);
+
+	QList<InstanceLockInfo> instances;
+	if (cmd.instance.includeDead) {
+		sortInstances(deadInstances, cmd.config.newest);
+		instances = std::move(deadInstances);
+		instances.append(liveInstances);
+	} else {
+		instances = std::move(liveInstances);
+	}
+
+	if (instances.isEmpty()) {
+		if (cmd.instance.all) {
+			qCInfo(logBare) << "No running instances.";
+		} else {
+			qCInfo(logBare) << "No running instances for" << configFilePath;
+			qCInfo(logBare) << "Use --all to list all instances.";
+		}
+	} else {
+
+		if (cmd.output.json) {
+			auto array = QJsonArray();
+
+			for (auto& instance: instances) {
+				auto json = QJsonObject();
+
+				json["id"] = instance.instance.instanceId;
+				json["pid"] = instance.instance.pid;
+				json["shell_id"] = instance.instance.shellId;
+				json["config_path"] = instance.instance.configPath;
+				json["launch_time"] = instance.instance.launchTime.toString(Qt::ISODate);
+
+				array.push_back(json);
+			}
+
+			auto document = QJsonDocument(array);
+			QTextStream(stdout) << document.toJson(QJsonDocument::Indented);
+		} else {
+			for (auto& instance: instances) {
+				auto launchTimeStr = instance.instance.launchTime.toString("yyyy-MM-dd hh:mm:ss");
+
+				auto runSeconds = instance.instance.launchTime.secsTo(QDateTime::currentDateTime());
+				auto remSeconds = runSeconds % 60;
+				auto runMinutes = (runSeconds - remSeconds) / 60;
+				auto remMinutes = runMinutes % 60;
+				auto runHours = (runMinutes - remMinutes) / 60;
+				auto runtimeStr = QString("%1 hours, %2 minutes, %3 seconds")
+				                      .arg(runHours)
+				                      .arg(remMinutes)
+				                      .arg(remSeconds);
+
+				auto isDead = instance.pid == -1;
+				auto gray = !cmd.log.noColor && isDead;
+
+				qCInfo(logBare).noquote().nospace()
+				    << (gray ? "\033[90m" : "") << "Instance " << instance.instance.instanceId
+				    << (isDead ? " (dead)" : "") << ":\n"
+				    << "  Process ID: " << instance.instance.pid << '\n'
+				    << "  Shell ID: " << instance.instance.shellId << '\n'
+				    << "  Config path: " << instance.instance.configPath << '\n'
+				    << "  Launch time: " << launchTimeStr
+				    << (isDead ? "" : " (running for " + runtimeStr + ")") << '\n'
+				    << (gray ? "\033[0m" : "");
+			}
+		}
+	}
+
+	return 0;
+}
+
+int killInstances(CommandState& cmd) {
+	InstanceLockInfo instance;
+	auto r = selectInstance(cmd, &instance);
+	if (r != 0) return r;
+
+	return IpcClient::connect(instance.instance.instanceId, [&](IpcClient& client) {
+		client.kill();
+		qCInfo(logBare).noquote() << "Killed" << instance.instance.instanceId;
+	});
+}
+
+int ipcCommand(CommandState& cmd) {
+	InstanceLockInfo instance;
+	auto r = selectInstance(cmd, &instance);
+	if (r != 0) return r;
+
+	return IpcClient::connect(instance.instance.instanceId, [&](IpcClient& client) {
+		if (*cmd.ipc.show || cmd.ipc.showOld) {
+			return qs::io::ipc::comm::queryMetadata(&client, *cmd.ipc.target, *cmd.ipc.name);
+		} else if (*cmd.ipc.getprop) {
+			return qs::io::ipc::comm::getProperty(&client, *cmd.ipc.target, *cmd.ipc.name);
+		} else {
+			QVector<QString> arguments;
+			for (auto& arg: cmd.ipc.arguments) {
+				arguments += *arg;
+			}
+
+			return qs::io::ipc::comm::callFunction(&client, *cmd.ipc.target, *cmd.ipc.name, arguments);
+		}
+
+		return -1;
+	});
+}
+
+int launchFromCommand(CommandState& cmd, QCoreApplication* coreApplication) {
+	QString configPath;
+
+	auto r = locateConfigFile(cmd, configPath);
+	if (r != 0) return r;
+
+	{
+		InstanceLockInfo info;
+		if (cmd.misc.noDuplicate && selectInstance(cmd, &info) == 0) {
+			qCInfo(logBare) << "An instance of this configuration is already running.";
+			return 0;
+		}
+	}
+
+	return launch(
+	    {
+	        .configPath = configPath,
+	        .debugPort = cmd.debug.port,
+	        .waitForDebug = cmd.debug.wait,
+	    },
+	    cmd.exec.argv,
+	    coreApplication
+	);
+}
+
+} // namespace
+
+int runCommand(int argc, char** argv, QCoreApplication* coreApplication) {
+	auto state = CommandState();
+	if (auto ret = parseCommand(argc, argv, state); ret != 65535) return ret;
+
+	if (state.misc.checkCompat) {
+		if (strcmp(qVersion(), QT_VERSION_STR) != 0) {
+			QTextStream(stdout) << "\033[31mCOMPATIBILITY WARNING: Quickshell was built against Qt "
+			                    << QT_VERSION_STR << " but the system has updated to Qt " << qVersion()
+			                    << " without rebuilding the package. This is likely to cause crashes, so "
+			                       "you must rebuild the quickshell package.\n";
+			return 1;
+		}
+
+		return 0;
+	}
+
+	// Has to happen before extra threads are spawned.
+	if (state.misc.daemonize) {
+		auto closepipes = std::array<int, 2>();
+		if (pipe(closepipes.data()) == -1) {
+			qFatal().nospace() << "Failed to create messaging pipes for daemon with error " << errno
+			                   << ": " << qt_error_string();
+		}
+
+		pid_t pid = fork(); // NOLINT (include)
+
+		if (pid == -1) {
+			qFatal().nospace() << "Failed to fork daemon with error " << errno << ": "
+			                   << qt_error_string();
+		} else if (pid == 0) {
+			DAEMON_PIPE = closepipes[1];
+			close(closepipes[0]);
+
+			if (setsid() == -1) {
+				qFatal().nospace() << "Failed to setsid with error " << errno << ": " << qt_error_string();
+			}
+		} else {
+			close(closepipes[1]);
+
+			int ret = 0;
+			if (read(closepipes[0], &ret, sizeof(int)) == -1) {
+				qFatal() << "Failed to wait for daemon launch (it may have crashed)";
+			}
+
+			return ret;
+		}
+	}
+
+	{
+		auto level = state.log.verbosity == 0 ? QtWarningMsg
+		           : state.log.verbosity == 1 ? QtInfoMsg
+		                                      : QtDebugMsg;
+
+		LogManager::init(
+		    !state.log.noColor,
+		    state.log.timestamp,
+		    state.log.sparse,
+		    level,
+		    *state.log.rules,
+		    *state.subcommand.log ? "READER" : ""
+		);
+	}
+
+	if (state.misc.printVersion) {
+		qCInfo(logBare).noquote().nospace()
+		    << "quickshell 0.2.0, revision " << GIT_REVISION << ", distributed by: " << DISTRIBUTOR;
+
+		if (state.log.verbosity > 1) {
+			qCInfo(logBare).noquote() << "\nBuildtime Qt Version:" << QT_VERSION_STR;
+			qCInfo(logBare).noquote() << "Runtime Qt Version:" << qVersion();
+			qCInfo(logBare).noquote() << "Compiler:" << COMPILER;
+			qCInfo(logBare).noquote() << "Compile Flags:" << COMPILE_FLAGS;
+		}
+
+		if (state.log.verbosity > 0) {
+			qCInfo(logBare).noquote() << "\nBuild Type:" << BUILD_TYPE;
+			qCInfo(logBare).noquote() << "Build configuration:";
+			qCInfo(logBare).noquote().nospace() << BUILD_CONFIGURATION;
+		}
+	} else if (*state.subcommand.log) {
+		return readLogFile(state);
+	} else if (*state.subcommand.list) {
+		return listInstances(state);
+	} else if (*state.subcommand.kill) {
+		return killInstances(state);
+	} else if (*state.subcommand.msg || *state.ipc.ipc) {
+		return ipcCommand(state);
+	} else {
+		if (strcmp(qVersion(), QT_VERSION_STR) != 0) {
+			qWarning() << "\033[31mQuickshell was built against Qt" << QT_VERSION_STR
+			           << "but the system has updated to Qt" << qVersion()
+			           << "without rebuilding the package. This is likely to cause crashes, so "
+			              "the quickshell package must be rebuilt.\n";
+		}
+
+		return launchFromCommand(state, coreApplication);
+	}
+
+	return 0;
+}
+
+} // namespace qs::launch
diff --git a/src/launch/launch.cpp b/src/launch/launch.cpp
new file mode 100644
index 00000000..fd6a0af7
--- /dev/null
+++ b/src/launch/launch.cpp
@@ -0,0 +1,261 @@
+#include <qapplication.h>
+#include <qcoreapplication.h>
+#include <qcryptographichash.h>
+#include <qdebug.h>
+#include <qdir.h>
+#include <qfile.h>
+#include <qguiapplication.h>
+#include <qhash.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qnamespace.h>
+#include <qprocess.h>
+#include <qqmldebug.h>
+#include <qquickwindow.h>
+#include <qstring.h>
+#include <qtenvironmentvariables.h>
+#include <qtextstream.h>
+#include <unistd.h>
+
+#include "../core/common.hpp"
+#include "../core/instanceinfo.hpp"
+#include "../core/logging.hpp"
+#include "../core/paths.hpp"
+#include "../core/plugin.hpp"
+#include "../core/rootwrapper.hpp"
+#include "../ipc/ipc.hpp"
+#include "build.hpp"
+#include "launch_p.hpp"
+
+#if CRASH_REPORTER
+#include "../crash/handler.hpp"
+#endif
+
+namespace qs::launch {
+
+namespace {
+
+template <typename T>
+QString base36Encode(T number) {
+	const QString digits = "0123456789abcdefghijklmnopqrstuvwxyz";
+	QString result;
+
+	do {
+		result.prepend(digits[number % 36]);
+		number /= 36;
+	} while (number > 0);
+
+	for (auto i = 0; i < result.length() / 2; i++) {
+		auto opposite = result.length() - i - 1;
+		auto c = result.at(i);
+		result[i] = result.at(opposite);
+		result[opposite] = c;
+	}
+
+	return result;
+}
+
+} // namespace
+
+int launch(const LaunchArgs& args, char** argv, QCoreApplication* coreApplication) {
+	auto pathId = QCryptographicHash::hash(args.configPath.toUtf8(), QCryptographicHash::Md5).toHex();
+	auto shellId = QString(pathId);
+
+	qInfo() << "Launching config:" << args.configPath;
+
+	auto file = QFile(args.configPath);
+	if (!file.open(QFile::ReadOnly | QFile::Text)) {
+		qCritical() << "Could not open config file" << args.configPath;
+		return -1;
+	}
+
+	struct {
+		bool useQApplication = false;
+		bool nativeTextRendering = false;
+		bool desktopSettingsAware = true;
+		bool useSystemStyle = false;
+		QString iconTheme = qEnvironmentVariable("QS_ICON_THEME");
+		QHash<QString, QString> envOverrides;
+		QString dataDir;
+		QString stateDir;
+	} pragmas;
+
+	auto stream = QTextStream(&file);
+	while (!stream.atEnd()) {
+		auto line = stream.readLine().trimmed();
+		if (line.startsWith("//@ pragma ")) {
+			auto pragma = line.sliced(11).trimmed();
+
+			if (pragma == "UseQApplication") pragmas.useQApplication = true;
+			else if (pragma == "NativeTextRendering") pragmas.nativeTextRendering = true;
+			else if (pragma == "IgnoreSystemSettings") pragmas.desktopSettingsAware = false;
+			else if (pragma == "RespectSystemStyle") pragmas.useSystemStyle = true;
+			else if (pragma.startsWith("IconTheme ")) pragmas.iconTheme = pragma.sliced(10);
+			else if (pragma.startsWith("Env ")) {
+				auto envPragma = pragma.sliced(4);
+				auto splitIdx = envPragma.indexOf('=');
+
+				if (splitIdx == -1) {
+					qCritical() << "Env pragma" << pragma << "not in the form 'VAR = VALUE'";
+					return -1;
+				}
+
+				auto var = envPragma.sliced(0, splitIdx).trimmed();
+				auto val = envPragma.sliced(splitIdx + 1).trimmed();
+				pragmas.envOverrides.insert(var, val);
+			} else if (pragma.startsWith("ShellId ")) {
+				shellId = pragma.sliced(8).trimmed();
+			} else if (pragma.startsWith("DataDir ")) {
+				pragmas.dataDir = pragma.sliced(8).trimmed();
+			} else if (pragma.startsWith("StateDir ")) {
+				pragmas.stateDir = pragma.sliced(9).trimmed();
+			} else {
+				qCritical() << "Unrecognized pragma" << pragma;
+				return -1;
+			}
+		} else if (line.startsWith("import")) break;
+	}
+
+	file.close();
+
+	if (!pragmas.iconTheme.isEmpty()) {
+		QIcon::setThemeName(pragmas.iconTheme);
+	}
+
+	qInfo() << "Shell ID:" << shellId << "Path ID" << pathId;
+
+	auto launchTime = qs::Common::LAUNCH_TIME.toSecsSinceEpoch();
+	InstanceInfo::CURRENT = InstanceInfo {
+	    .instanceId = base36Encode(getpid()) + base36Encode(launchTime),
+	    .configPath = args.configPath,
+	    .shellId = shellId,
+	    .launchTime = qs::Common::LAUNCH_TIME,
+	    .pid = getpid(),
+	};
+
+#if CRASH_REPORTER
+	auto crashHandler = crash::CrashHandler();
+	crashHandler.init();
+
+	{
+		auto* log = LogManager::instance();
+		crashHandler.setRelaunchInfo({
+		    .instance = InstanceInfo::CURRENT,
+		    .noColor = !log->colorLogs,
+		    .timestamp = log->timestampLogs,
+		    .sparseLogsOnly = log->isSparse(),
+		    .defaultLogLevel = log->defaultLevel(),
+		    .logRules = log->rulesString(),
+		});
+	}
+#endif
+
+	QsPaths::init(shellId, pathId, pragmas.dataDir, pragmas.stateDir);
+	QsPaths::instance()->linkRunDir();
+	QsPaths::instance()->linkPathDir();
+	LogManager::initFs();
+
+	Common::INITIAL_ENVIRONMENT = QProcessEnvironment::systemEnvironment();
+
+	if (!pragmas.useSystemStyle) {
+		qunsetenv("QT_STYLE_OVERRIDE");
+		qputenv("QT_QUICK_CONTROLS_STYLE", "Fusion");
+	}
+
+	for (auto [var, val]: pragmas.envOverrides.asKeyValueRange()) {
+		qputenv(var.toUtf8(), val.toUtf8());
+	}
+
+	// The qml engine currently refuses to cache non file (qsintercept) paths.
+
+	// if (auto* cacheDir = QsPaths::instance()->cacheDir()) {
+	// 	auto qmlCacheDir = cacheDir->filePath("qml-engine-cache");
+	// 	qputenv("QML_DISK_CACHE_PATH", qmlCacheDir.toLocal8Bit());
+	//
+	// 	if (!qEnvironmentVariableIsSet("QML_DISK_CACHE")) {
+	// 		qputenv("QML_DISK_CACHE", "aot,qmlc");
+	// 	}
+	// }
+
+	// While the simple animation driver can lead to better animations in some cases,
+	// it also can cause excessive repainting at excessively high framerates which can
+	// lead to noticeable amounts of gpu usage, including overheating on some systems.
+	// This gets worse the more windows are open, as repaints trigger on all of them for
+	// some reason. See QTBUG-126099 for details.
+
+	// if (!qEnvironmentVariableIsSet("QSG_USE_SIMPLE_ANIMATION_DRIVER")) {
+	// 	qputenv("QSG_USE_SIMPLE_ANIMATION_DRIVER", "1");
+	// }
+
+	// Some programs place icons in the pixmaps folder instead of the icons folder.
+	// This seems to be controlled by the QPA and qt6ct does not provide it.
+	{
+		QList<QString> dataPaths;
+
+		if (qEnvironmentVariableIsSet("XDG_DATA_DIRS")) {
+			auto var = qEnvironmentVariable("XDG_DATA_DIRS");
+			dataPaths = var.split(u':', Qt::SkipEmptyParts);
+		} else {
+			dataPaths.push_back("/usr/local/share");
+			dataPaths.push_back("/usr/share");
+		}
+
+		auto fallbackPaths = QIcon::fallbackSearchPaths();
+
+		for (auto& path: dataPaths) {
+			auto newPath = QDir(path).filePath("pixmaps");
+
+			if (!fallbackPaths.contains(newPath)) {
+				fallbackPaths.push_back(newPath);
+			}
+		}
+
+		QIcon::setFallbackSearchPaths(fallbackPaths);
+	}
+
+	QGuiApplication::setDesktopSettingsAware(pragmas.desktopSettingsAware);
+
+	delete coreApplication;
+
+	QGuiApplication* app = nullptr;
+	auto qArgC = 0;
+
+	if (pragmas.useQApplication) {
+		app = new QApplication(qArgC, argv);
+	} else {
+		app = new QGuiApplication(qArgC, argv);
+	}
+
+	QGuiApplication::setDesktopFileName("org.quickshell");
+
+	if (args.debugPort != -1) {
+		QQmlDebuggingEnabler::enableDebugging(true);
+		auto wait = args.waitForDebug ? QQmlDebuggingEnabler::WaitForClient
+		                              : QQmlDebuggingEnabler::DoNotWaitForClient;
+		QQmlDebuggingEnabler::startTcpDebugServer(args.debugPort, wait);
+	}
+
+	QsEnginePlugin::initPlugins();
+
+	// Base window transparency appears to be additive.
+	// Use a fully transparent window with a colored rect.
+	QQuickWindow::setDefaultAlphaBuffer(true);
+
+	if (pragmas.nativeTextRendering) {
+		QQuickWindow::setTextRenderType(QQuickWindow::NativeTextRendering);
+	}
+
+	qs::ipc::IpcServer::start();
+	QsPaths::instance()->createLock();
+
+	auto root = RootWrapper(args.configPath, shellId);
+	QGuiApplication::setQuitOnLastWindowClosed(false);
+
+	exitDaemon(0);
+
+	auto code = QGuiApplication::exec();
+	delete app;
+	return code;
+}
+
+} // namespace qs::launch
diff --git a/src/launch/launch_p.hpp b/src/launch/launch_p.hpp
new file mode 100644
index 00000000..7b8fca68
--- /dev/null
+++ b/src/launch/launch_p.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include <CLI/App.hpp>
+#include <qcoreapplication.h>
+#include <qstring.h>
+
+namespace qs::launch {
+
+extern int DAEMON_PIPE; // NOLINT
+
+class QStringOption {
+public:
+	QStringOption() = default;
+	QStringOption& operator=(const std::string& str) {
+		this->str = QString::fromStdString(str);
+		return *this;
+	}
+
+	QString& operator*() { return this->str; }
+	QString* operator->() { return &this->str; }
+
+private:
+	QString str;
+};
+
+struct CommandState {
+	std::unique_ptr<CLI::App> app;
+	struct {
+		int argc = 0;
+		char** argv = nullptr;
+	} exec;
+
+	struct {
+		bool timestamp = false;
+		bool noColor = !qEnvironmentVariableIsEmpty("NO_COLOR");
+		bool sparse = false;
+		size_t verbosity = 0;
+		int tail = 0;
+		bool follow = false;
+		QStringOption rules;
+		QStringOption readoutRules;
+		QStringOption file;
+	} log;
+
+	struct {
+		QStringOption path;
+		QStringOption manifest;
+		QStringOption name;
+		bool newest = false;
+	} config;
+
+	struct {
+		int port = -1;
+		bool wait = false;
+	} debug;
+
+	struct {
+		QStringOption id;
+		pid_t pid = -1; // NOLINT (include)
+		bool all = false;
+		bool includeDead = false;
+	} instance;
+
+	struct {
+		bool json = false;
+	} output;
+
+	struct {
+		CLI::App* ipc = nullptr;
+		CLI::App* show = nullptr;
+		CLI::App* call = nullptr;
+		CLI::App* getprop = nullptr;
+		bool showOld = false;
+		QStringOption target;
+		QStringOption name;
+		std::vector<QStringOption> arguments;
+	} ipc;
+
+	struct {
+		CLI::App* log = nullptr;
+		CLI::App* list = nullptr;
+		CLI::App* kill = nullptr;
+		CLI::App* msg = nullptr;
+	} subcommand;
+
+	struct {
+		bool checkCompat = false;
+		bool printVersion = false;
+		bool killAll = false;
+		bool noDuplicate = false;
+		bool daemonize = false;
+	} misc;
+};
+
+struct LaunchArgs {
+	QString configPath;
+	int debugPort = -1;
+	bool waitForDebug = false;
+};
+
+void exitDaemon(int code);
+
+int parseCommand(int argc, char** argv, CommandState& state);
+int runCommand(int argc, char** argv, QCoreApplication* coreApplication);
+
+int launch(const LaunchArgs& args, char** argv, QCoreApplication* coreApplication);
+
+} // namespace qs::launch
diff --git a/src/launch/main.cpp b/src/launch/main.cpp
new file mode 100644
index 00000000..2bcbebd3
--- /dev/null
+++ b/src/launch/main.cpp
@@ -0,0 +1,118 @@
+#include "main.hpp"
+#include <cerrno>
+
+#include <fcntl.h>
+#include <qcoreapplication.h>
+#include <qdatastream.h>
+#include <qdatetime.h>
+#include <qdebug.h>
+#include <qlogging.h>
+#include <qtenvironmentvariables.h>
+#include <unistd.h>
+
+#include "../core/instanceinfo.hpp"
+#include "../core/logging.hpp"
+#include "../core/paths.hpp"
+#include "build.hpp"
+#include "launch_p.hpp"
+
+#if CRASH_REPORTER
+#include "../crash/main.hpp"
+#endif
+
+namespace qs::launch {
+
+namespace {
+
+void checkCrashRelaunch(char** argv, QCoreApplication* coreApplication) {
+#if CRASH_REPORTER
+	auto lastInfoFdStr = qEnvironmentVariable("__QUICKSHELL_CRASH_INFO_FD");
+
+	if (!lastInfoFdStr.isEmpty()) {
+		auto lastInfoFd = lastInfoFdStr.toInt();
+
+		QFile file;
+		file.open(lastInfoFd, QFile::ReadOnly, QFile::AutoCloseHandle);
+		file.seek(0);
+
+		auto ds = QDataStream(&file);
+		RelaunchInfo info;
+		ds >> info;
+
+		LogManager::init(
+		    !info.noColor,
+		    info.timestamp,
+		    info.sparseLogsOnly,
+		    info.defaultLogLevel,
+		    info.logRules
+		);
+
+		qCritical().nospace() << "Quickshell has crashed under pid "
+		                      << qEnvironmentVariable("__QUICKSHELL_CRASH_DUMP_PID").toInt()
+		                      << " (Coredumps will be available under that pid.)";
+
+		qCritical() << "Further crash information is stored under"
+		            << QsPaths::crashDir(info.instance.instanceId).path();
+
+		if (info.instance.launchTime.msecsTo(QDateTime::currentDateTime()) < 10000) {
+			qCritical() << "Quickshell crashed within 10 seconds of launching. Not restarting to avoid "
+			               "a crash loop.";
+			exit(-1); // NOLINT
+		} else {
+			qCritical() << "Quickshell has been restarted.";
+
+			launch({.configPath = info.instance.configPath}, argv, coreApplication);
+		}
+	}
+#endif
+}
+
+} // namespace
+
+int DAEMON_PIPE = -1; // NOLINT
+
+void exitDaemon(int code) {
+	if (DAEMON_PIPE == -1) return;
+
+	if (write(DAEMON_PIPE, &code, sizeof(int)) == -1) {
+		qCritical().nospace() << "Failed to write daemon exit command with error code " << errno << ": "
+		                      << qt_error_string();
+	}
+
+	close(DAEMON_PIPE);
+
+	close(STDIN_FILENO);
+	close(STDOUT_FILENO);
+	close(STDERR_FILENO);
+
+	if (open("/dev/null", O_RDONLY) != STDIN_FILENO) { // NOLINT
+		qFatal() << "Failed to open /dev/null on stdin";
+	}
+
+	if (open("/dev/null", O_WRONLY) != STDOUT_FILENO) { // NOLINT
+		qFatal() << "Failed to open /dev/null on stdout";
+	}
+
+	if (open("/dev/null", O_WRONLY) != STDERR_FILENO) { // NOLINT
+		qFatal() << "Failed to open /dev/null on stderr";
+	}
+}
+
+int main(int argc, char** argv) {
+	QCoreApplication::setApplicationName("quickshell");
+
+#if CRASH_REPORTER
+	qsCheckCrash(argc, argv);
+#endif
+
+	auto qArgC = 1;
+	auto* coreApplication = new QCoreApplication(qArgC, argv);
+
+	checkCrashRelaunch(argv, coreApplication);
+	auto code = runCommand(argc, argv, coreApplication);
+
+	exitDaemon(code);
+	return code;
+}
+
+} // namespace qs::launch
diff --git a/src/launch/main.hpp b/src/launch/main.hpp
new file mode 100644
index 00000000..e9d22902
--- /dev/null
+++ b/src/launch/main.hpp
@@ -0,0 +1,7 @@
+#pragma once
+
+namespace qs::launch {
+
+int main(int argc, char** argv);
+
+}
diff --git a/src/launch/parsecommand.cpp b/src/launch/parsecommand.cpp
new file mode 100644
index 00000000..fc16086e
--- /dev/null
+++ b/src/launch/parsecommand.cpp
@@ -0,0 +1,253 @@
+#include <cstddef>
+#include <limits>
+#include <memory>
+
+#include <CLI/App.hpp>
+#include <CLI/CLI.hpp> // NOLINT: Need to include this for impls of some CLI11 classes
+#include <CLI/Validators.hpp>
+
+#include "launch_p.hpp"
+
+namespace qs::launch {
+
+int parseCommand(int argc, char** argv, CommandState& state) {
+	state.exec = {
+	    .argc = argc,
+	    .argv = argv,
+	};
+
+	auto addConfigSelection = [&](CLI::App* cmd, bool withNewestOption = false) {
+		auto* group =
+		    cmd->add_option_group("Config Selection")
+		        ->description(
+		            "Quickshell detects configurations as named directories under each XDG config "
+		            "directory as `<xdg dir>/quickshell/<config name>/shell.qml`.\n\n"
+		            "If `<xdg dir>/quickshell/shell.qml` exists, it will be registered as the "
+		            "'default' configuration, and no subdirectories will be considered. "
+		            "If --config is not passed, 'default' will be assumed.\n\n"
+		            "Alternatively, a config can be selected by path with --path.\n\n"
+		            "Examples:\n"
+		            "- `~/.config/quickshell/shell.qml` can be run with `qs`\n"
+		            "- `/etc/xdg/quickshell/myconfig/shell.qml` can be run with `qs -c myconfig`\n"
+		            "- `~/myshell/shell.qml` can be run with `qs -p ~/myshell`\n"
+		            "- `~/myshell/randomfile.qml` can be run with `qs -p ~/myshell/randomfile.qml`"
+		        );
+
+		auto* path = group->add_option("-p,--path", state.config.path)
+		                 ->description("Path to a QML file or config folder.")
+		                 ->envname("QS_CONFIG_PATH");
+
+		group->add_option("-c,--config", state.config.name)
+		    ->description("Name of a quickshell configuration to run.")
+		    ->envname("QS_CONFIG_NAME")
+		    ->excludes(path);
+
+		group->add_option("-m,--manifest", state.config.manifest)
+		    ->description("[DEPRECATED] Path to a quickshell manifest.\n"
+		                  "If a manifest is specified, configs named by -c will point to its entries.\n"
+		                  "Defaults to $XDG_CONFIG_HOME/quickshell/manifest.conf")
+		    ->envname("QS_MANIFEST")
+		    ->excludes(path);
+
+		if (withNewestOption) {
+			group->add_flag("-n,--newest", state.config.newest)
+			    ->description("Operate on the most recently launched instance instead of the oldest");
+		}
+
+		return group;
+	};
+
+	auto addDebugOptions = [&](CLI::App* cmd) {
+		auto* group = cmd->add_option_group("Debugging", "Options for QML debugging.");
+
+		auto* debug = group->add_option("--debug", state.debug.port)
+		                  ->description("Open the given port for a QML debugger connection.")
+		                  ->check(CLI::Range(0, 65535));
+
+		group->add_flag("--waitfordebug", state.debug.wait)
+		    ->description("Wait for a QML debugger to connect before executing the configuration.")
+		    ->needs(debug);
+
+		return group;
+	};
+
+	auto addLoggingOptions = [&](CLI::App* cmd, bool noGroup, bool noDisplay = false) {
+		auto* group = noGroup ? cmd : cmd->add_option_group(noDisplay ? "" : "Logging");
+
+		group->add_flag("--no-color", state.log.noColor)
+		    ->description("Disables colored logging.\n"
+		                  "Colored logging can also be disabled by specifying a non empty value "
+		                  "for the NO_COLOR environment variable.");
+
+		group->add_flag("--log-times", state.log.timestamp)
+		    ->description("Log timestamps with each message.");
+
+		group->add_option("--log-rules", state.log.rules)
+		    ->description("Log rules to apply, in the format of QT_LOGGING_RULES.");
+
+		group->add_flag("-v,--verbose", [&](size_t count) { state.log.verbosity = count; })
+		    ->description("Increases log verbosity.\n"
+		                  "-v will show INFO level internal logs.\n"
+		                  "-vv will show DEBUG level internal logs.");
+
+		auto* hgroup = cmd->add_option_group("");
+		hgroup->add_flag("--no-detailed-logs", state.log.sparse);
+	};
+
+	auto addInstanceSelection = [&](CLI::App* cmd) {
+		auto* group = cmd->add_option_group("Instance Selection");
+
+		group->add_option("-i,--id", state.instance.id)
+		    ->description("The instance id to operate on.\n"
+		                  "You may also use a substring the id as long as it is unique, "
+		                  "for example \"abc\" will select \"abcdefg\".");
+
+		group->add_option("--pid", state.instance.pid)
+		    ->description("The process id of the instance to operate on.");
+
+		return group;
+	};
+
+	state.app = std::make_unique<CLI::App>();
+	auto* cli = state.app.get();
+
+	// Require 0-1 subcommands. Without this, positionals can be parsed as more subcommands.
+	cli->require_subcommand(0, 1);
+
+	addConfigSelection(cli);
+	addLoggingOptions(cli, false);
+	addDebugOptions(cli);
+
+	{
+		cli->add_option_group("")->add_flag("--private-check-compat", state.misc.checkCompat);
+
+		cli->add_flag("-V,--version", state.misc.printVersion)
+		    ->description("Print quickshell's version and exit.");
+
+		cli->add_flag("-n,--no-duplicate", state.misc.noDuplicate)
+		    ->description("Exit immediately if another instance of the given config is running.");
+
+		cli->add_flag("-d,--daemonize", state.misc.daemonize)
+		    ->description("Detach from the controlling terminal.");
+	}
+
+	{
+		auto* sub = cli->add_subcommand("log", "Print quickshell logs.");
+
+		auto* file = sub->add_option("file", state.log.file, "Log file to read.");
+
+		sub->add_option("-t,--tail", state.log.tail)
+		    ->description("Maximum number of lines to print, starting from the bottom.")
+		    ->check(CLI::Range(1, std::numeric_limits<int>::max(), "INT > 0"));
+
+		sub->add_flag("-f,--follow", state.log.follow)
+		    ->description("Keep reading the log until the logging process terminates.");
+
+		sub->add_option("-r,--rules", state.log.readoutRules, "Log file to read.")
+		    ->description("Rules to apply to the log being read, in the format of QT_LOGGING_RULES.");
+
+		auto* instance = addInstanceSelection(sub)->excludes(file);
+		addConfigSelection(sub, true)->excludes(instance)->excludes(file);
+		addLoggingOptions(sub, false);
+
+		state.subcommand.log = sub;
+	}
+
+	{
+		auto* sub = cli->add_subcommand("list", "List running quickshell instances.");
+
+		auto* all = sub->add_flag("-a,--all", state.instance.all)
+		                ->description("List all instances.\n"
+		                              "If unspecified, only instances of"
+		                              "the selected config will be listed.");
+
+		sub->add_flag("-j,--json", state.output.json, "Output the list as a json.");
+
+		sub->add_flag("--show-dead", state.instance.includeDead)
+		    ->description("Include dead instances in the list.");
+
+		addConfigSelection(sub, true)->excludes(all);
+		addLoggingOptions(sub, false, true);
+
+		state.subcommand.list = sub;
+	}
+
+	{
+		auto* sub = cli->add_subcommand("kill", "Kill quickshell instances.");
+		//sub->add_flag("-a,--all", "Kill all matching instances instead of just one.");
+		auto* instance = addInstanceSelection(sub);
+		addConfigSelection(sub, true)->excludes(instance);
+		addLoggingOptions(sub, false, true);
+
+		state.subcommand.kill = sub;
+	}
+
+	{
+		auto* sub = cli->add_subcommand("ipc", "Communicate with other Quickshell instances.")
+		                ->require_subcommand();
+		state.ipc.ipc = sub;
+
+		auto* instance = addInstanceSelection(sub);
+		addConfigSelection(sub, true)->excludes(instance);
+		addLoggingOptions(sub, false, true);
+
+		{
+			auto* show = sub->add_subcommand("show", "Print information about available IPC targets.");
+			state.ipc.show = show;
+		}
+
+		{
+			auto* call = sub->add_subcommand("call", "Call an IpcHandler function.");
+			state.ipc.call = call;
+
+			call->add_option("target", state.ipc.target, "The target to message.");
+
+			call->add_option("function", state.ipc.name)
+			    ->description("The function to call in the target.");
+
+			call->add_option("arguments", state.ipc.arguments)
+			    ->description("Arguments to the called function.")
+			    ->allow_extra_args();
+		}
+
+		{
+			auto* prop =
+			    sub->add_subcommand("prop", "Manipulate IpcHandler properties.")->require_subcommand();
+
+			{
+				auto* get = prop->add_subcommand("get", "Read the value of a property.");
+				state.ipc.getprop = get;
+				get->add_option("target", state.ipc.target, "The target to read the property of.");
+				get->add_option("property", state.ipc.name)->description("The property to read.");
+			}
+		}
+	}
+
+	{
+		auto* sub = cli->add_subcommand("msg", "[DEPRECATED] Moved to `ipc call`.")->require_option();
+
+		sub->add_option("target", state.ipc.target, "The target to message.");
+
+		sub->add_option("function", state.ipc.name)->description("The function to call in the target.");
+
+		sub->add_option("arguments", state.ipc.arguments)
+		    ->description("Arguments to the called function.")
+		    ->allow_extra_args();
+
+		sub->add_flag("-s,--show", state.ipc.showOld)
+		    ->description("Print information about a function or target if given, or all available "
+		                  "targets if not.");
+
+		auto* instance = addInstanceSelection(sub);
+		addConfigSelection(sub, true)->excludes(instance);
+		addLoggingOptions(sub, false, true);
+
+		state.subcommand.msg = sub;
+	}
+
+	CLI11_PARSE(*cli, argc, argv);
+
+	return 65535;
+}
+
+} // namespace qs::launch
diff --git a/src/main.cpp b/src/main.cpp
new file mode 100644
index 00000000..e0ce937f
--- /dev/null
+++ b/src/main.cpp
@@ -0,0 +1,3 @@
+#include "launch/main.hpp"
+
+int main(int argc, char** argv) { return qs::launch::main(argc, argv); }
diff --git a/src/services/CMakeLists.txt b/src/services/CMakeLists.txt
new file mode 100644
index 00000000..5ab5c550
--- /dev/null
+++ b/src/services/CMakeLists.txt
@@ -0,0 +1,27 @@
+if (SERVICE_STATUS_NOTIFIER)
+	add_subdirectory(status_notifier)
+endif()
+
+if (SERVICE_PIPEWIRE)
+	add_subdirectory(pipewire)
+endif()
+
+if (SERVICE_MPRIS)
+	add_subdirectory(mpris)
+endif()
+
+if (SERVICE_PAM)
+	add_subdirectory(pam)
+endif()
+
+if (SERVICE_GREETD)
+	add_subdirectory(greetd)
+endif()
+
+if (SERVICE_UPOWER)
+	add_subdirectory(upower)
+endif()
+
+if (SERVICE_NOTIFICATIONS)
+	add_subdirectory(notifications)
+endif()
diff --git a/src/services/greetd/CMakeLists.txt b/src/services/greetd/CMakeLists.txt
new file mode 100644
index 00000000..2252f8cf
--- /dev/null
+++ b/src/services/greetd/CMakeLists.txt
@@ -0,0 +1,19 @@
+qt_add_library(quickshell-service-greetd STATIC
+	qml.cpp
+	connection.cpp
+)
+
+qt_add_qml_module(quickshell-service-greetd
+	URI Quickshell.Services.Greetd
+	VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+install_qml_module(quickshell-service-greetd)
+
+# can't be Qt::Qml because generation.hpp pulls in gui types
+target_link_libraries(quickshell-service-greetd PRIVATE Qt::Quick)
+
+qs_module_pch(quickshell-service-greetd)
+
+target_link_libraries(quickshell PRIVATE quickshell-service-greetdplugin)
diff --git a/src/services/greetd/connection.cpp b/src/services/greetd/connection.cpp
new file mode 100644
index 00000000..bf0d1fdd
--- /dev/null
+++ b/src/services/greetd/connection.cpp
@@ -0,0 +1,260 @@
+#include "connection.hpp"
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qjsonarray.h>
+#include <qjsondocument.h>
+#include <qjsonobject.h>
+#include <qlocalsocket.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtenvironmentvariables.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/generation.hpp"
+#include "../../core/logcat.hpp"
+
+namespace {
+QS_LOGGING_CATEGORY(logGreetd, "quickshell.service.greetd");
+}
+
+QString GreetdState::toString(GreetdState::Enum value) {
+	switch (value) {
+	case GreetdState::Inactive: return "Inactive";
+	case GreetdState::Authenticating: return "Authenticating";
+	case GreetdState::ReadyToLaunch: return "Ready to Launch";
+	case GreetdState::Launching: return "Launching";
+	case GreetdState::Launched: return "Launched";
+	default: return "Invalid";
+	}
+}
+
+GreetdConnection::GreetdConnection() {
+	auto socket = qEnvironmentVariable("GREETD_SOCK");
+
+	if (socket.isEmpty()) {
+		this->mAvailable = false;
+		return;
+	}
+
+	this->mAvailable = true;
+
+	// clang-format off
+	QObject::connect(&this->socket, &QLocalSocket::connected, this, &GreetdConnection::onSocketConnected);
+	QObject::connect(&this->socket, &QLocalSocket::readyRead, this, &GreetdConnection::onSocketReady);
+	// clang-format on
+
+	this->socket.connectToServer(socket, QLocalSocket::ReadWrite);
+}
+
+void GreetdConnection::createSession(QString user) {
+	if (!this->mAvailable) {
+		qCCritical(logGreetd) << "Greetd is not available.";
+		return;
+	}
+
+	if (user != this->mUser) {
+		this->mUser = std::move(user);
+		emit this->userChanged();
+	}
+
+	this->setActive(true);
+}
+
+void GreetdConnection::cancelSession() { this->setActive(false); }
+
+void GreetdConnection::respond(QString response) {
+	if (!this->mResponseRequired) {
+		qCCritical(logGreetd) << "Cannot respond to greetd as a response is not currently required.";
+		return;
+	}
+
+	this->sendRequest({
+	    {"type", "post_auth_message_response"},
+	    {"response", response},
+	});
+
+	this->mResponseRequired = false;
+}
+
+void GreetdConnection::launch(
+    const QList<QString>& command,
+    const QList<QString>& environment,
+    bool exit
+) {
+	if (this->mState != GreetdState::ReadyToLaunch) {
+		qCCritical(logGreetd) << "Cannot call launch() as state is not currently ReadyToLaunch.";
+		return;
+	}
+
+	this->mState = GreetdState::Launching;
+	this->mExitAfterLaunch = exit;
+
+	this->sendRequest({
+	    {"type", "start_session"},
+	    {"cmd", QJsonArray::fromStringList(command)},
+	    {"env", QJsonArray::fromStringList(environment)},
+	});
+}
+
+bool GreetdConnection::isAvailable() const { return this->mAvailable; }
+GreetdState::Enum GreetdConnection::state() const { return this->mState; }
+
+void GreetdConnection::setActive(bool active) {
+	if (this->socket.state() == QLocalSocket::ConnectedState) {
+		this->mTargetActive = active;
+		if (active == (this->mState != GreetdState::Inactive)) return;
+
+		if (active) {
+			if (this->mUser.isEmpty()) {
+				qCCritical(logGreetd) << "Cannot activate greetd with unset user.";
+				this->setActive(false);
+				return;
+			}
+
+			this->sendRequest({
+			    {"type", "create_session"},
+			    {"username", this->mUser},
+			});
+
+			this->mState = GreetdState::Authenticating;
+			emit this->stateChanged();
+		} else {
+			this->sendRequest({
+			    {"type", "cancel_session"},
+			});
+
+			this->setInactive();
+		}
+	} else {
+		if (active != this->mTargetActive) {
+			this->mTargetActive = active;
+		}
+	}
+}
+
+void GreetdConnection::setInactive() {
+	this->mTargetActive = false;
+	this->mResponseRequired = false;
+	this->mState = GreetdState::Inactive;
+	emit this->stateChanged();
+}
+
+QString GreetdConnection::user() const { return this->mUser; }
+
+void GreetdConnection::onSocketConnected() {
+	qCDebug(logGreetd) << "Connected to greetd socket.";
+
+	if (this->mTargetActive) {
+		this->setActive(true);
+	}
+}
+
+void GreetdConnection::onSocketError(QLocalSocket::LocalSocketError error) {
+	qCCritical(logGreetd) << "Greetd socket encountered an error and cannot continue:" << error;
+
+	this->mAvailable = false;
+	this->setActive(false);
+}
+
+void GreetdConnection::onSocketReady() {
+	qint32 length = 0;
+
+	this->socket.read(reinterpret_cast<char*>(&length), sizeof(qint32));
+
+	auto text = this->socket.read(length);
+	auto json = QJsonDocument::fromJson(text).object();
+	auto type = json.value("type").toString();
+
+	qCDebug(logGreetd).noquote() << "Received greetd response:" << text;
+
+	if (type == "success") {
+		switch (this->mState) {
+		case GreetdState::Authenticating:
+			qCDebug(logGreetd) << "Authentication complete.";
+			this->mState = GreetdState::ReadyToLaunch;
+			emit this->stateChanged();
+			emit this->readyToLaunch();
+			break;
+		case GreetdState::Launching:
+			qCDebug(logGreetd) << "Target session set successfully.";
+			this->mState = GreetdState::Launched;
+			emit this->stateChanged();
+			emit this->launched();
+
+			if (this->mExitAfterLaunch) {
+				qCDebug(logGreetd) << "Quitting.";
+				EngineGeneration::currentGeneration()->quit();
+			}
+
+			break;
+		default: goto unexpected;
+		}
+	} else if (type == "error") {
+		auto errorType = json.value("error_type").toString();
+		auto desc = json.value("description").toString();
+
+		// Special case this error in case a session was already running.
+		// This cancels and restarts the session.
+		if (errorType == "error" && desc == "a session is already being configured") {
+			qCDebug(logGreetd
+			) << "A session was already in progress, cancelling it and starting a new one.";
+			this->setActive(false);
+			this->setActive(true);
+			return;
+		}
+
+		if (errorType == "auth_error") {
+			emit this->authFailure(desc);
+			this->setActive(false);
+		} else if (errorType == "error") {
+			qCWarning(logGreetd) << "Greetd error occurred" << desc;
+			emit this->error(desc);
+		} else goto unexpected;
+
+		// errors terminate the session
+		this->setInactive();
+	} else if (type == "auth_message") {
+		auto message = json.value("auth_message").toString();
+		auto type = json.value("auth_message_type").toString();
+		auto error = type == "error";
+		auto responseRequired = type == "visible" || type == "secret";
+		auto echoResponse = type != "secret";
+
+		this->mResponseRequired = responseRequired;
+		emit this->authMessage(message, error, responseRequired, echoResponse);
+	} else goto unexpected;
+
+	return;
+unexpected:
+	qCCritical(logGreetd) << "Received unexpected greetd response" << text;
+	this->setActive(false);
+}
+
+void GreetdConnection::sendRequest(const QJsonObject& json) {
+	auto text = QJsonDocument(json).toJson(QJsonDocument::Compact);
+	auto length = static_cast<qint32>(text.length());
+
+	if (logGreetd().isDebugEnabled()) {
+		auto debugJson = json;
+
+		if (json.value("type").toString() == "post_auth_message_response") {
+			debugJson["response"] = "<CENSORED>";
+		}
+
+		qCDebug(logGreetd).noquote() << "Sending greetd request:"
+		                             << QJsonDocument(debugJson).toJson(QJsonDocument::Compact);
+	}
+
+	this->socket.write(reinterpret_cast<char*>(&length), sizeof(qint32));
+
+	this->socket.write(text);
+	this->socket.flush();
+}
+
+GreetdConnection* GreetdConnection::instance() {
+	static auto* instance = new GreetdConnection(); // NOLINT
+	return instance;
+}
diff --git a/src/services/greetd/connection.hpp b/src/services/greetd/connection.hpp
new file mode 100644
index 00000000..0c1d1ebc
--- /dev/null
+++ b/src/services/greetd/connection.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qjsonobject.h>
+#include <qlocalsocket.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+///! State of the Greetd connection.
+/// See @@Greetd.state.
+class GreetdState: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		Inactive = 0,
+		Authenticating = 1,
+		ReadyToLaunch = 2,
+		Launching = 3,
+		Launched = 4,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(GreetdState::Enum value);
+};
+
+class GreetdConnection: public QObject {
+	Q_OBJECT;
+
+public:
+	void createSession(QString user);
+	void cancelSession();
+	void respond(QString response);
+	void launch(const QList<QString>& command, const QList<QString>& environment, bool exit);
+
+	[[nodiscard]] bool isAvailable() const;
+	[[nodiscard]] GreetdState::Enum state() const;
+
+	[[nodiscard]] QString user() const;
+
+	static GreetdConnection* instance();
+
+signals:
+	void authMessage(QString message, bool error, bool responseRequired, bool echoResponse);
+	void authFailure(QString message);
+	void readyToLaunch();
+	void launched();
+	void error(QString error);
+
+	void stateChanged();
+	void userChanged();
+
+private slots:
+	void onSocketConnected();
+	void onSocketError(QLocalSocket::LocalSocketError error);
+	void onSocketReady();
+
+private:
+	explicit GreetdConnection();
+
+	void sendRequest(const QJsonObject& json);
+	void setActive(bool active);
+	void setInactive();
+
+	bool mAvailable = false;
+	GreetdState::Enum mState = GreetdState::Inactive;
+	bool mTargetActive = false;
+	bool mExitAfterLaunch = false;
+	QString mMessage;
+	bool mResponseRequired = false;
+	QString mUser;
+	QLocalSocket socket;
+};
diff --git a/src/services/greetd/module.md b/src/services/greetd/module.md
new file mode 100644
index 00000000..a3ec540d
--- /dev/null
+++ b/src/services/greetd/module.md
@@ -0,0 +1,7 @@
+name = "Quickshell.Services.Greetd"
+description = "Greetd integration"
+headers = [
+	"qml.hpp",
+	"connection.hpp",
+]
+-----
diff --git a/src/services/greetd/qml.cpp b/src/services/greetd/qml.cpp
new file mode 100644
index 00000000..faebaa17
--- /dev/null
+++ b/src/services/greetd/qml.cpp
@@ -0,0 +1,46 @@
+#include "qml.hpp"
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+
+#include "connection.hpp"
+
+Greetd::Greetd(QObject* parent): QObject(parent) {
+	auto* connection = GreetdConnection::instance();
+
+	QObject::connect(connection, &GreetdConnection::authMessage, this, &Greetd::authMessage);
+	QObject::connect(connection, &GreetdConnection::authFailure, this, &Greetd::authFailure);
+	QObject::connect(connection, &GreetdConnection::readyToLaunch, this, &Greetd::readyToLaunch);
+	QObject::connect(connection, &GreetdConnection::launched, this, &Greetd::launched);
+	QObject::connect(connection, &GreetdConnection::error, this, &Greetd::error);
+
+	QObject::connect(connection, &GreetdConnection::stateChanged, this, &Greetd::stateChanged);
+	QObject::connect(connection, &GreetdConnection::userChanged, this, &Greetd::userChanged);
+}
+
+void Greetd::createSession(QString user) {
+	GreetdConnection::instance()->createSession(std::move(user));
+}
+
+void Greetd::cancelSession() { GreetdConnection::instance()->cancelSession(); }
+
+void Greetd::respond(QString response) {
+	GreetdConnection::instance()->respond(std::move(response));
+}
+
+void Greetd::launch(const QList<QString>& command) {
+	GreetdConnection::instance()->launch(command, {}, true);
+}
+
+void Greetd::launch(const QList<QString>& command, const QList<QString>& environment) {
+	GreetdConnection::instance()->launch(command, environment, true);
+}
+
+void Greetd::launch(const QList<QString>& command, const QList<QString>& environment, bool quit) {
+	GreetdConnection::instance()->launch(command, environment, quit);
+}
+
+bool Greetd::isAvailable() { return GreetdConnection::instance()->isAvailable(); }
+GreetdState::Enum Greetd::state() { return GreetdConnection::instance()->state(); }
+QString Greetd::user() { return GreetdConnection::instance()->user(); }
diff --git a/src/services/greetd/qml.hpp b/src/services/greetd/qml.hpp
new file mode 100644
index 00000000..9a42e763
--- /dev/null
+++ b/src/services/greetd/qml.hpp
@@ -0,0 +1,95 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+
+#include "connection.hpp"
+
+/// This object provides access to a running greetd instance if present.
+/// With it you can authenticate a user and launch a session.
+///
+/// See [the greetd wiki] for instructions on how to set up a graphical greeter.
+///
+/// [the greetd wiki]: https://man.sr.ht/~kennylevinsen/greetd/#setting-up-greetd-with-gtkgreet
+class Greetd: public QObject {
+	Q_OBJECT;
+	/// If the greetd socket is available.
+	Q_PROPERTY(bool available READ isAvailable CONSTANT);
+	/// The current state of the greetd connection.
+	Q_PROPERTY(GreetdState::Enum state READ state NOTIFY stateChanged);
+	/// The currently authenticating user.
+	Q_PROPERTY(QString user READ user NOTIFY userChanged);
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	explicit Greetd(QObject* parent = nullptr);
+
+	/// Create a greetd session for the given user.
+	Q_INVOKABLE static void createSession(QString user);
+	/// Cancel the active greetd session.
+	Q_INVOKABLE static void cancelSession();
+	/// Respond to an authentication message.
+	///
+	/// May only be called in response to an @@authMessage(s) with `responseRequired` set to true.
+	Q_INVOKABLE static void respond(QString response);
+
+	// docgen currently can't handle default params
+
+	// clang-format off
+	/// Launch the session, exiting quickshell.
+	/// @@state must be `GreetdState.ReadyToLaunch` to call this function.
+	Q_INVOKABLE static void launch(const QList<QString>& command);
+	/// Launch the session, exiting quickshell.
+	/// @@state must be `GreetdState.ReadyToLaunch` to call this function.
+	Q_INVOKABLE static void launch(const QList<QString>& command, const QList<QString>& environment);
+	/// Launch the session, exiting quickshell if @@quit is true.
+	/// @@state must be `GreetdState.ReadyToLaunch` to call this function.
+	///
+	/// The @@launched signal can be used to perform an action after greetd has acknowledged
+	/// the desired session.
+	///
+	/// > [!WARNING] Note that greetd expects the greeter to terminate as soon as possible
+	/// > after setting a target session, and waiting too long may lead to unexpected behavior
+	/// > such as the greeter restarting.
+	/// >
+	/// > Performing animations and such should be done *before* calling @@launch.
+	Q_INVOKABLE static void launch(const QList<QString>& command, const QList<QString>& environment, bool quit);
+	// clang-format on
+
+	[[nodiscard]] static bool isAvailable();
+	[[nodiscard]] static GreetdState::Enum state();
+	[[nodiscard]] static QString user();
+
+signals:
+	/// An authentication message has been sent by greetd.
+	/// - `message` - the text of the message
+	/// - `error` - if the message should be displayed as an error
+	/// - `responseRequired` - if a response via `respond()` is required for this message
+	/// - `echoResponse` - if the response should be displayed in clear text to the user
+	///
+	/// Note that `error` and `responseRequired` are mutually exclusive.
+	///
+	/// Errors are sent through `authMessage` when they are recoverable, such as a fingerprint scanner
+	/// not being able to read a finger correctly, while definite failures such as a bad password are
+	/// sent through `authFailure`.
+	void authMessage(QString message, bool error, bool responseRequired, bool echoResponse);
+	/// Authentication has failed an the session has terminated.
+	///
+	/// Usually this is something like a timeout or a failed password entry.
+	void authFailure(QString message);
+	/// Authentication has finished successfully and greetd can now launch a session.
+	void readyToLaunch();
+	/// Greetd has acknowledged the launch request and the greeter should quit as soon as possible.
+	///
+	/// This signal is sent right before quickshell exits automatically if the launch was not specifically
+	/// requested not to exit. You usually don't need to use this signal.
+	void launched();
+	/// Greetd has encountered an error.
+	void error(QString error);
+
+	void stateChanged();
+	void userChanged();
+};
diff --git a/src/services/mpris/CMakeLists.txt b/src/services/mpris/CMakeLists.txt
new file mode 100644
index 00000000..4440c0a7
--- /dev/null
+++ b/src/services/mpris/CMakeLists.txt
@@ -0,0 +1,45 @@
+set_source_files_properties(org.mpris.MediaPlayer2.Player.xml PROPERTIES
+	CLASSNAME DBusMprisPlayer
+	NO_NAMESPACE TRUE
+)
+
+qt_add_dbus_interface(DBUS_INTERFACES
+	org.mpris.MediaPlayer2.Player.xml
+	dbus_player
+)
+
+set_source_files_properties(org.mpris.MediaPlayer2.xml PROPERTIES
+	CLASSNAME DBusMprisPlayerApp
+	NO_NAMESPACE TRUE
+)
+
+qt_add_dbus_interface(DBUS_INTERFACES
+	org.mpris.MediaPlayer2.xml
+	dbus_player_app
+)
+
+qt_add_library(quickshell-service-mpris STATIC
+	player.cpp
+	watcher.cpp
+	${DBUS_INTERFACES}
+)
+
+# dbus headers
+target_include_directories(quickshell-service-mpris PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+
+qt_add_qml_module(quickshell-service-mpris
+	URI Quickshell.Services.Mpris
+  VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+qs_add_module_deps_light(quickshell-service-mpris Quickshell)
+
+install_qml_module(quickshell-service-mpris)
+
+target_link_libraries(quickshell-service-mpris PRIVATE Qt::Qml Qt::DBus)
+qs_add_link_dependencies(quickshell-service-mpris quickshell-dbus)
+
+qs_module_pch(quickshell-service-mpris SET dbus)
+
+target_link_libraries(quickshell PRIVATE quickshell-service-mprisplugin)
diff --git a/src/services/mpris/module.md b/src/services/mpris/module.md
new file mode 100644
index 00000000..e2256e8c
--- /dev/null
+++ b/src/services/mpris/module.md
@@ -0,0 +1,7 @@
+name = "Quickshell.Services.Mpris"
+description = "Mpris Service"
+headers = [
+	"player.hpp",
+	"watcher.hpp",
+]
+-----
diff --git a/src/services/mpris/org.mpris.MediaPlayer2.Player.xml b/src/services/mpris/org.mpris.MediaPlayer2.Player.xml
new file mode 100644
index 00000000..a0095231
--- /dev/null
+++ b/src/services/mpris/org.mpris.MediaPlayer2.Player.xml
@@ -0,0 +1,24 @@
+<node>
+	<interface name="org.mpris.MediaPlayer2.Player">
+		<method name="OpenUri">
+			<arg direction="in" type="s" name="Uri"/>
+		</method>
+		<method name="SetPosition">
+			<arg direction="in" type="o" name="TrackId"/>
+			<arg direction="in" type="x" name="Position"/>
+		</method>
+		<method name="Seek">
+			<arg direction="in" type="x" name="Offset"/> 
+		</method>
+		<method name="PlayPause"/>
+		<method name="Next"/>
+		<method name="Previous"/>
+		<method name="Stop"/>
+		<method name="Play"/>
+		<method name="Pause"/>
+
+		<signal name="Seeked">
+			<arg type="x" name="Position"/>
+		</signal>
+  </interface>
+</node>
diff --git a/src/services/mpris/org.mpris.MediaPlayer2.xml b/src/services/mpris/org.mpris.MediaPlayer2.xml
new file mode 100644
index 00000000..fa880d08
--- /dev/null
+++ b/src/services/mpris/org.mpris.MediaPlayer2.xml
@@ -0,0 +1,6 @@
+<node>
+	<interface name="org.mpris.MediaPlayer2">
+		<method name="Raise"/>
+		<method name="Quit"/>
+	</interface>
+</node>
diff --git a/src/services/mpris/player.cpp b/src/services/mpris/player.cpp
new file mode 100644
index 00000000..751a4e73
--- /dev/null
+++ b/src/services/mpris/player.cpp
@@ -0,0 +1,501 @@
+#include "player.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdatetime.h>
+#include <qdbusconnection.h>
+#include <qdbuserror.h>
+#include <qdbusextratypes.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qstring.h>
+#include <qtimer.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/logcat.hpp"
+#include "../../dbus/properties.hpp"
+#include "dbus_player.h"
+#include "dbus_player_app.h"
+
+using namespace qs::dbus;
+
+namespace qs::service::mpris {
+
+namespace {
+QS_LOGGING_CATEGORY(logMprisPlayer, "quickshell.service.mp.player", QtWarningMsg);
+}
+
+QString MprisPlaybackState::toString(MprisPlaybackState::Enum status) {
+	switch (status) {
+	case MprisPlaybackState::Stopped: return "Stopped";
+	case MprisPlaybackState::Playing: return "Playing";
+	case MprisPlaybackState::Paused: return "Paused";
+	default: return "Unknown Status";
+	}
+}
+
+QString MprisLoopState::toString(MprisLoopState::Enum status) {
+	switch (status) {
+	case MprisLoopState::None: return "None";
+	case MprisLoopState::Track: return "Track";
+	case MprisLoopState::Playlist: return "Playlist";
+	default: return "Unknown Status";
+	}
+}
+
+MprisPlayer::MprisPlayer(const QString& address, QObject* parent): QObject(parent) {
+	this->app = new DBusMprisPlayerApp(
+	    address,
+	    "/org/mpris/MediaPlayer2",
+	    QDBusConnection::sessionBus(),
+	    this
+	);
+
+	this->player =
+	    new DBusMprisPlayer(address, "/org/mpris/MediaPlayer2", QDBusConnection::sessionBus(), this);
+
+	if (!this->player->isValid() || !this->app->isValid()) {
+		qCWarning(logMprisPlayer) << "Cannot create MprisPlayer for" << address;
+		return;
+	}
+
+	this->bCanPlay.setBinding([this]() { return this->bCanControl && this->bpCanPlay; });
+	this->bCanPause.setBinding([this]() { return this->bCanControl && this->bpCanPause; });
+	this->bCanSeek.setBinding([this]() { return this->bCanControl && this->bpCanSeek; });
+	this->bCanGoNext.setBinding([this]() { return this->bCanControl && this->bpCanGoNext; });
+	this->bCanGoPrevious.setBinding([this]() { return this->bCanControl && this->bpCanGoPrevious; });
+
+	this->bCanTogglePlaying.setBinding([this]() {
+		return this->bIsPlaying ? this->bCanPause.value() : this->bCanPlay.value();
+	});
+
+	this->bTrackTitle.setBinding([this]() {
+		return this->bMetadata.value().value("xesam:title").toString();
+	});
+
+	this->bTrackAlbum.setBinding([this]() {
+		return this->bMetadata.value().value("xesam:album").toString();
+	});
+
+	this->bTrackArtist.setBinding([this]() {
+		const auto& artist = this->bMetadata.value().value("xesam:artist").value<QList<QString>>();
+		return artist.isEmpty() ? QString() : artist.join(", ");
+	});
+
+	this->bTrackAlbumArtist.setBinding([this]() {
+		return this->bMetadata.value().value("xesam:albumArtist").toString();
+	});
+
+	this->bTrackArtUrl.setBinding([this]() {
+		return this->bMetadata.value().value("mpris:artUrl").toString();
+	});
+
+	this->bInternalLength.setBinding([this]() {
+		auto variant = this->bMetadata.value().value("mpris:length");
+		if (variant.isValid() && variant.canConvert<qlonglong>()) {
+			return variant.value<qlonglong>();
+		} else return static_cast<qlonglong>(-1);
+	});
+
+	this->bLengthSupported.setBinding([this]() { return this->bInternalLength != -1; });
+
+	this->bIsPlaying.setBinding([this]() {
+		return this->bPlaybackState == MprisPlaybackState::Playing;
+	});
+
+	// clang-format off
+	QObject::connect(this->player, &DBusMprisPlayer::Seeked, this, &MprisPlayer::onSeek);
+	QObject::connect(&this->playerProperties, &DBusPropertyGroup::getAllFinished, this, &MprisPlayer::onGetAllFinished);
+
+	// Ensure user triggered position updates can update length.
+	QObject::connect(this, &MprisPlayer::positionChanged, this, &MprisPlayer::onExportedPositionChanged);
+	// clang-format on
+
+	this->appProperties.setInterface(this->app);
+	this->playerProperties.setInterface(this->player);
+	this->appProperties.updateAllViaGetAll();
+	this->playerProperties.updateAllViaGetAll();
+}
+
+void MprisPlayer::raise() {
+	if (!this->bCanRaise) {
+		qWarning() << "Cannot call raise() on" << this << "because canRaise is false.";
+		return;
+	}
+
+	this->app->Raise();
+}
+
+void MprisPlayer::quit() {
+	if (!this->bCanQuit) {
+		qWarning() << "Cannot call quit() on" << this << "because canQuit is false.";
+		return;
+	}
+
+	this->app->Quit();
+}
+
+void MprisPlayer::openUri(const QString& uri) { this->player->OpenUri(uri); }
+
+void MprisPlayer::next() {
+	if (!this->bCanGoNext) {
+		qWarning() << "Cannot call next() on" << this << "because canGoNext is false.";
+		return;
+	}
+
+	this->player->Next();
+}
+
+void MprisPlayer::previous() {
+	if (!this->bCanGoPrevious) {
+		qWarning() << "Cannot call previous() on" << this << "because canGoPrevious is false.";
+		return;
+	}
+
+	this->player->Previous();
+}
+
+void MprisPlayer::seek(qreal offset) {
+	if (!this->bCanSeek) {
+		qWarning() << "Cannot call seek() on" << this << "because canSeek is false.";
+		return;
+	}
+
+	auto target = static_cast<qlonglong>(offset * 1000) * 1000;
+	this->player->Seek(target);
+}
+
+bool MprisPlayer::isValid() const { return this->player->isValid(); }
+QString MprisPlayer::address() const { return this->player->service(); }
+
+qlonglong MprisPlayer::positionMs() const {
+	if (!this->positionSupported()) return 0; // unsupported
+	if (this->bPlaybackState == MprisPlaybackState::Stopped) return 0;
+
+	auto paused = this->bPlaybackState == MprisPlaybackState::Paused;
+	auto time = paused ? this->pausedTime : QDateTime::currentDateTime();
+	auto offset = time - this->lastPositionTimestamp;
+	auto rateMul = static_cast<qlonglong>(this->bRate.value() * 1000);
+	offset = (offset * rateMul) / 1000;
+
+	return (this->bpPosition.value() / 1000) + offset.count();
+}
+
+qreal MprisPlayer::position() const {
+	if (!this->positionSupported()) return 0; // unsupported
+	if (this->bPlaybackState == MprisPlaybackState::Stopped) return 0;
+
+	return static_cast<qreal>(this->positionMs()) / 1000.0; // NOLINT
+}
+
+bool MprisPlayer::positionSupported() const { return this->pPosition.exists(); }
+
+void MprisPlayer::setPosition(qreal position) {
+	if (this->bpPosition.value() == -1) {
+		qWarning() << "Cannot set position of" << this << "because position is not supported.";
+		return;
+	}
+
+	if (!this->bCanSeek) {
+		qWarning() << "Cannot set position of" << this << "because canSeek is false.";
+		return;
+	}
+
+	auto target = static_cast<qlonglong>(position * 1000) * 1000;
+
+	if (!this->mTrackId.isEmpty()) {
+		this->player->SetPosition(QDBusObjectPath(this->mTrackId), target);
+	} else {
+		auto pos = this->positionMs() * 1000;
+		this->player->Seek(target - pos);
+	}
+
+	this->setPosition(target);
+}
+
+void MprisPlayer::onPositionUpdated() {
+	const bool firstChange = !this->lastPositionTimestamp.isValid();
+	this->lastPositionTimestamp = QDateTime::currentDateTimeUtc();
+	this->pausedTime = this->lastPositionTimestamp;
+	emit this->positionChanged();
+	if (firstChange) emit this->positionSupportedChanged();
+}
+
+void MprisPlayer::setPosition(qlonglong position) {
+	this->bpPosition = position;
+	this->onPositionUpdated();
+}
+
+void MprisPlayer::onExportedPositionChanged() {
+	if (!this->bLengthSupported) emit this->lengthChanged();
+}
+
+void MprisPlayer::onSeek(qlonglong time) { this->setPosition(time); }
+
+qreal MprisPlayer::length() const {
+	if (!this->bLengthSupported) {
+		return this->position(); // unsupported
+	} else {
+		return static_cast<qreal>(this->bInternalLength / 1000) / 1000; // NOLINT
+	}
+}
+
+bool MprisPlayer::volumeSupported() const { return this->pVolume.exists(); }
+
+void MprisPlayer::setVolume(qreal volume) {
+	if (!this->bCanControl) {
+		qWarning() << "Cannot set volume of" << this << "because canControl is false.";
+		return;
+	}
+
+	if (!this->volumeSupported()) {
+		qWarning() << "Cannot set volume of" << this << "because volume is not supported.";
+		return;
+	}
+
+	this->bVolume = volume;
+	this->pVolume.write();
+}
+
+void MprisPlayer::onMetadataChanged() {
+	auto trackChanged = false;
+
+	QString trackId;
+	auto trackidVariant = this->bpMetadata.value().value("mpris:trackid");
+	if (trackidVariant.isValid()) {
+		if (trackidVariant.canConvert<QString>()) {
+			trackId = trackidVariant.toString();
+		} else if (trackidVariant.canConvert<QDBusObjectPath>()) {
+			trackId = trackidVariant.value<QDBusObjectPath>().path();
+		}
+	}
+
+	if (trackId != this->mTrackId) {
+		this->mTrackId = trackId;
+		trackChanged = true;
+	}
+
+	// Helps to catch players without trackid.
+	auto urlVariant = this->bpMetadata.value().value("xesam:url");
+	if (urlVariant.isValid() && urlVariant.canConvert<QString>()) {
+		auto url = urlVariant.toString();
+
+		if (url != this->mTrackUrl) {
+			this->mTrackUrl = url;
+			trackChanged = true;
+		}
+	}
+
+	// Some players (Jellyfin) specify xesam:url or mpris:trackid
+	// and DON'T ACTUALLY CHANGE THEM WHEN THE TRACK CHANGES.
+	auto titleVariant = this->bpMetadata.value().value("xesam:title");
+	if (titleVariant.isValid() && titleVariant.canConvert<QString>()) {
+		auto title = titleVariant.toString();
+
+		if (title != this->mTrackTitle) {
+			this->mTrackTitle = title;
+			trackChanged = true;
+		}
+	}
+
+	Qt::beginPropertyUpdateGroup();
+
+	if (trackChanged) {
+		emit this->trackChanged();
+		this->bUniqueId = this->bUniqueId + 1;
+		this->trackChangedBeforeState = true;
+
+		// Some players don't seem to send position updates or seeks on track change.
+		this->pPosition.requestUpdate();
+	}
+
+	this->bMetadata = this->bpMetadata.value();
+
+	Qt::endPropertyUpdateGroup();
+
+	if (trackChanged) emit this->postTrackChanged();
+}
+
+void MprisPlayer::setPlaybackState(MprisPlaybackState::Enum playbackState) {
+	if (playbackState == this->bPlaybackState) return;
+
+	switch (playbackState) {
+	case MprisPlaybackState::Stopped:
+		if (!this->bCanControl) {
+			qWarning() << "Cannot set playbackState of" << this
+			           << "to Stopped because canControl is false.";
+			return;
+		}
+
+		this->player->Stop();
+		break;
+	case MprisPlaybackState::Playing:
+		if (!this->bCanPlay) {
+			qWarning() << "Cannot set playbackState of" << this << "to Playing because canPlay is false.";
+			return;
+		}
+
+		this->player->Play();
+		break;
+	case MprisPlaybackState::Paused:
+		if (!this->bCanPause) {
+			qWarning() << "Cannot set playbackState of" << this << "to Paused because canPause is false.";
+			return;
+		}
+
+		this->player->Pause();
+		break;
+	default:
+		qWarning() << "Cannot set playbackState of" << this << "to unknown value" << playbackState;
+		return;
+	}
+}
+
+void MprisPlayer::play() { this->setPlaybackState(MprisPlaybackState::Playing); }
+void MprisPlayer::pause() { this->setPlaybackState(MprisPlaybackState::Paused); }
+void MprisPlayer::stop() { this->setPlaybackState(MprisPlaybackState::Stopped); }
+
+void MprisPlayer::togglePlaying() {
+	if (this->bIsPlaying) {
+		this->pause();
+	} else {
+		this->play();
+	}
+}
+
+void MprisPlayer::setPlaying(bool playing) {
+	if (playing == this->bIsPlaying) return;
+	this->togglePlaying();
+}
+
+void MprisPlayer::onPlaybackStatusUpdated() {
+	// Insurance - have not yet seen a player where this particular check is required that doesn't
+	// require the late query below.
+	this->pPosition.requestUpdate();
+
+	// For exceptionally bad players that update playback timestamps at an indeterminate time AFTER
+	// updating playback state. (Youtube)
+	QTimer::singleShot(100, this, [&]() { this->pPosition.requestUpdate(); });
+
+	// For exceptionally bad players that don't update length (or other metadata) until a new track actually
+	// starts playing, and then don't trigger a metadata update when they do. (Jellyfin)
+	if (this->trackChangedBeforeState) {
+		this->trackChangedBeforeState = false;
+		this->pMetadata.requestUpdate();
+	}
+}
+
+bool MprisPlayer::loopSupported() const { return this->pLoopStatus.exists(); }
+
+void MprisPlayer::setLoopState(MprisLoopState::Enum loopState) {
+	if (!this->bCanControl) {
+		qWarning() << "Cannot set loopState of" << this << "because canControl is false.";
+		return;
+	}
+
+	if (!this->loopSupported()) {
+		qWarning() << "Cannot set loopState of" << this << "because loop state is not supported.";
+		return;
+	}
+
+	if (loopState == this->bLoopState) return;
+	if (loopState < MprisLoopState::None || loopState > MprisLoopState::Playlist) {
+		qWarning() << "Cannot set loopState of" << this << "to unknown value" << loopState;
+	}
+
+	this->bLoopState = loopState;
+	this->pLoopStatus.write();
+}
+
+void MprisPlayer::setRate(qreal rate) {
+	if (rate == this->bRate.value()) return;
+
+	if (rate < this->bMinRate.value() || rate > this->bMaxRate.value()) {
+		qWarning() << "Cannot set rate for" << this << "to" << rate
+		           << "which is outside of minRate and maxRate" << this->bMinRate.value()
+		           << this->bMaxRate.value();
+		return;
+	}
+
+	this->bRate = rate;
+	this->pRate.write();
+}
+
+bool MprisPlayer::shuffleSupported() const { return this->pShuffle.exists(); }
+
+void MprisPlayer::setShuffle(bool shuffle) {
+	if (!this->shuffleSupported()) {
+		qWarning() << "Cannot set shuffle for" << this << "because shuffle is not supported.";
+		return;
+	}
+
+	if (!this->bCanControl) {
+		qWarning() << "Cannot set shuffle state of" << this << "because canControl is false.";
+		return;
+	}
+
+	this->bShuffle = shuffle;
+	this->pShuffle.write();
+}
+
+void MprisPlayer::setFullscreen(bool fullscreen) {
+	if (!this->bCanSetFullscreen) {
+		qWarning() << "Cannot set fullscreen for" << this << "because canSetFullscreen is false.";
+		return;
+	}
+
+	this->bFullscreen = fullscreen;
+	this->pFullscreen.write();
+}
+
+void MprisPlayer::onGetAllFinished() {
+	if (this->volumeSupported()) emit this->volumeSupportedChanged();
+	if (this->loopSupported()) emit this->loopSupportedChanged();
+	if (this->shuffleSupported()) emit this->shuffleSupportedChanged();
+	emit this->ready();
+}
+
+} // namespace qs::service::mpris
+
+namespace qs::dbus {
+
+using namespace qs::service::mpris;
+
+DBusResult<MprisPlaybackState::Enum>
+DBusDataTransform<MprisPlaybackState::Enum>::fromWire(const QString& wire) {
+	if (wire == "Playing") return MprisPlaybackState::Playing;
+	if (wire == "Paused") return MprisPlaybackState::Paused;
+	if (wire == "Stopped") return MprisPlaybackState::Stopped;
+	return QDBusError(QDBusError::InvalidArgs, QString("Invalid MprisPlaybackState: %1").arg(wire));
+}
+
+QString DBusDataTransform<MprisPlaybackState::Enum>::toWire(MprisPlaybackState::Enum data) {
+	switch (data) {
+	case MprisPlaybackState::Playing: return "Playing";
+	case MprisPlaybackState::Paused: return "Paused";
+	case MprisPlaybackState::Stopped: return "Stopped";
+	default: qFatal() << "Tried to convert an invalid MprisPlaybackState to String"; return QString();
+	}
+}
+
+DBusResult<MprisLoopState::Enum>
+DBusDataTransform<MprisLoopState::Enum>::fromWire(const QString& wire) {
+	if (wire == "None") return MprisLoopState::None;
+	if (wire == "Track") return MprisLoopState::Track;
+	if (wire == "Playlist") return MprisLoopState::Playlist;
+	return QDBusError(QDBusError::InvalidArgs, QString("Invalid MprisLoopState: %1").arg(wire));
+}
+
+QString DBusDataTransform<MprisLoopState::Enum>::toWire(MprisLoopState::Enum data) {
+	switch (data) {
+	case MprisLoopState::None: return "None";
+	case MprisLoopState::Track: return "Track";
+	case MprisLoopState::Playlist: return "Playlist";
+	default: qFatal() << "Tried to convert an invalid MprisLoopState to String"; return QString();
+	}
+}
+
+} // namespace qs::dbus
diff --git a/src/services/mpris/player.hpp b/src/services/mpris/player.hpp
new file mode 100644
index 00000000..423453d3
--- /dev/null
+++ b/src/services/mpris/player.hpp
@@ -0,0 +1,504 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/doc.hpp"
+#include "../../core/util.hpp"
+#include "../../dbus/properties.hpp"
+#include "dbus_player.h"
+#include "dbus_player_app.h"
+
+namespace qs::service::mpris {
+
+///! Playback state of an MprisPlayer
+/// See @@MprisPlayer.playbackState.
+class MprisPlaybackState: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		Stopped = 0,
+		Playing = 1,
+		Paused = 2,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(qs::service::mpris::MprisPlaybackState::Enum status);
+};
+
+///! Loop state of an MprisPlayer
+/// See @@MprisPlayer.loopState.
+class MprisLoopState: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		None = 0,
+		Track = 1,
+		Playlist = 2,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(qs::service::mpris::MprisLoopState::Enum status);
+};
+
+}; // namespace qs::service::mpris
+
+namespace qs::dbus {
+
+template <>
+struct DBusDataTransform<qs::service::mpris::MprisPlaybackState::Enum> {
+	using Wire = QString;
+	using Data = qs::service::mpris::MprisPlaybackState::Enum;
+	static DBusResult<Data> fromWire(const QString& wire);
+	static QString toWire(Data data);
+};
+
+template <>
+struct DBusDataTransform<qs::service::mpris::MprisLoopState::Enum> {
+	using Wire = QString;
+	using Data = qs::service::mpris::MprisLoopState::Enum;
+	static DBusResult<Data> fromWire(const QString& wire);
+	static QString toWire(Data data);
+};
+
+}; // namespace qs::dbus
+
+namespace qs::service::mpris {
+
+///! A media player exposed over MPRIS.
+/// A media player exposed over MPRIS.
+///
+/// > [!WARNING] Support for various functionality and general compliance to
+/// > the MPRIS specification varies wildly by player.
+/// > Always check the associated `canXyz` and `xyzSupported` properties if available.
+///
+/// > [!INFO] The TrackList and Playlist interfaces were not implemented as we could not
+/// > find any media players using them to test against.
+class MprisPlayer: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	Q_PROPERTY(bool canControl READ default NOTIFY canControlChanged BINDABLE bindableCanControl);
+	Q_PROPERTY(bool canPlay READ default NOTIFY canPlayChanged BINDABLE bindableCanPlay);
+	Q_PROPERTY(bool canPause READ default NOTIFY canPauseChanged BINDABLE bindableCanPause);
+	Q_PROPERTY(bool canTogglePlaying READ default NOTIFY canTogglePlayingChanged BINDABLE bindableCanTogglePlaying);
+	Q_PROPERTY(bool canSeek READ default NOTIFY canSeekChanged BINDABLE bindableCanSeek);
+	Q_PROPERTY(bool canGoNext READ default NOTIFY canGoNextChanged BINDABLE bindableCanGoNext);
+	Q_PROPERTY(bool canGoPrevious READ default NOTIFY canGoPreviousChanged BINDABLE bindableCanGoPrevious);
+	Q_PROPERTY(bool canQuit READ default NOTIFY canQuitChanged BINDABLE bindableCanQuit);
+	Q_PROPERTY(bool canRaise READ default NOTIFY canRaiseChanged BINDABLE bindableCanRaise);
+	Q_PROPERTY(bool canSetFullscreen READ default NOTIFY canSetFullscreenChanged BINDABLE bindableCanSetFullscreen);
+	/// The human readable name of the media player.
+	Q_PROPERTY(QString identity READ default NOTIFY identityChanged BINDABLE bindableIdentity);
+	/// The name of the desktop entry for the media player, or an empty string if not provided.
+	Q_PROPERTY(QString desktopEntry READ default NOTIFY desktopEntryChanged BINDABLE bindableDesktopEntry);
+	/// The DBus service name of the player.
+	Q_PROPERTY(QString dbusName READ address CONSTANT);
+	/// The current position in the playing track, as seconds, with millisecond precision,
+	/// or `0` if @@positionSupported is false.
+	///
+	/// May only be written to if @@canSeek and @@positionSupported are true.
+	///
+	/// > [!WARNING] To avoid excessive property updates wasting CPU while `position` is not
+	/// > actively monitored, `position` usually will not update reactively, unless a nonlinear
+	/// > change in position occurs, however reading it will always return the current position.
+	/// >
+	/// > If you want to actively monitor the position, the simplest way it to emit the @@positionChanged(s)
+	/// > signal manually for the duration you are monitoring it, Using a @@QtQuick.FrameAnimation if you need
+	/// > the value to update smoothly, such as on a slider, or a @@QtQuick.Timer if not, as shown below.
+	/// >
+	/// > ```qml {filename="Using a FrameAnimation"}
+	/// > FrameAnimation {
+	/// >   // only emit the signal when the position is actually changing.
+	/// >   running: player.playbackState == MprisPlaybackState.Playing
+	/// >   // emit the positionChanged signal every frame.
+	/// >   onTriggered: player.positionChanged()
+	/// > }
+	/// > ```
+	/// >
+	/// > ```qml {filename="Using a Timer"}
+	/// > Timer {
+	/// >   // only emit the signal when the position is actually changing.
+	/// >   running: player.playbackState == MprisPlaybackState.Playing
+	/// >   // Make sure the position updates at least once per second.
+	/// >   interval: 1000
+	/// >   repeat: true
+	/// >   // emit the positionChanged signal every second.
+	/// >   onTriggered: player.positionChanged()
+	/// > }
+	/// > ```
+	Q_PROPERTY(qreal position READ position WRITE setPosition NOTIFY positionChanged);
+	Q_PROPERTY(bool positionSupported READ positionSupported NOTIFY positionSupportedChanged);
+	/// The length of the playing track, as seconds, with millisecond precision,
+	/// or the value of @@position if @@lengthSupported is false.
+	Q_PROPERTY(qreal length READ length NOTIFY lengthChanged);
+	Q_PROPERTY(bool lengthSupported READ default NOTIFY lengthSupportedChanged BINDABLE bindableLengthSupported);
+	/// The volume of the playing track from 0.0 to 1.0, or 1.0 if @@volumeSupported is false.
+	///
+	/// May only be written to if @@canControl and @@volumeSupported are true.
+	Q_PROPERTY(qreal volume READ volume WRITE setVolume NOTIFY volumeChanged);
+	Q_PROPERTY(bool volumeSupported READ volumeSupported NOTIFY volumeSupportedChanged);
+	/// Metadata of the current track.
+	///
+	/// A map of common properties is available [here](https://www.freedesktop.org/wiki/Specifications/mpris-spec/metadata).
+	/// Do not count on any of them actually being present.
+	///
+	/// Note that the @@trackTitle, @@trackAlbum, @@trackAlbumArtist, @@trackArtist and @@trackArtUrl
+	/// properties have extra logic to guard against bad players sending weird metadata, and should
+	/// be used over grabbing the properties directly from the metadata.
+	Q_PROPERTY(QVariantMap metadata READ default NOTIFY metadataChanged BINDABLE bindableMetadata);
+	/// An opaque identifier for the current track unique within the current player.
+	///
+	/// > [!WARNING] This is NOT `mpris:trackid` as that is sometimes missing or nonunique
+	/// > in some players.
+	Q_PROPERTY(quint32 uniqueId READ default NOTIFY uniqueIdChanged BINDABLE bindableUniqueId);
+	/// The title of the current track, or `""` if none was provided.
+	///
+	/// > [!TIP] Use `player.trackTitle || "Unknown Title"` to provide a message
+	/// > when no title is available.
+	Q_PROPERTY(QString trackTitle READ default NOTIFY trackTitleChanged BINDABLE bindableTrackTitle);
+	/// The current track's artist, or an `""` if none was provided.
+	///
+	/// > [!TIP] Use `player.trackArtist || "Unknown Artist"` to provide a message
+	/// > when no artist is available.
+	Q_PROPERTY(QString trackArtist READ default NOTIFY trackArtistChanged BINDABLE bindableTrackArtist);
+	/// > [!ERROR] deprecated in favor of @@trackArtist.
+	Q_PROPERTY(QString trackArtists READ default NOTIFY trackArtistChanged BINDABLE bindableTrackArtist);
+	/// The current track's album, or `""` if none was provided.
+	///
+	/// > [!TIP] Use `player.trackAlbum || "Unknown Album"` to provide a message
+	/// > when no album is available.
+	Q_PROPERTY(QString trackAlbum READ default NOTIFY trackAlbumChanged BINDABLE bindableTrackAlbum);
+	/// The current track's album artist, or `""` if none was provided.
+	///
+	/// > [!TIP] Use `player.trackAlbumArtist || "Unknown Album"` to provide a message
+	/// > when no album artist is available.
+	Q_PROPERTY(QString trackAlbumArtist READ default NOTIFY trackAlbumArtistChanged BINDABLE bindableTrackAlbumArtist);
+	/// The current track's art url, or `""` if none was provided.
+	Q_PROPERTY(QString trackArtUrl READ default NOTIFY trackArtUrlChanged BINDABLE bindableTrackArtUrl);
+	/// The playback state of the media player.
+	///
+	/// - If @@canPlay is false, you cannot assign the `Playing` state.
+	/// - If @@canPause is false, you cannot assign the `Paused` state.
+	/// - If @@canControl is false, you cannot assign the `Stopped` state.
+	/// (or any of the others, though their repsective properties will also be false)
+	Q_PROPERTY(qs::service::mpris::MprisPlaybackState::Enum playbackState READ playbackState WRITE setPlaybackState NOTIFY playbackStateChanged );
+	/// True if @@playbackState == `MprisPlaybackState.Playing`.
+	///
+	/// Setting this property is equivalent to calling @@play() or @@pause().
+	/// You cannot set this property if @@canTogglePlaying is false.
+	Q_PROPERTY(bool isPlaying READ isPlaying WRITE setPlaying NOTIFY isPlayingChanged);
+	/// The loop state of the media player, or `None` if @@loopSupported is false.
+	///
+	/// May only be written to if @@canControl and @@loopSupported are true.
+	Q_PROPERTY(qs::service::mpris::MprisLoopState::Enum loopState READ loopState WRITE setLoopState NOTIFY loopStateChanged);
+	Q_PROPERTY(bool loopSupported READ loopSupported NOTIFY loopSupportedChanged);
+	/// The speed the song is playing at, as a multiplier.
+	///
+	/// Only values between @@minRate and @@maxRate (inclusive) may be written to the property.
+	/// Additionally, It is recommended that you only write common values such as `0.25`, `0.5`, `1.0`, `2.0`
+	/// to the property, as media players are free to ignore the value, and are more likely to
+	/// accept common ones.
+	Q_PROPERTY(qreal rate READ rate WRITE setRate NOTIFY rateChanged);
+	Q_PROPERTY(qreal minRate READ default NOTIFY minRateChanged BINDABLE bindableMinRate);
+	Q_PROPERTY(qreal maxRate READ default NOTIFY maxRateChanged BINDABLE bindableMaxRate);
+	/// If the play queue is currently being shuffled, or false if @@shuffleSupported is false.
+	///
+	/// May only be written if @@canControl and @@shuffleSupported are true.
+	Q_PROPERTY(bool shuffle READ shuffle WRITE setShuffle NOTIFY shuffleChanged);
+	Q_PROPERTY(bool shuffleSupported READ shuffleSupported NOTIFY shuffleSupportedChanged);
+	/// If the player is currently shown in fullscreen.
+	///
+	/// May only be written to if @@canSetFullscreen is true.
+	Q_PROPERTY(bool fullscreen READ fullscreen WRITE setFullscreen NOTIFY fullscreenChanged);
+	/// Uri schemes supported by @@openUri().
+	Q_PROPERTY(QList<QString> supportedUriSchemes READ default NOTIFY supportedUriSchemesChanged BINDABLE bindableSupportedUriSchemes);
+	/// Mime types supported by @@openUri().
+	Q_PROPERTY(QList<QString> supportedMimeTypes READ default NOTIFY supportedMimeTypesChanged BINDABLE bindableSupportedMimeTypes);
+	// clang-format on
+	QML_ELEMENT;
+	QML_UNCREATABLE("MprisPlayers can only be acquired from Mpris");
+
+public:
+	explicit MprisPlayer(const QString& address, QObject* parent = nullptr);
+
+	/// Bring the media player to the front of the window stack.
+	///
+	/// May only be called if @@canRaise is true.
+	Q_INVOKABLE void raise();
+	/// Quit the media player.
+	///
+	/// May only be called if @@canQuit is true.
+	Q_INVOKABLE void quit();
+	/// Open the given URI in the media player.
+	///
+	/// Many players will silently ignore this, especially if the uri
+	/// does not match @@supportedUriSchemes and @@supportedMimeTypes.
+	Q_INVOKABLE void openUri(const QString& uri);
+	/// Play the next song.
+	///
+	/// May only be called if @@canGoNext is true.
+	Q_INVOKABLE void next();
+	/// Play the previous song, or go back to the beginning of the current one.
+	///
+	/// May only be called if @@canGoPrevious is true.
+	Q_INVOKABLE void previous();
+	/// Change `position` by an offset.
+	///
+	/// Even if @@positionSupported is false and you cannot set `position`,
+	/// this function may work.
+	///
+	/// May only be called if @@canSeek is true.
+	Q_INVOKABLE void seek(qreal offset);
+	/// Equivalent to setting @@playbackState to `Playing`.
+	Q_INVOKABLE void play();
+	/// Equivalent to setting @@playbackState to `Paused`.
+	Q_INVOKABLE void pause();
+	/// Equivalent to setting @@playbackState to `Stopped`.
+	Q_INVOKABLE void stop();
+	/// Equivalent to calling @@play() if not playing or @@pause() if playing.
+	///
+	/// May only be called if @@canTogglePlaying is true, which is equivalent to
+	/// @@canPlay or @@canPause depending on the current playback state.
+	Q_INVOKABLE void togglePlaying();
+
+	[[nodiscard]] bool isValid() const;
+	[[nodiscard]] QString address() const;
+
+	[[nodiscard]] QBindable<bool> bindableCanControl() const { return &this->bCanControl; }
+	[[nodiscard]] QBindable<bool> bindableCanSeek() const { return &this->bCanSeek; }
+	[[nodiscard]] QBindable<bool> bindableCanGoNext() const { return &this->bCanGoNext; }
+	[[nodiscard]] QBindable<bool> bindableCanGoPrevious() const { return &this->bCanGoPrevious; }
+	[[nodiscard]] QBindable<bool> bindableCanPlay() const { return &this->bCanPlay; }
+	[[nodiscard]] QBindable<bool> bindableCanPause() const { return &this->bCanPause; }
+	[[nodiscard]] QBindable<bool> bindableCanTogglePlaying() const {
+		return &this->bCanTogglePlaying;
+	}
+	[[nodiscard]] QBindable<bool> bindableCanQuit() const { return &this->bCanQuit; }
+	[[nodiscard]] QBindable<bool> bindableCanRaise() const { return &this->bCanRaise; }
+	[[nodiscard]] QBindable<bool> bindableCanSetFullscreen() const {
+		return &this->bCanSetFullscreen;
+	}
+
+	[[nodiscard]] QBindable<QString> bindableIdentity() const { return &this->bIdentity; }
+	[[nodiscard]] QBindable<QString> bindableDesktopEntry() const { return &this->bDesktopEntry; }
+
+	[[nodiscard]] qlonglong positionMs() const;
+	[[nodiscard]] qreal position() const;
+	[[nodiscard]] bool positionSupported() const;
+	void setPosition(qreal position);
+
+	[[nodiscard]] qreal length() const;
+	[[nodiscard]] QBindable<bool> bindableLengthSupported() const { return &this->bLengthSupported; }
+
+	[[nodiscard]] qreal volume() const { return this->bVolume; }
+	[[nodiscard]] bool volumeSupported() const;
+	void setVolume(qreal volume);
+
+	[[nodiscard]] QBindable<quint32> bindableUniqueId() const { return &this->bUniqueId; }
+	[[nodiscard]] QBindable<QVariantMap> bindableMetadata() const { return &this->bMetadata; }
+	[[nodiscard]] QBindable<QString> bindableTrackTitle() const { return &this->bTrackTitle; }
+	[[nodiscard]] QBindable<QString> bindableTrackAlbum() const { return &this->bTrackAlbum; }
+	[[nodiscard]] QBindable<QString> bindableTrackAlbumArtist() const {
+		return &this->bTrackAlbumArtist;
+	}
+	[[nodiscard]] QBindable<QString> bindableTrackArtist() const { return &this->bTrackArtist; }
+	[[nodiscard]] QBindable<QString> bindableTrackArtUrl() const { return &this->bTrackArtUrl; }
+
+	[[nodiscard]] MprisPlaybackState::Enum playbackState() const { return this->bPlaybackState; }
+	void setPlaybackState(MprisPlaybackState::Enum playbackState);
+
+	[[nodiscard]] bool isPlaying() const { return this->bIsPlaying; }
+	void setPlaying(bool playing);
+
+	[[nodiscard]] MprisLoopState::Enum loopState() const { return this->bLoopState; }
+	[[nodiscard]] bool loopSupported() const;
+	void setLoopState(MprisLoopState::Enum loopState);
+
+	[[nodiscard]] qreal rate() const { return this->bRate; }
+	[[nodiscard]] QBindable<qreal> bindableMinRate() const { return &this->bRate; }
+	[[nodiscard]] QBindable<qreal> bindableMaxRate() const { return &this->bRate; }
+	void setRate(qreal rate);
+
+	[[nodiscard]] bool shuffle() const { return this->bShuffle; }
+	[[nodiscard]] bool shuffleSupported() const;
+	void setShuffle(bool shuffle);
+
+	[[nodiscard]] bool fullscreen() const { return this->bFullscreen; }
+	void setFullscreen(bool fullscreen);
+
+	[[nodiscard]] QBindable<QList<QString>> bindableSupportedUriSchemes() const {
+		return &this->bSupportedUriSchemes;
+	}
+
+	[[nodiscard]] QBindable<QList<QString>> bindableSupportedMimeTypes() const {
+		return &this->bSupportedMimeTypes;
+	}
+
+signals:
+	/// The track has changed.
+	///
+	/// All track information properties that were sent by the player
+	/// will be updated immediately following this signal. @@postTrackChanged
+	/// will be sent after they update.
+	///
+	/// Track information properties: @@uniqueId, @@metadata, @@trackTitle,
+	/// @@trackArtist, @@trackAlbum, @@trackAlbumArtist, @@trackArtUrl
+	///
+	/// > [!WARNING] Some particularly poorly behaved players will update metadata
+	/// > *before* indicating the track has changed.
+	void trackChanged();
+	/// Sent after track info related properties have been updated, following @@trackChanged.
+	///
+	/// > [!WARNING] It is not safe to assume all track information is up to date after
+	/// > this signal is emitted. A large number of players will update track information,
+	/// > particularly @@trackArtUrl, slightly after this signal.
+	void postTrackChanged();
+
+	QSDOC_HIDE void ready();
+	void canControlChanged();
+	void canPlayChanged();
+	void canPauseChanged();
+	void canTogglePlayingChanged();
+	void canSeekChanged();
+	void canGoNextChanged();
+	void canGoPreviousChanged();
+	void canQuitChanged();
+	void canRaiseChanged();
+	void canSetFullscreenChanged();
+	void identityChanged();
+	void desktopEntryChanged();
+	void positionChanged();
+	void positionSupportedChanged();
+	void lengthChanged();
+	void lengthSupportedChanged();
+	void volumeChanged();
+	void volumeSupportedChanged();
+	void metadataChanged();
+	void uniqueIdChanged();
+	void trackTitleChanged();
+	void trackArtistChanged();
+	void trackAlbumChanged();
+	void trackAlbumArtistChanged();
+	void trackArtUrlChanged();
+	void playbackStateChanged();
+	void isPlayingChanged();
+	void loopStateChanged();
+	void loopSupportedChanged();
+	void rateChanged();
+	void minRateChanged();
+	void maxRateChanged();
+	void shuffleChanged();
+	void shuffleSupportedChanged();
+	void fullscreenChanged();
+	void supportedUriSchemesChanged();
+	void supportedMimeTypesChanged();
+
+private slots:
+	void onGetAllFinished();
+	void onExportedPositionChanged();
+	void onSeek(qlonglong time);
+
+private:
+	void onMetadataChanged();
+	void onPositionUpdated();
+	void onPlaybackStatusUpdated();
+	// call instead of setting bpPosition
+	void setPosition(qlonglong position);
+	void requestPositionUpdate() { this->pPosition.requestUpdate(); }
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, QString, bIdentity, &MprisPlayer::identityChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, QString, bDesktopEntry, &MprisPlayer::desktopEntryChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bCanQuit, &MprisPlayer::canQuitChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bCanRaise, &MprisPlayer::canRaiseChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bFullscreen, &MprisPlayer::fullscreenChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bCanSetFullscreen, &MprisPlayer::canSetFullscreenChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, QList<QString>, bSupportedUriSchemes, &MprisPlayer::supportedUriSchemesChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, QList<QString>, bSupportedMimeTypes, &MprisPlayer::supportedMimeTypesChanged);
+
+	QS_DBUS_BINDABLE_PROPERTY_GROUP(MprisPlayer, appProperties);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pIdentity, bIdentity, appProperties, "Identity");
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pDesktopEntry, bDesktopEntry, appProperties, "DesktopEntry", false);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pCanQuit, bCanQuit, appProperties, "CanQuit", false);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pCanRaise, bCanRaise, appProperties, "CanRaise", false);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pFullscreen, bFullscreen, appProperties, "Fullscreen", false);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pCanSetFullscreen, bCanSetFullscreen, appProperties, "CanSetFullscreen", false);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pSupportedUriSchemes, bSupportedUriSchemes, appProperties, "SupportedUriSchemes", false);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pSupportedMimeTypes, bSupportedMimeTypes, appProperties, "SupportedMimeTypes", false);
+
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bpCanPlay);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bpCanPause);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bpCanSeek);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bpCanGoNext);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bpCanGoPrevious);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, QVariantMap, bpMetadata);
+	QS_BINDING_SUBSCRIBE_METHOD(MprisPlayer, bpMetadata, onMetadataChanged, onValueChanged);
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(MprisPlayer, qlonglong, bpPosition, -1, &MprisPlayer::positionChanged);
+
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bCanControl, &MprisPlayer::canControlChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bCanPlay, &MprisPlayer::canPlayChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bCanPause, &MprisPlayer::canPauseChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bCanTogglePlaying, &MprisPlayer::canTogglePlayingChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bCanSeek, &MprisPlayer::canSeekChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bCanGoNext, &MprisPlayer::canGoNextChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bCanGoPrevious, &MprisPlayer::canGoPreviousChanged);
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(MprisPlayer, qreal, bVolume, 1, &MprisPlayer::volumeChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, MprisPlaybackState::Enum, bPlaybackState, &MprisPlayer::playbackStateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bIsPlaying, &MprisPlayer::isPlayingChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(MprisPlayer, bPlaybackState, requestPositionUpdate, onValueChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, MprisLoopState::Enum, bLoopState, &MprisPlayer::loopStateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(MprisPlayer, qreal, bRate, 1, &MprisPlayer::rateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(MprisPlayer, qreal, bMinRate, 1, &MprisPlayer::minRateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(MprisPlayer, qreal, bMaxRate, 1, &MprisPlayer::maxRateChanged);
+
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, QVariantMap, bMetadata, &MprisPlayer::metadataChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, quint32, bUniqueId, &MprisPlayer::uniqueIdChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, QString, bTrackTitle, &MprisPlayer::trackTitleChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, QString, bTrackArtist, &MprisPlayer::trackArtistChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, QString, bTrackAlbum, &MprisPlayer::trackAlbumChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, QString, bTrackAlbumArtist, &MprisPlayer::trackAlbumArtistChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, QString, bTrackArtUrl, &MprisPlayer::trackArtUrlChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, qlonglong, bInternalLength, &MprisPlayer::lengthChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bLengthSupported, &MprisPlayer::lengthSupportedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MprisPlayer, bool, bShuffle, &MprisPlayer::shuffleChanged);
+
+	QS_DBUS_BINDABLE_PROPERTY_GROUP(MprisPlayer, playerProperties);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pCanControl, bCanControl, playerProperties, "CanControl");
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pCanPlay, bpCanPlay, playerProperties, "CanPlay");
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pCanPause, bpCanPause, playerProperties, "CanPause");
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pCanSeek, bpCanSeek, playerProperties, "CanSeek");
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pCanGoNext, bpCanGoNext, playerProperties, "CanGoNext");
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pCanGoPrevious, bpCanGoPrevious, playerProperties, "CanGoPrevious");
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, qlonglong, pPosition, bpPosition, onPositionUpdated, playerProperties, "Position", false);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pVolume, bVolume, playerProperties, "Volume", false);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pMetadata, bpMetadata, playerProperties, "Metadata");
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, void, pPlaybackStatus, bPlaybackState, onPlaybackStatusUpdated, playerProperties, "PlaybackStatus", true);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pLoopStatus, bLoopState, playerProperties, "LoopStatus", false);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pRate, bRate, playerProperties, "Rate", false);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pMinRate, bMinRate, playerProperties, "MinimumRate", false);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pMaxRate, bMaxRate, playerProperties, "MaximumRate", false);
+	QS_DBUS_PROPERTY_BINDING(MprisPlayer, pShuffle, bShuffle, playerProperties, "Shuffle", false);
+	// clang-format on
+
+	QDateTime lastPositionTimestamp;
+	QDateTime pausedTime;
+
+	DBusMprisPlayerApp* app = nullptr;
+	DBusMprisPlayer* player = nullptr;
+	QString mTrackId;
+	QString mTrackUrl;
+	QString mTrackTitle;
+	bool trackChangedBeforeState = false;
+};
+
+} // namespace qs::service::mpris
diff --git a/src/services/mpris/watcher.cpp b/src/services/mpris/watcher.cpp
new file mode 100644
index 00000000..fdfe97ad
--- /dev/null
+++ b/src/services/mpris/watcher.cpp
@@ -0,0 +1,117 @@
+#include "watcher.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdbusconnection.h>
+#include <qdbusconnectioninterface.h>
+#include <qdbusservicewatcher.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qqmllist.h>
+
+#include "../../core/logcat.hpp"
+#include "../../core/model.hpp"
+#include "player.hpp"
+
+namespace qs::service::mpris {
+
+namespace {
+QS_LOGGING_CATEGORY(logMprisWatcher, "quickshell.service.mpris.watcher", QtWarningMsg);
+}
+
+MprisWatcher::MprisWatcher() {
+	qCDebug(logMprisWatcher) << "Starting MprisWatcher";
+
+	auto bus = QDBusConnection::sessionBus();
+
+	if (!bus.isConnected()) {
+		qCWarning(logMprisWatcher) << "Could not connect to DBus. Mpris service will not work.";
+		return;
+	}
+
+	// clang-format off
+	QObject::connect(&this->serviceWatcher, &QDBusServiceWatcher::serviceRegistered, this, &MprisWatcher::onServiceRegistered);
+	QObject::connect(&this->serviceWatcher, &QDBusServiceWatcher::serviceUnregistered, this, &MprisWatcher::onServiceUnregistered);
+	// clang-format on
+
+	this->serviceWatcher.setWatchMode(
+	    QDBusServiceWatcher::WatchForUnregistration | QDBusServiceWatcher::WatchForRegistration
+	);
+
+	this->serviceWatcher.addWatchedService("org.mpris.MediaPlayer2*");
+	this->serviceWatcher.setConnection(bus);
+
+	this->registerExisting();
+}
+
+void MprisWatcher::registerExisting() {
+	const QStringList& list = QDBusConnection::sessionBus().interface()->registeredServiceNames();
+	for (const QString& service: list) {
+		if (service.startsWith("org.mpris.MediaPlayer2")) {
+			qCDebug(logMprisWatcher).noquote() << "Found Mpris service" << service;
+			this->registerPlayer(service);
+		}
+	}
+}
+
+void MprisWatcher::onServiceRegistered(const QString& service) {
+	if (service.startsWith("org.mpris.MediaPlayer2")) {
+		qCDebug(logMprisWatcher).noquote() << "Mpris service " << service << " registered.";
+		this->registerPlayer(service);
+	} else {
+		qCWarning(logMprisWatcher) << "Got a registration event for untracked service" << service;
+	}
+}
+
+void MprisWatcher::onServiceUnregistered(const QString& service) {
+	if (auto* player = this->mPlayers.value(service)) {
+		player->deleteLater();
+		this->mPlayers.remove(service);
+		qCDebug(logMprisWatcher) << "Unregistered MprisPlayer" << service;
+	} else {
+		qCWarning(logMprisWatcher) << "Got service unregister event for untracked service" << service;
+	}
+}
+
+void MprisWatcher::onPlayerReady() {
+	auto* player = qobject_cast<MprisPlayer*>(this->sender());
+	this->readyPlayers.insertObject(player);
+}
+
+void MprisWatcher::onPlayerDestroyed(QObject* object) {
+	auto* player = static_cast<MprisPlayer*>(object); // NOLINT
+	this->readyPlayers.removeObject(player);
+}
+
+ObjectModel<MprisPlayer>* MprisWatcher::players() { return &this->readyPlayers; }
+
+void MprisWatcher::registerPlayer(const QString& address) {
+	if (this->mPlayers.contains(address)) {
+		qCDebug(logMprisWatcher) << "Skipping duplicate registration of MprisPlayer" << address;
+		return;
+	}
+
+	auto* player = new MprisPlayer(address, this);
+	if (!player->isValid()) {
+		qCWarning(logMprisWatcher) << "Ignoring invalid MprisPlayer registration of" << address;
+		delete player;
+		return;
+	}
+
+	this->mPlayers.insert(address, player);
+	QObject::connect(player, &MprisPlayer::ready, this, &MprisWatcher::onPlayerReady);
+	QObject::connect(player, &QObject::destroyed, this, &MprisWatcher::onPlayerDestroyed);
+
+	qCDebug(logMprisWatcher) << "Registered MprisPlayer" << address;
+}
+
+MprisWatcher* MprisWatcher::instance() {
+	static MprisWatcher* instance = new MprisWatcher(); // NOLINT
+	return instance;
+}
+
+ObjectModel<MprisPlayer>* MprisQml::players() { // NOLINT
+	return MprisWatcher::instance()->players();
+}
+
+} // namespace qs::service::mpris
diff --git a/src/services/mpris/watcher.hpp b/src/services/mpris/watcher.hpp
new file mode 100644
index 00000000..cbe96690
--- /dev/null
+++ b/src/services/mpris/watcher.hpp
@@ -0,0 +1,59 @@
+#pragma once
+
+#include <qdbuscontext.h>
+#include <qdbusinterface.h>
+#include <qdbusservicewatcher.h>
+#include <qhash.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+
+#include "../../core/doc.hpp"
+#include "../../core/model.hpp"
+#include "player.hpp"
+
+namespace qs::service::mpris {
+
+///! Provides access to MprisPlayers.
+class MprisWatcher: public QObject {
+	Q_OBJECT;
+
+public:
+	[[nodiscard]] ObjectModel<MprisPlayer>* players();
+
+	static MprisWatcher* instance();
+
+private slots:
+	void onServiceRegistered(const QString& service);
+	void onServiceUnregistered(const QString& service);
+	void onPlayerReady();
+	void onPlayerDestroyed(QObject* object);
+
+private:
+	explicit MprisWatcher();
+
+	void registerExisting();
+	void registerPlayer(const QString& address);
+
+	QDBusServiceWatcher serviceWatcher;
+	QHash<QString, MprisPlayer*> mPlayers;
+	ObjectModel<MprisPlayer> readyPlayers {this};
+};
+
+class MprisQml: public QObject {
+	Q_OBJECT;
+	QML_NAMED_ELEMENT(Mpris);
+	QML_SINGLETON;
+	/// All connected MPRIS players.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::service::mpris::MprisPlayer>*);
+	Q_PROPERTY(UntypedObjectModel* players READ players CONSTANT);
+
+public:
+	explicit MprisQml(QObject* parent = nullptr): QObject(parent) {}
+
+	[[nodiscard]] ObjectModel<MprisPlayer>* players();
+};
+
+} // namespace qs::service::mpris
diff --git a/src/services/notifications/CMakeLists.txt b/src/services/notifications/CMakeLists.txt
new file mode 100644
index 00000000..58b6648c
--- /dev/null
+++ b/src/services/notifications/CMakeLists.txt
@@ -0,0 +1,31 @@
+qt_add_dbus_adaptor(DBUS_INTERFACES
+	org.freedesktop.Notifications.xml
+	server.hpp
+	qs::service::notifications::NotificationServer
+	dbus_notifications
+	DBusNotificationServer
+)
+
+qt_add_library(quickshell-service-notifications STATIC
+	server.cpp
+	notification.cpp
+	dbusimage.cpp
+	qml.cpp
+	${DBUS_INTERFACES}
+)
+
+# dbus headers
+target_include_directories(quickshell-service-notifications PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+
+qt_add_qml_module(quickshell-service-notifications
+	URI Quickshell.Services.Notifications
+	VERSION 0.1
+)
+
+qs_add_module_deps_light(quickshell-service-notifications Quickshell)
+install_qml_module(quickshell-service-notifications)
+
+target_link_libraries(quickshell-service-notifications PRIVATE Qt::Quick Qt::DBus)
+target_link_libraries(quickshell PRIVATE quickshell-service-notificationsplugin)
+
+qs_module_pch(quickshell-service-notifications SET dbus)
diff --git a/src/services/notifications/dbusimage.cpp b/src/services/notifications/dbusimage.cpp
new file mode 100644
index 00000000..469d08c0
--- /dev/null
+++ b/src/services/notifications/dbusimage.cpp
@@ -0,0 +1,74 @@
+#include "dbusimage.hpp"
+
+#include <qdbusargument.h>
+#include <qimage.h>
+#include <qloggingcategory.h>
+#include <qsize.h>
+#include <qsysinfo.h>
+#include <qtypes.h>
+
+#include "../../core/logcat.hpp"
+
+namespace qs::service::notifications {
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+QS_DECLARE_LOGGING_CATEGORY(logNotifications); // server.cpp
+
+QImage DBusNotificationImage::createImage() const {
+	auto format = this->hasAlpha ? QImage::Format_RGBA8888 : QImage::Format_RGB888;
+
+	return QImage(
+	    reinterpret_cast<const uchar*>(this->data.data()),
+	    this->width,
+	    this->height,
+	    format
+	);
+}
+
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusNotificationImage& pixmap) {
+	argument.beginStructure();
+	argument >> pixmap.width;
+	argument >> pixmap.height;
+	auto rowstride = qdbus_cast<qint32>(argument);
+	argument >> pixmap.hasAlpha;
+	auto sampleBits = qdbus_cast<qint32>(argument);
+	auto channels = qdbus_cast<qint32>(argument);
+	argument >> pixmap.data;
+	argument.endStructure();
+
+	if (sampleBits != 8) {
+		qCWarning(logNotifications) << "Unable to parse pixmap as sample count is incorrect. Got"
+		                            << sampleBits << "expected" << 8;
+	} else if (channels != (pixmap.hasAlpha ? 4 : 3)) {
+		qCWarning(logNotifications) << "Unable to parse pixmap as channel count is incorrect."
+		                            << "Got " << channels << "expected" << (pixmap.hasAlpha ? 4 : 3);
+	} else if (rowstride != pixmap.width * channels) {
+		qCWarning(logNotifications) << "Unable to parse pixmap as rowstride is incorrect. Got"
+		                            << rowstride << "expected" << (pixmap.width * channels);
+	}
+
+	return argument;
+}
+
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusNotificationImage& pixmap) {
+	argument.beginStructure();
+	argument << pixmap.width;
+	argument << pixmap.height;
+	argument << pixmap.width * (pixmap.hasAlpha ? 4 : 3);
+	argument << pixmap.hasAlpha;
+	argument << 8;
+	argument << (pixmap.hasAlpha ? 4 : 3);
+	argument << pixmap.data;
+	argument.endStructure();
+	return argument;
+}
+
+QImage
+NotificationImage::requestImage(const QString& /*unused*/, QSize* size, const QSize& /*unused*/) {
+	auto image = this->image.createImage();
+
+	if (size != nullptr) *size = image.size();
+	return image;
+}
+
+} // namespace qs::service::notifications
diff --git a/src/services/notifications/dbusimage.hpp b/src/services/notifications/dbusimage.hpp
new file mode 100644
index 00000000..c310d95e
--- /dev/null
+++ b/src/services/notifications/dbusimage.hpp
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <qdbusargument.h>
+#include <qimage.h>
+#include <qobject.h>
+
+#include "../../core/imageprovider.hpp"
+
+namespace qs::service::notifications {
+
+struct DBusNotificationImage {
+	qint32 width = 0;
+	qint32 height = 0;
+	bool hasAlpha = false;
+	QByteArray data;
+
+	// valid only for the lifetime of the pixmap
+	[[nodiscard]] QImage createImage() const;
+};
+
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusNotificationImage& pixmap);
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusNotificationImage& pixmap);
+
+class NotificationImage: public QsIndexedImageHandle {
+public:
+	explicit NotificationImage(): QsIndexedImageHandle(QQuickAsyncImageProvider::Image) {}
+
+	[[nodiscard]] bool hasData() const { return !this->image.data.isEmpty(); }
+	void clear() { this->image.data.clear(); }
+
+	[[nodiscard]] DBusNotificationImage& writeImage() {
+		this->imageChanged();
+		return this->image;
+	}
+
+	QImage requestImage(const QString& id, QSize* size, const QSize& requestedSize) override;
+
+private:
+	DBusNotificationImage image;
+};
+
+} // namespace qs::service::notifications
diff --git a/src/services/notifications/module.md b/src/services/notifications/module.md
new file mode 100644
index 00000000..8e9ed2c1
--- /dev/null
+++ b/src/services/notifications/module.md
@@ -0,0 +1,4 @@
+name = "Quickshell.Services.Notifications"
+description = "Types for implementing a notification daemon"
+headers = [ "qml.hpp", "notification.hpp" ]
+-----
diff --git a/src/services/notifications/notification.cpp b/src/services/notifications/notification.cpp
new file mode 100644
index 00000000..c5269f32
--- /dev/null
+++ b/src/services/notifications/notification.cpp
@@ -0,0 +1,247 @@
+#include "notification.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdbusargument.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/desktopentry.hpp"
+#include "../../core/iconimageprovider.hpp"
+#include "../../core/logcat.hpp"
+#include "dbusimage.hpp"
+#include "server.hpp"
+
+namespace qs::service::notifications {
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+QS_DECLARE_LOGGING_CATEGORY(logNotifications); // server.cpp
+
+QString NotificationUrgency::toString(NotificationUrgency::Enum value) {
+	switch (value) {
+	case NotificationUrgency::Low: return "Low";
+	case NotificationUrgency::Normal: return "Normal";
+	case NotificationUrgency::Critical: return "Critical";
+	default: return "Invalid notification urgency";
+	}
+}
+
+QString NotificationCloseReason::toString(NotificationCloseReason::Enum value) {
+	switch (value) {
+	case NotificationCloseReason::Expired: return "Expired";
+	case NotificationCloseReason::Dismissed: return "Dismissed";
+	case NotificationCloseReason::CloseRequested: return "CloseRequested";
+	default: return "Invalid notification close reason";
+	}
+}
+
+QString NotificationAction::identifier() const { return this->mIdentifier; }
+QString NotificationAction::text() const { return this->mText; }
+
+void NotificationAction::invoke() {
+	if (this->notification->isRetained()) {
+		qCritical() << "Cannot invoke destroyed notification" << this;
+		return;
+	}
+
+	NotificationServer::instance()->ActionInvoked(this->notification->id(), this->mIdentifier);
+
+	if (!this->notification->bindableResident().value()) {
+		this->notification->close(NotificationCloseReason::Dismissed);
+	}
+}
+
+void NotificationAction::setText(const QString& text) {
+	if (text != this->mText) return;
+
+	this->mText = text;
+	emit this->textChanged();
+}
+
+void Notification::expire() { this->close(NotificationCloseReason::Expired); }
+void Notification::dismiss() { this->close(NotificationCloseReason::Dismissed); }
+
+void Notification::close(NotificationCloseReason::Enum reason) {
+	if (this->isRetained()) {
+		qCritical() << "Cannot close destroyed notification" << this;
+		return;
+	}
+
+	this->mCloseReason = reason;
+
+	if (reason != 0) {
+		NotificationServer::instance()->deleteNotification(this, reason);
+	}
+}
+
+void Notification::sendInlineReply(const QString& replyText) {
+	if (!NotificationServer::instance()->support.inlineReply) {
+		qCritical() << "Inline reply support disabled on server";
+		return;
+	}
+
+	if (!this->bHasInlineReply) {
+		qCritical() << "Cannot send reply to notification without inline-reply action";
+		return;
+	}
+
+	if (this->isRetained()) {
+		qCritical() << "Cannot send reply to destroyed notification" << this;
+		return;
+	}
+
+	NotificationServer::instance()->NotificationReplied(this->id(), replyText);
+
+	if (!this->bindableResident().value()) {
+		this->close(NotificationCloseReason::Dismissed);
+	}
+}
+
+void Notification::updateProperties(
+    const QString& appName,
+    QString appIcon,
+    const QString& summary,
+    const QString& body,
+    const QStringList& actions,
+    QVariantMap hints,
+    qint32 expireTimeout
+) {
+	Qt::beginPropertyUpdateGroup();
+
+	this->bExpireTimeout = expireTimeout;
+	this->bAppName = appName;
+	this->bSummary = summary;
+	this->bBody = body;
+	this->bHasActionIcons = hints.value("action-icons").toBool();
+	this->bResident = hints.value("resident").toBool();
+	this->bTransient = hints.value("transient").toBool();
+	this->bDesktopEntry = hints.value("desktop-entry").toString();
+
+	this->bUrgency = hints.contains("urgency")
+	                   ? hints.value("urgency").value<NotificationUrgency::Enum>()
+	                   : NotificationUrgency::Normal;
+
+	if (appIcon.isEmpty() && !this->bDesktopEntry.value().isEmpty()) {
+		if (auto* entry = DesktopEntryManager::instance()->byId(this->bDesktopEntry.value())) {
+			appIcon = entry->mIcon;
+		}
+	}
+
+	this->bAppIcon = appIcon;
+
+	QString imageDataName;
+	if (hints.contains("image-data")) imageDataName = "image-data";
+	else if (hints.contains("image_data")) imageDataName = "image_data";
+	else if (hints.contains("icon_data")) imageDataName = "icon_data";
+
+	QString imagePath;
+
+	if (imageDataName.isEmpty()) {
+		this->mImagePixmap.clear();
+	} else {
+		auto value = hints.value(imageDataName).value<QDBusArgument>();
+		value >> this->mImagePixmap.writeImage();
+		imagePath = this->mImagePixmap.url();
+	}
+
+	// don't store giant byte arrays longer than necessary
+	hints.remove("image-data");
+	hints.remove("image_data");
+	hints.remove("icon_data");
+
+	if (!this->mImagePixmap.hasData()) {
+		QString imagePathName;
+		if (hints.contains("image-path")) imagePathName = "image-path";
+		else if (hints.contains("image_path")) imagePathName = "image_path";
+
+		if (!imagePathName.isEmpty()) {
+			imagePath = hints.value(imagePathName).value<QString>();
+
+			if (!imagePath.startsWith("file:")) {
+				imagePath = IconImageProvider::requestString(imagePath, "");
+			}
+		}
+	}
+
+	this->bImage = imagePath;
+	this->bHints = hints;
+
+	bool actionsChanged = false;
+	auto deletedActions = QVector<NotificationAction*>();
+
+	if (actions.length() % 2 == 0) {
+		int ai = 0;
+		for (auto i = 0; i != actions.length(); i += 2) {
+			const auto& identifier = actions.at(i);
+			const auto& text = actions.at(i + 1);
+
+			if (identifier == "inline-reply" && NotificationServer::instance()->support.inlineReply) {
+				if (this->bHasInlineReply) {
+					qCWarning(logNotifications) << this << '(' << appName << ')'
+					                            << "sent an action set with duplicate inline-reply actions.";
+				} else {
+					this->bHasInlineReply = true;
+					this->bInlineReplyPlaceholder = text;
+				}
+				// skip inserting this action into action list
+				continue;
+			}
+
+			auto* action = ai < this->mActions.length() ? this->mActions.at(ai) : nullptr;
+
+			if (action && identifier == action->identifier()) {
+				action->setText(text);
+			} else {
+				auto* newAction = new NotificationAction(identifier, text, this);
+
+				if (action) {
+					deletedActions.push_back(action);
+					this->mActions.replace(ai, newAction);
+				} else {
+					this->mActions.push_back(newAction);
+				}
+
+				actionsChanged = true;
+			}
+
+			ai++;
+		}
+
+		for (auto i = this->mActions.length(); i > ai; i--) {
+			deletedActions.push_back(this->mActions.at(i - 1));
+			this->mActions.remove(i - 1);
+			actionsChanged = true;
+		}
+	} else {
+		qCWarning(logNotifications) << this << '(' << appName << ')'
+		                            << "sent an action set of an invalid length.";
+	}
+
+	Qt::endPropertyUpdateGroup();
+
+	if (actionsChanged) emit this->actionsChanged();
+
+	for (auto* action: deletedActions) {
+		delete action;
+	}
+}
+
+quint32 Notification::id() const { return this->mId; }
+bool Notification::isTracked() const { return this->mCloseReason == 0; }
+QList<NotificationAction*> Notification::actions() const { return this->mActions; }
+NotificationCloseReason::Enum Notification::closeReason() const { return this->mCloseReason; }
+
+void Notification::setTracked(bool tracked) {
+	this->close(
+	    tracked ? static_cast<NotificationCloseReason::Enum>(0) : NotificationCloseReason::Dismissed
+	);
+}
+
+bool Notification::isLastGeneration() const { return this->mLastGeneration; }
+void Notification::setLastGeneration() { this->mLastGeneration = true; }
+
+} // namespace qs::service::notifications
diff --git a/src/services/notifications/notification.hpp b/src/services/notifications/notification.hpp
new file mode 100644
index 00000000..7f5246c1
--- /dev/null
+++ b/src/services/notifications/notification.hpp
@@ -0,0 +1,276 @@
+#pragma once
+
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qlist.h>
+#include <qmap.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/retainable.hpp"
+#include "../../core/util.hpp"
+#include "dbusimage.hpp"
+
+namespace qs::service::notifications {
+
+///! The urgency level of a Notification.
+/// See @@Notification.urgency.
+class NotificationUrgency: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		Low = 0,
+		Normal = 1,
+		Critical = 2,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(qs::service::notifications::NotificationUrgency::Enum value);
+};
+
+///! The reason a Notification was closed.
+/// See @@Notification.closed(s).
+class NotificationCloseReason: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		/// The notification expired due to a timeout.
+		Expired = 1,
+		/// The notification was explicitly dismissed by the user.
+		Dismissed = 2,
+		/// The remote application requested the notification be removed.
+		CloseRequested = 3,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString
+	toString(qs::service::notifications::NotificationCloseReason::Enum value);
+};
+
+class NotificationAction;
+
+///! A notification emitted by a NotificationServer.
+/// A notification emitted by a NotificationServer.
+///
+/// > [!INFO] This type is @@Quickshell.Retainable. It
+/// > can be retained after destruction if necessary.
+class Notification
+    : public QObject
+    , public Retainable {
+	Q_OBJECT;
+	// clang-format off
+	/// Id of the notification as given to the client.
+	Q_PROPERTY(quint32 id READ id CONSTANT);
+	/// If the notification is tracked by the notification server.
+	///
+	/// Setting this property to false is equivalent to calling @@dismiss().
+	Q_PROPERTY(bool tracked READ isTracked WRITE setTracked NOTIFY trackedChanged);
+	/// If this notification was carried over from the last generation
+	/// when quickshell reloaded.
+	///
+	/// Notifications from the last generation will only be emitted
+	/// if @@NotificationServer.keepOnReload is true.
+	Q_PROPERTY(bool lastGeneration READ isLastGeneration CONSTANT);
+	/// Time in seconds the notification should be valid for
+	Q_PROPERTY(qreal expireTimeout READ default NOTIFY expireTimeoutChanged BINDABLE bindableExpireTimeout);
+	/// The sending application's name.
+	Q_PROPERTY(QString appName READ default NOTIFY appNameChanged BINDABLE bindableAppName);
+	/// The sending application's icon. If none was provided, then the icon from an associated
+	/// desktop entry will be retrieved. If none was found then "".
+	Q_PROPERTY(QString appIcon READ default NOTIFY appIconChanged BINDABLE bindableAppIcon);
+	/// The image associated with this notification, or "" if none.
+	Q_PROPERTY(QString summary READ default NOTIFY summaryChanged BINDABLE bindableSummary);
+	Q_PROPERTY(QString body READ default NOTIFY bodyChanged BINDABLE bindableBody);
+	Q_PROPERTY(qs::service::notifications::NotificationUrgency::Enum urgency READ default NOTIFY urgencyChanged BINDABLE bindableUrgency);
+	/// Actions that can be taken for this notification.
+	Q_PROPERTY(QList<qs::service::notifications::NotificationAction*> actions READ actions NOTIFY actionsChanged);
+	/// If actions associated with this notification have icons available.
+	///
+	/// See @@NotificationAction.identifier for details.
+	Q_PROPERTY(bool hasActionIcons READ default NOTIFY hasActionIconsChanged BINDABLE bindableHasActionIcons);
+	/// If true, the notification will not be destroyed after an action is invoked.
+	Q_PROPERTY(bool resident READ default NOTIFY residentChanged BINDABLE bindableResident);
+	/// If true, the notification should skip any kind of persistence function like a notification area.
+	Q_PROPERTY(bool transient READ default NOTIFY transientChanged BINDABLE bindableTransient);
+	/// The name of the sender's desktop entry or "" if none was supplied.
+	Q_PROPERTY(QString desktopEntry READ default NOTIFY desktopEntryChanged BINDABLE bindableDesktopEntry);
+	/// An image associated with the notification.
+	///
+	/// This image is often something like a profile picture in instant messaging applications.
+	Q_PROPERTY(QString image READ default NOTIFY imageChanged BINDABLE bindableImage);
+	/// If true, the notification has an inline reply action.
+	/// 
+	/// A quick reply text field should be displayed and the reply can be sent using @@sendInlineReply().
+	Q_PROPERTY(bool hasInlineReply READ default NOTIFY hasInlineReplyChanged BINDABLE bindableHasInlineReply);
+	/// The placeholder text/button caption for the inline reply.
+	Q_PROPERTY(QString inlineReplyPlaceholder READ default NOTIFY inlineReplyPlaceholderChanged BINDABLE bindableInlineReplyPlaceholder);
+	/// All hints sent by the client application as a javascript object.
+	/// Many common hints are exposed via other properties.
+	Q_PROPERTY(QVariantMap hints READ default NOTIFY hintsChanged BINDABLE bindableHints);
+	// clang-format on
+	QML_ELEMENT;
+	QML_UNCREATABLE("Notifications must be acquired from a NotificationServer");
+
+public:
+	explicit Notification(quint32 id, QObject* parent): QObject(parent), mId(id) {}
+
+	/// Destroy the notification and hint to the remote application that it has
+	/// timed out an expired.
+	Q_INVOKABLE void expire();
+	/// Destroy the notification and hint to the remote application that it was
+	/// explicitly closed by the user.
+	Q_INVOKABLE void dismiss();
+
+	/// Send an inline reply to the notification with an inline reply action.
+	/// > [!WARNING] This method can only be called if
+	/// > @@hasInlineReply is true
+	/// > and the server has @@NotificationServer.inlineReplySupported set to true.
+	Q_INVOKABLE void sendInlineReply(const QString& replyText);
+
+	void updateProperties(
+	    const QString& appName,
+	    QString appIcon,
+	    const QString& summary,
+	    const QString& body,
+	    const QStringList& actions,
+	    QVariantMap hints,
+	    qint32 expireTimeout
+	);
+
+	void close(NotificationCloseReason::Enum reason);
+
+	[[nodiscard]] quint32 id() const;
+	[[nodiscard]] bool isTracked() const;
+
+	[[nodiscard]] bool isLastGeneration() const;
+	void setLastGeneration();
+
+	[[nodiscard]] QBindable<qreal> bindableExpireTimeout() const { return &this->bExpireTimeout; }
+	[[nodiscard]] QBindable<QString> bindableAppName() const { return &this->bAppName; }
+	[[nodiscard]] QBindable<QString> bindableAppIcon() const { return &this->bAppIcon; }
+	[[nodiscard]] QBindable<QString> bindableSummary() const { return &this->bSummary; }
+	[[nodiscard]] QBindable<QString> bindableBody() const { return &this->bBody; }
+	[[nodiscard]] QBindable<NotificationUrgency ::Enum> bindableUrgency() const {
+		return &this->bUrgency;
+	}
+
+	[[nodiscard]] QList<NotificationAction*> actions() const;
+
+	[[nodiscard]] QBindable<bool> bindableHasActionIcons() const { return &this->bHasActionIcons; }
+	[[nodiscard]] QBindable<bool> bindableResident() const { return &this->bResident; }
+	[[nodiscard]] QBindable<bool> bindableTransient() const { return &this->bTransient; }
+	[[nodiscard]] QBindable<QString> bindableDesktopEntry() const { return &this->bDesktopEntry; }
+	[[nodiscard]] QBindable<QString> bindableImage() const { return &this->bImage; }
+	[[nodiscard]] QBindable<bool> bindableHasInlineReply() const { return &this->bHasInlineReply; }
+
+	[[nodiscard]] QBindable<QString> bindableInlineReplyPlaceholder() const {
+		return &this->bInlineReplyPlaceholder;
+	}
+
+	[[nodiscard]] QBindable<QVariantMap> bindableHints() const { return &this->bHints; }
+
+	[[nodiscard]] NotificationCloseReason::Enum closeReason() const;
+	void setTracked(bool tracked);
+
+signals:
+	/// Sent when a notification has been closed.
+	///
+	/// The notification object will be destroyed as soon as all signal handlers exit.
+	void closed(qs::service::notifications::NotificationCloseReason::Enum reason);
+
+	void trackedChanged();
+	void expireTimeoutChanged();
+	void appNameChanged();
+	void appIconChanged();
+	void summaryChanged();
+	void bodyChanged();
+	void urgencyChanged();
+	void actionsChanged();
+	void hasActionIconsChanged();
+	void residentChanged();
+	void transientChanged();
+	void desktopEntryChanged();
+	void imageChanged();
+	void hasInlineReplyChanged();
+	void inlineReplyPlaceholderChanged();
+	void hintsChanged();
+
+private:
+	quint32 mId;
+	NotificationCloseReason::Enum mCloseReason = NotificationCloseReason::Dismissed;
+	bool mLastGeneration = false;
+	NotificationImage mImagePixmap;
+	QList<NotificationAction*> mActions;
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(Notification, qreal, bExpireTimeout, &Notification::expireTimeoutChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Notification, QString, bAppName, &Notification::appNameChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Notification, QString, bAppIcon, &Notification::appIconChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Notification, QString, bSummary, &Notification::summaryChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Notification, QString, bBody, &Notification::bodyChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Notification, bool, bHasActionIcons, &Notification::hasActionIconsChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Notification, bool, bResident, &Notification::residentChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Notification, bool, bTransient, &Notification::transientChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Notification, QString, bDesktopEntry, &Notification::desktopEntryChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Notification, QString, bImage, &Notification::imageChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Notification, bool, bHasInlineReply, &Notification::hasInlineReplyChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Notification, QString, bInlineReplyPlaceholder, &Notification::inlineReplyPlaceholderChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Notification, QVariantMap, bHints, &Notification::hintsChanged);
+	// clang-format on
+
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(
+	    Notification,
+	    NotificationUrgency::Enum,
+	    bUrgency,
+	    NotificationUrgency::Normal,
+	    &Notification::urgencyChanged
+	);
+};
+
+///! An action associated with a Notification.
+/// See @@Notification.actions.
+class NotificationAction: public QObject {
+	Q_OBJECT;
+	/// The identifier of the action.
+	///
+	/// When @@Notification.hasActionIcons is true, this property will be an icon name.
+	/// When it is false, this property is irrelevant.
+	Q_PROPERTY(QString identifier READ identifier CONSTANT);
+	/// The localized text that should be displayed on a button.
+	Q_PROPERTY(QString text READ text NOTIFY textChanged);
+	QML_ELEMENT;
+	QML_UNCREATABLE("NotificationActions must be acquired from a Notification");
+
+public:
+	explicit NotificationAction(QString identifier, QString text, Notification* notification)
+	    : QObject(notification)
+	    , notification(notification)
+	    , mIdentifier(std::move(identifier))
+	    , mText(std::move(text)) {}
+
+	/// Invoke the action. If @@Notification.resident is false it will be dismissed.
+	Q_INVOKABLE void invoke();
+
+	[[nodiscard]] QString identifier() const;
+	[[nodiscard]] QString text() const;
+	void setText(const QString& text);
+
+signals:
+	void textChanged();
+
+private:
+	Notification* notification;
+	QString mIdentifier;
+	QString mText;
+};
+
+} // namespace qs::service::notifications
diff --git a/src/services/notifications/org.freedesktop.Notifications.xml b/src/services/notifications/org.freedesktop.Notifications.xml
new file mode 100644
index 00000000..3d99db09
--- /dev/null
+++ b/src/services/notifications/org.freedesktop.Notifications.xml
@@ -0,0 +1,51 @@
+<node>
+	<interface name="org.freedesktop.Notifications">
+		<method name="GetCapabilities">
+			<arg name="capabilities" type="as" direction="out"/>
+		</method>
+
+		<method name="Notify">
+			<arg name="appName" type="s" direction="in"/>
+			<arg name="replacesId" type="u" direction="in"/>
+			<arg name="appIcon" type="s" direction="in"/>
+			<arg name="summary" type="s" direction="in"/>
+			<arg name="body" type="s" direction="in"/>
+			<arg name="actions" type="as" direction="in"/>
+			<arg name="hints" type="a{sv}" direction="in"/>
+			<arg name="expireTimeout" type="i" direction="in"/>
+			<arg name="id" type="u" direction="out"/>
+			<annotation name="org.qtproject.QtDBus.QtTypeName.In6" value="QVariantMap"/>
+		</method>
+
+		<method name="CloseNotification">
+			<arg name="id" type="u" direction="in"/>
+		</method>
+
+		<method name="GetServerInformation">
+			<arg name="name" type="s" direction="out"/>
+			<arg name="vendor" type="s" direction="out"/>
+			<arg name="version" type="s" direction="out"/>
+			<arg name="specVersion" type="s" direction="out"/>
+		</method>
+
+		<signal name="NotificationClosed">
+			<arg name="id" type="u" direction="out"/>
+			<arg name="reason" type="u" direction="out"/>
+		</signal>
+
+		<signal name="ActionInvoked">
+			<arg name="id" type="u" direction="out"/>
+			<arg name="actionKey" type="s" direction="out"/>
+		</signal>
+
+		<signal name="NotificationReplied">
+			<arg name="id" type="u" direction="out"/>
+			<arg name="replyText" type="s" direction="out"/>
+		</signal>
+
+		<signal name="ActivationToken">
+			<arg name="id" type="u" direction="out"/>
+			<arg name="activationToken" type="s" direction="out"/>
+		</signal>
+	</interface>
+</node>
diff --git a/src/services/notifications/qml.cpp b/src/services/notifications/qml.cpp
new file mode 100644
index 00000000..42bb23a0
--- /dev/null
+++ b/src/services/notifications/qml.cpp
@@ -0,0 +1,150 @@
+#include "qml.hpp"
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qlogging.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+#include "../../core/model.hpp"
+#include "notification.hpp"
+#include "server.hpp"
+
+namespace qs::service::notifications {
+
+void NotificationServerQml::onPostReload() {
+	auto* instance = NotificationServer::instance();
+	instance->support = this->support;
+
+	QObject::connect(
+	    instance,
+	    &NotificationServer::notification,
+	    this,
+	    &NotificationServerQml::notification
+	);
+
+	instance->switchGeneration(this->mKeepOnReload, [this]() {
+		this->live = true;
+		emit this->trackedNotificationsChanged();
+	});
+}
+
+bool NotificationServerQml::keepOnReload() const { return this->mKeepOnReload; }
+
+void NotificationServerQml::setKeepOnReload(bool keepOnReload) {
+	if (keepOnReload == this->mKeepOnReload) return;
+
+	if (this->live) {
+		qCritical() << "Cannot set NotificationServer.keepOnReload after the server has been started.";
+		return;
+	}
+
+	this->mKeepOnReload = keepOnReload;
+	emit this->keepOnReloadChanged();
+}
+
+bool NotificationServerQml::persistenceSupported() const { return this->support.persistence; }
+
+void NotificationServerQml::setPersistenceSupported(bool persistenceSupported) {
+	if (persistenceSupported == this->support.persistence) return;
+	this->support.persistence = persistenceSupported;
+	this->updateSupported();
+	emit this->persistenceSupportedChanged();
+}
+
+bool NotificationServerQml::bodySupported() const { return this->support.body; }
+
+void NotificationServerQml::setBodySupported(bool bodySupported) {
+	if (bodySupported == this->support.body) return;
+	this->support.body = bodySupported;
+	this->updateSupported();
+	emit this->bodySupportedChanged();
+}
+
+bool NotificationServerQml::bodyMarkupSupported() const { return this->support.bodyMarkup; }
+
+void NotificationServerQml::setBodyMarkupSupported(bool bodyMarkupSupported) {
+	if (bodyMarkupSupported == this->support.bodyMarkup) return;
+	this->support.bodyMarkup = bodyMarkupSupported;
+	this->updateSupported();
+	emit this->bodyMarkupSupportedChanged();
+}
+
+bool NotificationServerQml::bodyHyperlinksSupported() const { return this->support.bodyHyperlinks; }
+
+void NotificationServerQml::setBodyHyperlinksSupported(bool bodyHyperlinksSupported) {
+	if (bodyHyperlinksSupported == this->support.bodyHyperlinks) return;
+	this->support.bodyHyperlinks = bodyHyperlinksSupported;
+	this->updateSupported();
+	emit this->bodyHyperlinksSupportedChanged();
+}
+
+bool NotificationServerQml::bodyImagesSupported() const { return this->support.bodyImages; }
+
+void NotificationServerQml::setBodyImagesSupported(bool bodyImagesSupported) {
+	if (bodyImagesSupported == this->support.bodyImages) return;
+	this->support.bodyImages = bodyImagesSupported;
+	this->updateSupported();
+	emit this->bodyImagesSupportedChanged();
+}
+
+bool NotificationServerQml::actionsSupported() const { return this->support.actions; }
+
+void NotificationServerQml::setActionsSupported(bool actionsSupported) {
+	if (actionsSupported == this->support.actions) return;
+	this->support.actions = actionsSupported;
+	this->updateSupported();
+	emit this->actionsSupportedChanged();
+}
+
+bool NotificationServerQml::actionIconsSupported() const { return this->support.actionIcons; }
+
+void NotificationServerQml::setActionIconsSupported(bool actionIconsSupported) {
+	if (actionIconsSupported == this->support.actionIcons) return;
+	this->support.actionIcons = actionIconsSupported;
+	this->updateSupported();
+	emit this->actionIconsSupportedChanged();
+}
+
+bool NotificationServerQml::imageSupported() const { return this->support.image; }
+
+void NotificationServerQml::setImageSupported(bool imageSupported) {
+	if (imageSupported == this->support.image) return;
+	this->support.image = imageSupported;
+	this->updateSupported();
+	emit this->imageSupportedChanged();
+}
+
+bool NotificationServerQml::inlineReplySupported() const { return this->support.inlineReply; }
+
+void NotificationServerQml::setInlineReplySupported(bool inlineReplySupported) {
+	if (inlineReplySupported == this->support.inlineReply) return;
+	this->support.inlineReply = inlineReplySupported;
+	this->updateSupported();
+	emit this->inlineReplySupportedChanged();
+}
+
+QVector<QString> NotificationServerQml::extraHints() const { return this->support.extraHints; }
+
+void NotificationServerQml::setExtraHints(QVector<QString> extraHints) {
+	if (extraHints == this->support.extraHints) return;
+	this->support.extraHints = std::move(extraHints);
+	this->updateSupported();
+	emit this->extraHintsChanged();
+}
+
+ObjectModel<Notification>* NotificationServerQml::trackedNotifications() const {
+	if (this->live) {
+		return NotificationServer::instance()->trackedNotifications();
+	} else {
+		return ObjectModel<Notification>::emptyInstance();
+	}
+}
+
+void NotificationServerQml::updateSupported() {
+	if (this->live) {
+		NotificationServer::instance()->support = this->support;
+	}
+}
+
+} // namespace qs::service::notifications
diff --git a/src/services/notifications/qml.hpp b/src/services/notifications/qml.hpp
new file mode 100644
index 00000000..88132c70
--- /dev/null
+++ b/src/services/notifications/qml.hpp
@@ -0,0 +1,143 @@
+#pragma once
+
+#include <QtCore/qtmetamacros.h>
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+
+#include "../../core/doc.hpp"
+#include "../../core/model.hpp"
+#include "../../core/reload.hpp"
+#include "notification.hpp"
+#include "server.hpp"
+
+namespace qs::service::notifications {
+
+///! Desktop Notifications Server.
+/// An implementation of the [Desktop Notifications Specification] for receiving notifications
+/// from external applications.
+///
+/// The server does not advertise most capabilities by default. See the individual properties for details.
+///
+/// [Desktop Notifications Specification]: https://specifications.freedesktop.org/notification-spec/notification-spec-latest.html
+class NotificationServerQml: public PostReloadHook {
+	Q_OBJECT;
+	// clang-format off
+	/// If notifications should be re-emitted when quickshell reloads. Defaults to true.
+	///
+	/// The @@Notification.lastGeneration flag will be
+	/// set on notifications from the prior generation for further filtering/handling.
+	Q_PROPERTY(bool keepOnReload READ keepOnReload WRITE setKeepOnReload NOTIFY keepOnReloadChanged);
+	/// If the notification server should advertise that it can persist notifications in the background
+	/// after going offscreen. Defaults to false.
+	Q_PROPERTY(bool persistenceSupported READ persistenceSupported WRITE setPersistenceSupported NOTIFY persistenceSupportedChanged);
+	/// If notification body text should be advertised as supported by the notification server.
+	/// Defaults to true.
+	///
+	/// Note that returned notifications are likely to return body text even if this property is false,
+	/// as it is only a hint.
+	Q_PROPERTY(bool bodySupported READ bodySupported WRITE setBodySupported NOTIFY bodySupportedChanged);
+	/// If notification body text should be advertised as supporting markup as described in [the specification]
+	/// Defaults to false.
+	///
+	/// Note that returned notifications may still contain markup if this property is false,
+	/// as it is only a hint. By default Text objects will try to render markup. To avoid this
+	/// if any is sent, change @@QtQuick.Text.textFormat to `PlainText`.
+	Q_PROPERTY(bool bodyMarkupSupported READ bodyMarkupSupported WRITE setBodyMarkupSupported NOTIFY bodyMarkupSupportedChanged);
+	/// If notification body text should be advertised as supporting hyperlinks as described in [the specification]
+	/// Defaults to false.
+	///
+	/// Note that returned notifications may still contain hyperlinks if this property is false, as it is only a hint.
+	///
+	/// [the specification]: https://specifications.freedesktop.org/notification-spec/notification-spec-latest.html#hyperlinks
+	Q_PROPERTY(bool bodyHyperlinksSupported READ bodyHyperlinksSupported WRITE setBodyHyperlinksSupported NOTIFY bodyHyperlinksSupportedChanged);
+	/// If notification body text should be advertised as supporting images as described in [the specification]
+	/// Defaults to false.
+	///
+	/// Note that returned notifications may still contain images if this property is false, as it is only a hint.
+	///
+	/// [the specification]: https://specifications.freedesktop.org/notification-spec/notification-spec-latest.html#images
+	Q_PROPERTY(bool bodyImagesSupported READ bodyImagesSupported WRITE setBodyImagesSupported NOTIFY bodyImagesSupportedChanged);
+	/// If notification actions should be advertised as supported by the notification server. Defaults to false.
+	Q_PROPERTY(bool actionsSupported READ actionsSupported WRITE setActionsSupported NOTIFY actionsSupportedChanged);
+	/// If notification actions should be advertised as supporting the display of icons. Defaults to false.
+	Q_PROPERTY(bool actionIconsSupported READ actionIconsSupported WRITE setActionIconsSupported NOTIFY actionIconsSupportedChanged);
+	/// If the notification server should advertise that it supports images. Defaults to false.
+	Q_PROPERTY(bool imageSupported READ imageSupported WRITE setImageSupported NOTIFY imageSupportedChanged);
+	/// If the notification server should advertise that it supports inline replies. Defaults to false.
+	Q_PROPERTY(bool inlineReplySupported READ inlineReplySupported WRITE setInlineReplySupported NOTIFY inlineReplySupportedChanged);
+	/// All notifications currently tracked by the server.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::service::notifications::Notification>*);
+	Q_PROPERTY(UntypedObjectModel* trackedNotifications READ trackedNotifications NOTIFY trackedNotificationsChanged);
+	/// Extra hints to expose to notification clients.
+	Q_PROPERTY(QVector<QString> extraHints READ extraHints WRITE setExtraHints NOTIFY extraHintsChanged);
+	// clang-format on
+	QML_NAMED_ELEMENT(NotificationServer);
+
+public:
+	void onPostReload() override;
+
+	[[nodiscard]] bool keepOnReload() const;
+	void setKeepOnReload(bool keepOnReload);
+
+	[[nodiscard]] bool persistenceSupported() const;
+	void setPersistenceSupported(bool persistenceSupported);
+
+	[[nodiscard]] bool bodySupported() const;
+	void setBodySupported(bool bodySupported);
+
+	[[nodiscard]] bool bodyMarkupSupported() const;
+	void setBodyMarkupSupported(bool bodyMarkupSupported);
+
+	[[nodiscard]] bool bodyHyperlinksSupported() const;
+	void setBodyHyperlinksSupported(bool bodyHyperlinksSupported);
+
+	[[nodiscard]] bool bodyImagesSupported() const;
+	void setBodyImagesSupported(bool bodyImagesSupported);
+
+	[[nodiscard]] bool actionsSupported() const;
+	void setActionsSupported(bool actionsSupported);
+
+	[[nodiscard]] bool actionIconsSupported() const;
+	void setActionIconsSupported(bool actionIconsSupported);
+
+	[[nodiscard]] bool imageSupported() const;
+	void setImageSupported(bool imageSupported);
+
+	[[nodiscard]] bool inlineReplySupported() const;
+	void setInlineReplySupported(bool inlineReplySupported);
+
+	[[nodiscard]] QVector<QString> extraHints() const;
+	void setExtraHints(QVector<QString> extraHints);
+
+	[[nodiscard]] ObjectModel<Notification>* trackedNotifications() const;
+
+signals:
+	/// Sent when a notification is received by the server.
+	///
+	/// If this notification should not be discarded, set its `tracked` property to true.
+	void notification(qs::service::notifications::Notification* notification);
+
+	void keepOnReloadChanged();
+	void persistenceSupportedChanged();
+	void bodySupportedChanged();
+	void bodyMarkupSupportedChanged();
+	void bodyHyperlinksSupportedChanged();
+	void bodyImagesSupportedChanged();
+	void actionsSupportedChanged();
+	void actionIconsSupportedChanged();
+	void imageSupportedChanged();
+	void inlineReplySupportedChanged();
+	void extraHintsChanged();
+	void trackedNotificationsChanged();
+
+private:
+	void updateSupported();
+
+	bool live = false;
+	bool mKeepOnReload = true;
+	NotificationServerSupport support;
+};
+
+} // namespace qs::service::notifications
diff --git a/src/services/notifications/server.cpp b/src/services/notifications/server.cpp
new file mode 100644
index 00000000..3f2469d2
--- /dev/null
+++ b/src/services/notifications/server.cpp
@@ -0,0 +1,208 @@
+#include "server.hpp"
+#include <functional>
+
+#include <qcontainerfwd.h>
+#include <qcoreapplication.h>
+#include <qdbusconnection.h>
+#include <qdbusmetatype.h>
+#include <qdbusservicewatcher.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qqmlengine.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/logcat.hpp"
+#include "../../core/model.hpp"
+#include "dbus_notifications.h"
+#include "dbusimage.hpp"
+#include "notification.hpp"
+
+namespace qs::service::notifications {
+
+// NOLINTNEXTLINE(misc-use-internal-linkage)
+QS_LOGGING_CATEGORY(logNotifications, "quickshell.service.notifications", QtWarningMsg);
+
+NotificationServer::NotificationServer() {
+	qDBusRegisterMetaType<DBusNotificationImage>();
+
+	new DBusNotificationServer(this);
+
+	qCInfo(logNotifications) << "Starting notification server";
+
+	auto bus = QDBusConnection::sessionBus();
+
+	if (!bus.isConnected()) {
+		qCWarning(logNotifications) << "Could not connect to DBus. Notification service will not work.";
+		return;
+	}
+
+	if (!bus.registerObject("/org/freedesktop/Notifications", this)) {
+		qCWarning(logNotifications) << "Could not register Notification server object with DBus. "
+		                               "Notification server will not work.";
+		return;
+	}
+
+	QObject::connect(
+	    &this->serviceWatcher,
+	    &QDBusServiceWatcher::serviceUnregistered,
+	    this,
+	    &NotificationServer::onServiceUnregistered
+	);
+
+	this->serviceWatcher.setWatchMode(QDBusServiceWatcher::WatchForUnregistration);
+	this->serviceWatcher.addWatchedService("org.freedesktop.Notifications");
+	this->serviceWatcher.setConnection(bus);
+
+	NotificationServer::tryRegister();
+}
+
+NotificationServer* NotificationServer::instance() {
+	static auto* instance = new NotificationServer(); // NOLINT
+	return instance;
+}
+
+void NotificationServer::switchGeneration(bool reEmit, const std::function<void()>& clearHook) {
+	auto notifications = this->mNotifications.valueList();
+	this->mNotifications.valueList().clear();
+	this->idMap.clear();
+
+	clearHook();
+
+	if (reEmit) {
+		for (auto* notification: notifications) {
+			notification->setLastGeneration();
+			notification->setTracked(false);
+			emit this->notification(notification);
+
+			if (!notification->isTracked()) {
+				emit this->NotificationClosed(notification->id(), notification->closeReason());
+				delete notification;
+			} else {
+				this->idMap.insert(notification->id(), notification);
+				this->mNotifications.insertObject(notification);
+			}
+		}
+	} else {
+		for (auto* notification: notifications) {
+			emit this->NotificationClosed(notification->id(), NotificationCloseReason::Expired);
+			delete notification;
+		}
+	}
+}
+
+ObjectModel<Notification>* NotificationServer::trackedNotifications() {
+	return &this->mNotifications;
+}
+
+void NotificationServer::deleteNotification(
+    Notification* notification,
+    NotificationCloseReason::Enum reason
+) {
+	if (!this->idMap.contains(notification->id())) return;
+
+	emit notification->closed(reason);
+
+	this->mNotifications.removeObject(notification);
+	this->idMap.remove(notification->id());
+
+	emit this->NotificationClosed(notification->id(), reason);
+	notification->retainedDestroy();
+}
+
+void NotificationServer::tryRegister() {
+	auto bus = QDBusConnection::sessionBus();
+	auto success = bus.registerService("org.freedesktop.Notifications");
+
+	if (success) {
+		qCInfo(logNotifications) << "Registered notification server with dbus.";
+	} else {
+		qCWarning(logNotifications
+		) << "Could not register notification server at org.freedesktop.Notifications, presumably "
+		     "because one is already registered.";
+		qCWarning(logNotifications
+		) << "Registration will be attempted again if the active service is unregistered.";
+	}
+}
+void NotificationServer::onServiceUnregistered(const QString& /*unused*/) {
+	qCDebug(logNotifications) << "Active notification server unregistered, attempting registration";
+	NotificationServer::tryRegister();
+}
+
+void NotificationServer::CloseNotification(uint id) {
+	auto* notification = this->idMap.value(id);
+
+	if (notification) {
+		this->deleteNotification(notification, NotificationCloseReason::CloseRequested);
+	}
+}
+
+QStringList NotificationServer::GetCapabilities() const {
+	auto capabilities = QStringList();
+
+	if (this->support.persistence) capabilities += "persistence";
+
+	if (this->support.body) {
+		capabilities += "body";
+		if (this->support.bodyMarkup) capabilities += "body-markup";
+		if (this->support.bodyHyperlinks) capabilities += "body-hyperlinks";
+		if (this->support.bodyImages) capabilities += "body-images";
+	}
+
+	if (this->support.actions) {
+		capabilities += "actions";
+		if (this->support.actionIcons) capabilities += "action-icons";
+	}
+
+	if (this->support.image) capabilities += "icon-static";
+	if (this->support.inlineReply) capabilities += "inline-reply";
+
+	capabilities += this->support.extraHints;
+
+	return capabilities;
+}
+
+QString
+NotificationServer::GetServerInformation(QString& vendor, QString& version, QString& specVersion) {
+	vendor = "quickshell";
+	version = QCoreApplication::applicationVersion();
+	specVersion = "1.2";
+	return "quickshell";
+}
+
+uint NotificationServer::Notify(
+    const QString& appName,
+    uint replacesId,
+    const QString& appIcon,
+    const QString& summary,
+    const QString& body,
+    const QStringList& actions,
+    const QVariantMap& hints,
+    int expireTimeout
+) {
+	auto* notification = replacesId == 0 ? nullptr : this->idMap.value(replacesId);
+	auto old = notification != nullptr;
+
+	if (!notification) {
+		notification = new Notification(this->nextId++, this);
+		QQmlEngine::setObjectOwnership(notification, QQmlEngine::CppOwnership);
+	}
+
+	notification->updateProperties(appName, appIcon, summary, body, actions, hints, expireTimeout);
+
+	if (!old) {
+		emit this->notification(notification);
+
+		if (!notification->isTracked()) {
+			emit this->NotificationClosed(notification->id(), notification->closeReason());
+			delete notification;
+		} else {
+			this->idMap.insert(notification->id(), notification);
+			this->mNotifications.insertObject(notification);
+		}
+	}
+
+	return notification->id();
+}
+
+} // namespace qs::service::notifications
diff --git a/src/services/notifications/server.hpp b/src/services/notifications/server.hpp
new file mode 100644
index 00000000..8bd92a34
--- /dev/null
+++ b/src/services/notifications/server.hpp
@@ -0,0 +1,81 @@
+#pragma once
+
+#include <functional>
+
+#include <qcontainerfwd.h>
+#include <qdbusservicewatcher.h>
+#include <qhash.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/model.hpp"
+#include "notification.hpp"
+
+namespace qs::service::notifications {
+
+struct NotificationServerSupport {
+	bool persistence = false;
+	bool body = true;
+	bool bodyMarkup = false;
+	bool bodyHyperlinks = false;
+	bool bodyImages = false;
+	bool actions = false;
+	bool actionIcons = false;
+	bool image = false;
+	bool inlineReply = false;
+	QVector<QString> extraHints;
+};
+
+class NotificationServer: public QObject {
+	Q_OBJECT;
+
+public:
+	static NotificationServer* instance();
+
+	void switchGeneration(bool reEmit, const std::function<void()>& clearHook);
+	ObjectModel<Notification>* trackedNotifications();
+	void deleteNotification(Notification* notification, NotificationCloseReason::Enum reason);
+
+	// NOLINTBEGIN
+	void CloseNotification(uint id);
+	QStringList GetCapabilities() const;
+	static QString GetServerInformation(QString& vendor, QString& version, QString& specVersion);
+	uint Notify(
+	    const QString& appName,
+	    uint replacesId,
+	    const QString& appIcon,
+	    const QString& summary,
+	    const QString& body,
+	    const QStringList& actions,
+	    const QVariantMap& hints,
+	    int expireTimeout
+	);
+	// NOLINTEND
+
+	NotificationServerSupport support;
+
+signals:
+	void notification(Notification* notification);
+
+	// NOLINTBEGIN
+	void NotificationClosed(quint32 id, quint32 reason);
+	void ActionInvoked(quint32 id, QString action);
+	void NotificationReplied(quint32 id, QString replyText);
+	// NOLINTEND
+
+private slots:
+	static void onServiceUnregistered(const QString& service);
+
+private:
+	explicit NotificationServer();
+
+	static void tryRegister();
+
+	QDBusServiceWatcher serviceWatcher;
+	quint32 nextId = 1;
+	QHash<quint32, Notification*> idMap;
+	ObjectModel<Notification> mNotifications {this};
+};
+
+} // namespace qs::service::notifications
diff --git a/src/services/pam/CMakeLists.txt b/src/services/pam/CMakeLists.txt
new file mode 100644
index 00000000..ec300ee6
--- /dev/null
+++ b/src/services/pam/CMakeLists.txt
@@ -0,0 +1,23 @@
+qt_add_library(quickshell-service-pam STATIC
+	qml.cpp
+	conversation.cpp
+	ipc.cpp
+	subprocess.cpp
+)
+
+qt_add_qml_module(quickshell-service-pam
+	URI Quickshell.Services.Pam
+	VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+install_qml_module(quickshell-service-pam)
+
+target_link_libraries(quickshell-service-pam PRIVATE
+	Qt::Qml pam ${PAM_LIBRARIES}
+	Qt::Quick # pch
+)
+
+qs_module_pch(quickshell-service-pam)
+
+target_link_libraries(quickshell PRIVATE quickshell-service-pamplugin)
diff --git a/src/services/pam/conversation.cpp b/src/services/pam/conversation.cpp
new file mode 100644
index 00000000..6d27978f
--- /dev/null
+++ b/src/services/pam/conversation.cpp
@@ -0,0 +1,129 @@
+#include "conversation.hpp"
+
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qsocketnotifier.h>
+#include <qstring.h>
+#include <qtmetamacros.h>
+#include <sys/wait.h>
+
+#include "../../core/logcat.hpp"
+#include "ipc.hpp"
+
+QS_LOGGING_CATEGORY(logPam, "quickshell.service.pam", QtWarningMsg);
+
+QString PamError::toString(PamError::Enum value) {
+	switch (value) {
+	case StartFailed: return "Failed to start the PAM session";
+	case TryAuthFailed: return "Failed to try authenticating";
+	case InternalError: return "Internal error occurred";
+	default: return "Invalid error";
+	}
+}
+
+QString PamResult::toString(PamResult::Enum value) {
+	switch (value) {
+	case Success: return "Success";
+	case Failed: return "Failed";
+	case Error: return "Error occurred while authenticating";
+	case MaxTries: return "The authentication method has no more attempts available";
+	default: return "Invalid result";
+	}
+}
+
+PamConversation::~PamConversation() { this->abort(); }
+
+void PamConversation::start(const QString& configDir, const QString& config, const QString& user) {
+	this->childPid = PamConversation::createSubprocess(&this->pipes, configDir, config, user);
+	if (this->childPid == 0) {
+		qCCritical(logPam) << "Failed to create pam subprocess.";
+		emit this->error(PamError::InternalError);
+		return;
+	}
+
+	QObject::connect(&this->notifier, &QSocketNotifier::activated, this, &PamConversation::onMessage);
+	this->notifier.setSocket(this->pipes.fdIn);
+	this->notifier.setEnabled(true);
+}
+
+void PamConversation::abort() {
+	if (this->childPid != 0) {
+		qCDebug(logPam) << "Killing subprocess for" << this;
+		kill(this->childPid, SIGKILL); // NOLINT (include)
+		waitpid(this->childPid, nullptr, 0);
+		this->childPid = 0;
+	}
+}
+
+void PamConversation::internalError() {
+	if (this->childPid != 0) {
+		qCDebug(logPam) << "Killing subprocess for" << this;
+		kill(this->childPid, SIGKILL); // NOLINT (include)
+		waitpid(this->childPid, nullptr, 0);
+		this->childPid = 0;
+		emit this->error(PamError::InternalError);
+	}
+}
+
+void PamConversation::respond(const QString& response) {
+	qCDebug(logPam) << "Sending response for" << this;
+	if (!this->pipes.writeString(response.toStdString())) {
+		qCCritical(logPam) << "Failed to write response to subprocess.";
+		this->internalError();
+	}
+}
+
+void PamConversation::onMessage() {
+	{
+		qCDebug(logPam) << "Got message from subprocess.";
+
+		auto type = PamIpcEvent::Exit;
+
+		auto ok = this->pipes.readBytes(reinterpret_cast<char*>(&type), sizeof(PamIpcEvent));
+
+		if (!ok) goto fail;
+
+		if (type == PamIpcEvent::Exit) {
+			auto code = PamIpcExitCode::OtherError;
+
+			ok = this->pipes.readBytes(reinterpret_cast<char*>(&code), sizeof(PamIpcExitCode));
+
+			if (!ok) goto fail;
+
+			qCDebug(logPam) << "Subprocess exited with code" << static_cast<int>(code);
+
+			switch (code) {
+			case PamIpcExitCode::Success: emit this->completed(PamResult::Success); break;
+			case PamIpcExitCode::AuthFailed: emit this->completed(PamResult::Failed); break;
+			case PamIpcExitCode::StartFailed: emit this->error(PamError::StartFailed); break;
+			case PamIpcExitCode::MaxTries: emit this->completed(PamResult::MaxTries); break;
+			case PamIpcExitCode::PamError: emit this->error(PamError::TryAuthFailed); break;
+			case PamIpcExitCode::OtherError: emit this->error(PamError::InternalError); break;
+			}
+
+			waitpid(this->childPid, nullptr, 0);
+			this->childPid = 0;
+		} else if (type == PamIpcEvent::Request) {
+			PamIpcRequestFlags flags {};
+
+			ok = this->pipes.readBytes(reinterpret_cast<char*>(&flags), sizeof(PamIpcRequestFlags));
+
+			if (!ok) goto fail;
+
+			auto message = this->pipes.readString(&ok);
+
+			if (!ok) goto fail;
+
+			this->message(QString::fromUtf8(message), flags.error, flags.responseRequired, flags.echo);
+		} else {
+			qCCritical(logPam) << "Unexpected message from subprocess.";
+			goto fail;
+		}
+	}
+	return;
+
+fail:
+	qCCritical(logPam) << "Failed to read subprocess request.";
+	this->internalError();
+}
diff --git a/src/services/pam/conversation.hpp b/src/services/pam/conversation.hpp
new file mode 100644
index 00000000..779e6f47
--- /dev/null
+++ b/src/services/pam/conversation.hpp
@@ -0,0 +1,100 @@
+#pragma once
+
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qsocketnotifier.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/logcat.hpp"
+#include "ipc.hpp"
+
+QS_DECLARE_LOGGING_CATEGORY(logPam);
+
+///! The result of an authentication.
+/// See @@PamContext.completed(s).
+class PamResult: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		/// Authentication was successful.
+		Success = 0,
+		/// Authentication failed.
+		Failed = 1,
+		/// An error occurred while trying to authenticate.
+		Error = 2,
+		/// The authentication method ran out of tries and should not be used again.
+		MaxTries = 3,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(PamResult::Enum value);
+};
+
+///! An error that occurred during an authentication.
+/// See @@PamContext.error(s).
+class PamError: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		/// Failed to start the pam session.
+		StartFailed = 1,
+		/// Failed to try to authenticate the user.
+		/// This is not the same as the user failing to authenticate.
+		TryAuthFailed = 2,
+		/// An error occurred inside quickshell's pam interface.
+		InternalError = 3,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(PamError::Enum value);
+};
+
+// PAM has no way to abort a running module except when it sends a message,
+// meaning aborts for things like fingerprint scanners
+// and hardware keys don't actually work without aborting the process...
+// so we have a subprocess.
+class PamConversation: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit PamConversation(QObject* parent): QObject(parent) {}
+	~PamConversation() override;
+	Q_DISABLE_COPY_MOVE(PamConversation);
+
+public:
+	void start(const QString& configDir, const QString& config, const QString& user);
+
+	void abort();
+	void respond(const QString& response);
+
+signals:
+	void completed(PamResult::Enum result);
+	void error(PamError::Enum error);
+	void message(QString message, bool messageChanged, bool isError, bool responseRequired);
+
+private slots:
+	void onMessage();
+
+private:
+	static pid_t createSubprocess(
+	    PamIpcPipes* pipes,
+	    const QString& configDir,
+	    const QString& config,
+	    const QString& user
+	);
+
+	void internalError();
+
+	pid_t childPid = 0;
+	PamIpcPipes pipes;
+	QSocketNotifier notifier {QSocketNotifier::Read};
+};
diff --git a/src/services/pam/ipc.cpp b/src/services/pam/ipc.cpp
new file mode 100644
index 00000000..0ac4d580
--- /dev/null
+++ b/src/services/pam/ipc.cpp
@@ -0,0 +1,69 @@
+#include "ipc.hpp"
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+#include <unistd.h>
+
+PamIpcPipes::~PamIpcPipes() {
+	if (this->fdIn != 0) close(this->fdIn);
+	if (this->fdOut != 0) close(this->fdOut);
+}
+
+bool PamIpcPipes::readBytes(char* buffer, size_t length) const {
+	size_t i = 0;
+
+	while (i < length) {
+		auto count = read(this->fdIn, buffer + i, length - i); // NOLINT
+
+		if (count == -1 || count == 0) {
+			return false;
+		}
+
+		i += count;
+	}
+
+	return true;
+}
+
+bool PamIpcPipes::writeBytes(const char* buffer, size_t length) const {
+	size_t i = 0;
+	while (i < length) {
+		auto count = write(this->fdOut, buffer + i, length - i); // NOLINT
+
+		if (count == -1 || count == 0) {
+			return false;
+		}
+
+		i += count;
+	}
+
+	return true;
+}
+
+std::string PamIpcPipes::readString(bool* ok) const {
+	if (ok != nullptr) *ok = false;
+
+	uint32_t length = 0;
+	if (!this->readBytes(reinterpret_cast<char*>(&length), sizeof(length))) {
+		return "";
+	}
+
+	char data[length]; // NOLINT
+	if (!this->readBytes(data, length)) {
+		return "";
+	}
+
+	if (ok != nullptr) *ok = true;
+
+	return std::string(data, length);
+}
+
+bool PamIpcPipes::writeString(const std::string& string) const {
+	uint32_t length = string.length();
+	if (!this->writeBytes(reinterpret_cast<char*>(&length), sizeof(length))) {
+		return false;
+	}
+
+	return this->writeBytes(string.data(), string.length());
+}
diff --git a/src/services/pam/ipc.hpp b/src/services/pam/ipc.hpp
new file mode 100644
index 00000000..7bfcc6f3
--- /dev/null
+++ b/src/services/pam/ipc.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+#include <qtclasshelpermacros.h>
+
+enum class PamIpcEvent : uint8_t {
+	Request,
+	Exit,
+};
+
+enum class PamIpcExitCode : uint8_t {
+	Success,
+	StartFailed,
+	AuthFailed,
+	MaxTries,
+	PamError,
+	OtherError,
+};
+
+struct PamIpcRequestFlags {
+	bool echo;
+	bool error;
+	bool responseRequired;
+};
+
+class PamIpcPipes {
+public:
+	explicit PamIpcPipes() = default;
+	explicit PamIpcPipes(int fdIn, int fdOut): fdIn(fdIn), fdOut(fdOut) {}
+	~PamIpcPipes();
+	Q_DISABLE_COPY_MOVE(PamIpcPipes);
+
+	[[nodiscard]] bool readBytes(char* buffer, size_t length) const;
+	[[nodiscard]] bool writeBytes(const char* buffer, size_t length) const;
+	[[nodiscard]] std::string readString(bool* ok) const;
+	[[nodiscard]] bool writeString(const std::string& string) const;
+
+	int fdIn = 0;
+	int fdOut = 0;
+};
diff --git a/src/services/pam/module.md b/src/services/pam/module.md
new file mode 100644
index 00000000..2f99400f
--- /dev/null
+++ b/src/services/pam/module.md
@@ -0,0 +1,67 @@
+name = "Quickshell.Services.Pam"
+description = "Pam authentication"
+headers = [
+	"qml.hpp",
+	"conversation.hpp",
+]
+-----
+
+## Writing pam configurations
+
+It is a good idea to write pam configurations specifically for quickshell
+if you want to do anything other than match the default login flow.
+
+A good example of this is having a configuration that allows entering a password
+or fingerprint in any order.
+
+### Structure of a pam configuration.
+Pam configuration files are a list of rules, each on a new line in the following form:
+```
+<type> <control_flag> <module_path> [options]
+```
+
+Each line runs in order.
+
+PamContext currently only works with the `auth` type, as other types require root
+access to check.
+
+#### Control flags
+The control flags you're likely to use are `required` and `sufficient`.
+- `required` rules must pass for authentication to succeed.
+- `sufficient` rules will bypass any remaining rules and return on success.
+
+Note that you should have at least one required rule or pam will fail with an undocumented error.
+
+#### Modules
+Pam works with a set of modules that handle various authentication mechanisms.
+Some common ones include `pam_unix.so` which handles passwords and `pam_fprintd.so`
+which handles fingerprints.
+
+These modules have options but none are required for basic functionality.
+
+### Examples
+
+Authenticate with only a password:
+```
+auth required pam_unix.so
+```
+
+Authenticate with only a fingerprint:
+```
+auth required pam_fprintd.so
+```
+
+Try to authenticate with a fingerprint first, but if that fails fall back to a password:
+```
+auth sufficient pam_fprintd.so
+auth required pam_unix.so
+```
+
+Require both a fingerprint and a password:
+```
+auth required pam_fprintd.so
+auth required pam_unix.so
+```
+
+
+See also: [Oracle: PAM configuration file](https://docs.oracle.com/cd/E19683-01/816-4883/pam-32/index.html)
diff --git a/src/services/pam/qml.cpp b/src/services/pam/qml.cpp
new file mode 100644
index 00000000..01a02953
--- /dev/null
+++ b/src/services/pam/qml.cpp
@@ -0,0 +1,236 @@
+#include "qml.hpp"
+#include <utility>
+
+#include <pwd.h>
+#include <qdir.h>
+#include <qfileinfo.h>
+#include <qlogging.h>
+#include <qobject.h>
+#include <qqmlcontext.h>
+#include <qqmlengine.h>
+#include <qtmetamacros.h>
+#include <unistd.h>
+
+#include "conversation.hpp"
+
+void PamContext::componentComplete() {
+	this->postInit = true;
+
+	if (this->mTargetActive) {
+		this->startConversation();
+	}
+}
+
+void PamContext::startConversation() {
+	if (!this->postInit || this->conversation != nullptr) return;
+
+	QString user;
+
+	{
+		auto configDirInfo = QFileInfo(this->mConfigDirectory);
+		if (!configDirInfo.isDir()) {
+			qCritical() << "Cannot start" << this << "because specified config directory"
+			            << this->mConfigDirectory << "is not a directory.";
+			this->mTargetActive = false;
+			return;
+		}
+
+		auto configFilePath = QDir(this->mConfigDirectory).filePath(this->mConfig);
+		auto configFileInfo = QFileInfo(configFilePath);
+		if (!configFileInfo.isFile()) {
+			qCritical() << "Cannot start" << this << "because specified config file" << configFilePath
+			            << "is not a file.";
+			this->mTargetActive = false;
+			return;
+		}
+
+		auto pwuidbufSize = sysconf(_SC_GETPW_R_SIZE_MAX);
+		if (pwuidbufSize == -1) pwuidbufSize = 8192;
+		char pwuidbuf[pwuidbufSize]; // NOLINT
+
+		passwd pwuid {};
+		passwd* pwuidResult = nullptr;
+
+		if (this->mUser.isEmpty()) {
+			auto r = getpwuid_r(getuid(), &pwuid, pwuidbuf, pwuidbufSize, &pwuidResult);
+			if (pwuidResult == nullptr) {
+				qCritical() << "Cannot start" << this << "due to error in getpwuid_r: " << r;
+				this->mTargetActive = false;
+				return;
+			}
+
+			user = pwuid.pw_name;
+		} else {
+			auto r = getpwnam_r(
+			    this->mUser.toStdString().c_str(),
+			    &pwuid,
+			    pwuidbuf,
+			    pwuidbufSize,
+			    &pwuidResult
+			);
+
+			if (pwuidResult == nullptr) {
+				if (r == 0) {
+					qCritical() << "Cannot start" << this
+					            << "because specified user was not found: " << this->mUser;
+				} else {
+					qCritical() << "Cannot start" << this << "due to error in getpwnam_r: " << r;
+				}
+
+				this->mTargetActive = false;
+				return;
+			}
+
+			user = pwuid.pw_name;
+		}
+	}
+
+	this->conversation = new PamConversation(this);
+	QObject::connect(this->conversation, &PamConversation::completed, this, &PamContext::onCompleted);
+	QObject::connect(this->conversation, &PamConversation::error, this, &PamContext::onError);
+	QObject::connect(this->conversation, &PamConversation::message, this, &PamContext::onMessage);
+	emit this->activeChanged();
+	this->conversation->start(this->mConfigDirectory, this->mConfig, user);
+}
+
+void PamContext::abortConversation() {
+	if (this->conversation == nullptr) return;
+	this->mTargetActive = false;
+
+	QObject::disconnect(this->conversation, nullptr, this, nullptr);
+	this->conversation->deleteLater();
+	this->conversation = nullptr;
+	emit this->activeChanged();
+
+	if (!this->mMessage.isEmpty()) {
+		this->mMessage.clear();
+		emit this->messageChanged();
+	}
+
+	if (this->mMessageIsError) {
+		this->mMessageIsError = false;
+		emit this->messageIsErrorChanged();
+	}
+
+	if (this->mIsResponseRequired) {
+		this->mIsResponseRequired = false;
+		emit this->responseRequiredChanged();
+	}
+}
+
+void PamContext::respond(const QString& response) {
+	if (this->isActive() && this->mIsResponseRequired) {
+		this->conversation->respond(response);
+	} else {
+		qWarning() << "PamContext response was ignored as this context does not require one.";
+	}
+}
+
+bool PamContext::start() {
+	this->setActive(true);
+	return this->isActive();
+}
+
+void PamContext::abort() { this->setActive(false); }
+
+bool PamContext::isActive() const { return this->conversation != nullptr; }
+
+void PamContext::setActive(bool active) {
+	if (active == this->mTargetActive) return;
+	this->mTargetActive = active;
+
+	if (active) this->startConversation();
+	else this->abortConversation();
+}
+
+QString PamContext::config() const { return this->mConfig; }
+
+void PamContext::setConfig(QString config) {
+	if (config == this->mConfig) return;
+
+	if (this->isActive()) {
+		qCritical() << "Cannot set config on PamContext while it is active.";
+		return;
+	}
+
+	this->mConfig = std::move(config);
+	emit this->configChanged();
+}
+
+QString PamContext::configDirectory() const { return this->mConfigDirectory; }
+
+void PamContext::setConfigDirectory(QString configDirectory) {
+	if (configDirectory == this->mConfigDirectory) return;
+
+	if (this->isActive()) {
+		qCritical() << "Cannot set configDirectory on PamContext while it is active.";
+		return;
+	}
+
+	auto* context = QQmlEngine::contextForObject(this);
+	if (context != nullptr) {
+		configDirectory = context->resolvedUrl(configDirectory).path();
+	}
+
+	this->mConfigDirectory = std::move(configDirectory);
+	emit this->configDirectoryChanged();
+}
+
+QString PamContext::user() const { return this->mUser; }
+
+void PamContext::setUser(QString user) {
+	if (user == this->mUser) return;
+
+	if (this->isActive()) {
+		qCritical() << "Cannot set user on PamContext while it is active.";
+		return;
+	}
+
+	this->mUser = std::move(user);
+	emit this->userChanged();
+}
+
+QString PamContext::message() const { return this->mMessage; }
+bool PamContext::messageIsError() const { return this->mMessageIsError; }
+bool PamContext::isResponseRequired() const { return this->mIsResponseRequired; }
+bool PamContext::isResponseVisible() const { return this->mIsResponseVisible; }
+
+void PamContext::onCompleted(PamResult::Enum result) {
+	this->abortConversation();
+	emit this->completed(result);
+}
+
+void PamContext::onError(PamError::Enum error) {
+	this->abortConversation();
+	emit this->error(error);
+	emit this->completed(PamResult::Error);
+}
+
+void PamContext::onMessage(
+    QString message,
+    bool isError,
+    bool responseRequired,
+    bool responseVisible
+) {
+	if (message != this->mMessage) {
+		this->mMessage = std::move(message);
+		emit this->messageChanged();
+	}
+
+	if (isError != this->mMessageIsError) {
+		this->mMessageIsError = isError;
+		emit this->messageIsErrorChanged();
+	}
+
+	if (responseVisible != this->mIsResponseVisible) {
+		this->mIsResponseVisible = responseVisible;
+		emit this->responseVisibleChanged();
+	}
+
+	if (responseRequired != this->mIsResponseRequired) {
+		this->mIsResponseRequired = responseRequired;
+		emit this->responseRequiredChanged();
+	}
+
+	emit this->pamMessage();
+}
diff --git a/src/services/pam/qml.hpp b/src/services/pam/qml.hpp
new file mode 100644
index 00000000..a8ffcc35
--- /dev/null
+++ b/src/services/pam/qml.hpp
@@ -0,0 +1,131 @@
+#pragma once
+
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qqmlparserstatus.h>
+#include <qtclasshelpermacros.h>
+#include <qthread.h>
+#include <qtmetamacros.h>
+#include <security/_pam_types.h>
+#include <security/pam_appl.h>
+
+#include "conversation.hpp"
+
+///! Connection to pam.
+/// Connection to pam. See [the module documentation](../) for pam configuration advice.
+class PamContext
+    : public QObject
+    , public QQmlParserStatus {
+	Q_OBJECT;
+	QML_ELEMENT;
+	Q_INTERFACES(QQmlParserStatus);
+
+	// clang-format off
+	/// If the pam context is actively performing an authentication.
+	///
+	/// Setting this value behaves exactly the same as calling @@start() and @@abort().
+	Q_PROPERTY(bool active READ isActive WRITE setActive NOTIFY activeChanged);
+	/// The pam configuration to use. Defaults to "login".
+	///
+	/// The configuration should name a file inside @@configDirectory.
+	///
+	/// This property may not be set while @@active is true.
+	Q_PROPERTY(QString config READ config WRITE setConfig NOTIFY configChanged);
+	/// The pam configuration directory to use. Defaults to "/etc/pam.d".
+	///
+	/// The configuration directory is resolved relative to the current file if not an absolute path.
+	///
+	/// This property may not be set while @@active is true.
+	Q_PROPERTY(QString configDirectory READ configDirectory WRITE setConfigDirectory NOTIFY configDirectoryChanged);
+	/// The user to authenticate as. If unset the current user will be used.
+	///
+	/// This property may not be set while @@active is true.
+	Q_PROPERTY(QString user READ user WRITE setUser NOTIFY userChanged);
+	/// The last message sent by pam.
+	Q_PROPERTY(QString message READ message NOTIFY messageChanged);
+	/// If the last message should be shown as an error.
+	Q_PROPERTY(bool messageIsError READ messageIsError NOTIFY messageIsErrorChanged);
+	/// If pam currently wants a response.
+	///
+	/// Responses can be returned with the @@respond() function.
+	Q_PROPERTY(bool responseRequired READ isResponseRequired NOTIFY responseRequiredChanged);
+	/// If the user's response should be visible. Only valid when @@responseRequired is true.
+	Q_PROPERTY(bool responseVisible READ isResponseVisible NOTIFY responseVisibleChanged);
+	// clang-format on
+
+public:
+	explicit PamContext(QObject* parent = nullptr): QObject(parent) {}
+
+	void classBegin() override {}
+	void componentComplete() override;
+
+	void startConversation();
+	void abortConversation();
+
+	/// Start an authentication session. Returns if the session was started successfully.
+	Q_INVOKABLE bool start();
+
+	/// Abort a running authentication session.
+	Q_INVOKABLE void abort();
+
+	/// Respond to pam.
+	///
+	/// May not be called unless @@responseRequired is true.
+	Q_INVOKABLE void respond(const QString& response);
+
+	[[nodiscard]] bool isActive() const;
+	void setActive(bool active);
+
+	[[nodiscard]] QString config() const;
+	void setConfig(QString config);
+
+	[[nodiscard]] QString configDirectory() const;
+	void setConfigDirectory(QString configDirectory);
+
+	[[nodiscard]] QString user() const;
+	void setUser(QString user);
+
+	[[nodiscard]] QString message() const;
+	[[nodiscard]] bool messageIsError() const;
+	[[nodiscard]] bool isResponseRequired() const;
+	[[nodiscard]] bool isResponseVisible() const;
+
+signals:
+	/// Emitted whenever authentication completes.
+	void completed(PamResult::Enum result);
+	/// Emitted if pam fails to perform authentication normally.
+	///
+	/// A `completed(PamResult.Error)` will be emitted after this event.
+	void error(PamError::Enum error);
+
+	/// Emitted whenever pam sends a new message, after the change signals for
+	/// `message`, `messageIsError`, and `responseRequired`.
+	void pamMessage();
+
+	void activeChanged();
+	void configChanged();
+	void configDirectoryChanged();
+	void userChanged();
+	void messageChanged();
+	void messageIsErrorChanged();
+	void responseRequiredChanged();
+	void responseVisibleChanged();
+
+private slots:
+	void onCompleted(PamResult::Enum result);
+	void onError(PamError::Enum error);
+	void onMessage(QString message, bool isError, bool responseRequired, bool responseVisible);
+
+private:
+	PamConversation* conversation = nullptr;
+
+	bool postInit = false;
+	bool mTargetActive = false;
+	QString mConfig = "login";
+	QString mConfigDirectory = "/etc/pam.d";
+	QString mUser;
+	QString mMessage;
+	bool mMessageIsError = false;
+	bool mIsResponseRequired = false;
+	bool mIsResponseVisible = false;
+};
diff --git a/src/services/pam/subprocess.cpp b/src/services/pam/subprocess.cpp
new file mode 100644
index 00000000..f99b279d
--- /dev/null
+++ b/src/services/pam/subprocess.cpp
@@ -0,0 +1,198 @@
+#include "subprocess.hpp"
+#include <array>
+#include <ostream>
+#include <string>
+
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qstring.h>
+#include <sched.h>
+#include <security/_pam_types.h>
+#include <security/pam_appl.h>
+#include <unistd.h>
+
+#include "conversation.hpp"
+#include "ipc.hpp"
+
+pid_t PamConversation::createSubprocess(
+    PamIpcPipes* pipes,
+    const QString& configDir,
+    const QString& config,
+    const QString& user
+) {
+	auto toSubprocess = std::array<int, 2>();
+	auto fromSubprocess = std::array<int, 2>();
+
+	if (pipe(toSubprocess.data()) == -1 || pipe(fromSubprocess.data()) == -1) {
+		qCDebug(logPam) << "Failed to create pipes for subprocess.";
+		return 0;
+	}
+
+	auto* configDirF = strdup(configDir.toStdString().c_str()); // NOLINT (include)
+	auto* configF = strdup(config.toStdString().c_str());       // NOLINT (include)
+	auto* userF = strdup(user.toStdString().c_str());           // NOLINT (include)
+	auto log = logPam().isDebugEnabled();
+
+	auto pid = fork();
+
+	if (pid < 0) {
+		qCDebug(logPam) << "Failed to fork for subprocess.";
+	} else if (pid == 0) {
+		close(toSubprocess[1]);   // close w
+		close(fromSubprocess[0]); // close r
+
+		{
+			auto subprocess = PamSubprocess(log, toSubprocess[0], fromSubprocess[1]);
+			auto code = subprocess.exec(configDirF, configF, userF);
+			subprocess.sendCode(code);
+		}
+
+		free(configDirF); // NOLINT
+		free(configF);    // NOLINT
+		free(userF);      // NOLINT
+
+		// do not do cleanup that may affect the parent
+		_exit(0);
+	} else {
+		close(toSubprocess[0]);   // close r
+		close(fromSubprocess[1]); // close w
+
+		pipes->fdIn = fromSubprocess[0];
+		pipes->fdOut = toSubprocess[1];
+
+		free(configDirF); // NOLINT
+		free(configF);    // NOLINT
+		free(userF);      // NOLINT
+
+		return pid;
+	}
+
+	return -1; // should never happen but lint
+}
+
+PamIpcExitCode PamSubprocess::exec(const char* configDir, const char* config, const char* user) {
+	logIf(this->log) << "Waiting for parent confirmation..." << std::endl;
+
+	auto conv = pam_conv {
+	    .conv = &PamSubprocess::conversation,
+	    .appdata_ptr = this,
+	};
+
+	pam_handle_t* handle = nullptr;
+
+	logIf(this->log) << "Starting pam session for user \"" << user << "\" with config \"" << config
+	                 << "\" in dir \"" << configDir << "\"" << std::endl;
+
+	auto result = pam_start_confdir(config, user, &conv, configDir, &handle);
+
+	if (result != PAM_SUCCESS) {
+		logIf(true) << "Unable to start pam conversation with error \"" << pam_strerror(handle, result)
+		            << "\" (code " << result << ")" << std::endl;
+		return PamIpcExitCode::StartFailed;
+	}
+
+	result = pam_authenticate(handle, 0);
+	PamIpcExitCode code = PamIpcExitCode::OtherError;
+
+	switch (result) {
+	case PAM_SUCCESS:
+		logIf(this->log) << "Authenticated successfully." << std::endl;
+		code = PamIpcExitCode::Success;
+		break;
+	case PAM_AUTH_ERR:
+		logIf(this->log) << "Failed to authenticate." << std::endl;
+		code = PamIpcExitCode::AuthFailed;
+		break;
+	case PAM_MAXTRIES:
+		logIf(this->log) << "Failed to authenticate due to hitting max tries." << std::endl;
+		code = PamIpcExitCode::MaxTries;
+		break;
+	default:
+		logIf(true) << "Error while authenticating: \"" << pam_strerror(handle, result) << "\" (code "
+		            << result << ")" << std::endl;
+		code = PamIpcExitCode::PamError;
+		break;
+	}
+
+	result = pam_end(handle, result);
+	if (result != PAM_SUCCESS) {
+		logIf(true) << "Error in pam_end: \"" << pam_strerror(handle, result) << "\" (code " << result
+		            << ")" << std::endl;
+	}
+
+	return code;
+}
+
+void PamSubprocess::sendCode(PamIpcExitCode code) {
+	{
+		auto eventType = PamIpcEvent::Exit;
+		auto ok = this->pipes.writeBytes(reinterpret_cast<char*>(&eventType), sizeof(PamIpcEvent));
+
+		if (!ok) goto fail;
+
+		ok = this->pipes.writeBytes(reinterpret_cast<char*>(&code), sizeof(PamIpcExitCode));
+
+		if (!ok) goto fail;
+
+		return;
+	}
+
+fail:
+	_exit(1);
+}
+
+int PamSubprocess::conversation(
+    int msgCount,
+    const pam_message** msgArray,
+    pam_response** responseArray,
+    void* appdata
+) {
+	auto* delegate = static_cast<PamSubprocess*>(appdata);
+
+	// freed by libc so must be alloc'd by it.
+	auto* responses = static_cast<pam_response*>(calloc(msgCount, sizeof(pam_response))); // NOLINT
+
+	for (auto i = 0; i < msgCount; i++) {
+		const auto* message = msgArray[i]; // NOLINT
+		auto& response = responses[i];     // NOLINT
+
+		auto msgString = std::string(message->msg);
+		auto req = PamIpcRequestFlags {
+		    .echo = message->msg_style != PAM_PROMPT_ECHO_OFF,
+		    .error = message->msg_style == PAM_ERROR_MSG,
+		    .responseRequired =
+		        message->msg_style == PAM_PROMPT_ECHO_OFF || message->msg_style == PAM_PROMPT_ECHO_ON,
+		};
+
+		logIf(delegate->log) << "Relaying pam message: \"" << msgString << "\" echo: " << req.echo
+		                     << " error: " << req.error << " responseRequired: " << req.responseRequired
+		                     << std::endl;
+
+		auto eventType = PamIpcEvent::Request;
+		auto ok = delegate->pipes.writeBytes(reinterpret_cast<char*>(&eventType), sizeof(PamIpcEvent));
+
+		if (!ok) goto fail;
+
+		ok =
+		    delegate->pipes.writeBytes(reinterpret_cast<const char*>(&req), sizeof(PamIpcRequestFlags));
+
+		if (!ok) goto fail;
+		if (!delegate->pipes.writeString(msgString)) goto fail;
+
+		if (req.responseRequired) {
+			auto ok = false;
+			auto resp = delegate->pipes.readString(&ok);
+			if (!ok) _exit(static_cast<int>(PamIpcExitCode::OtherError));
+			logIf(delegate->log) << "Got response for request.";
+
+			response.resp = strdup(resp.c_str()); // NOLINT (include)
+		}
+	}
+
+	*responseArray = responses;
+	return PAM_SUCCESS;
+
+fail:
+	free(responseArray); // NOLINT
+	_exit(1);
+}
diff --git a/src/services/pam/subprocess.hpp b/src/services/pam/subprocess.hpp
new file mode 100644
index 00000000..2d289c96
--- /dev/null
+++ b/src/services/pam/subprocess.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <iostream> // NOLINT std::cout
+
+#include <security/pam_appl.h>
+
+#include "ipc.hpp"
+
+// endls are intentional as it makes debugging much easier when the buffer actually flushes.
+// NOLINTBEGIN
+#define logIf(log)                                                                                 \
+	if (log) std::cout << "quickshell.service.pam.subprocess: "
+// NOLINTEND
+
+class PamSubprocess {
+public:
+	explicit PamSubprocess(bool log, int fdIn, int fdOut): log(log), pipes(fdIn, fdOut) {}
+	PamIpcExitCode exec(const char* configDir, const char* config, const char* user);
+	void sendCode(PamIpcExitCode code);
+
+private:
+	static int conversation(
+	    int msgCount,
+	    const pam_message** msgArray,
+	    pam_response** responseArray,
+	    void* appdata
+	);
+
+	bool log;
+	PamIpcPipes pipes;
+};
diff --git a/src/services/pipewire/CMakeLists.txt b/src/services/pipewire/CMakeLists.txt
new file mode 100644
index 00000000..fddca6f5
--- /dev/null
+++ b/src/services/pipewire/CMakeLists.txt
@@ -0,0 +1,33 @@
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(pipewire REQUIRED IMPORTED_TARGET libpipewire-0.3)
+
+qt_add_library(quickshell-service-pipewire STATIC
+	qml.cpp
+	core.cpp
+	connection.cpp
+	registry.cpp
+	node.cpp
+	metadata.cpp
+	link.cpp
+	device.cpp
+	defaults.cpp
+)
+
+qt_add_qml_module(quickshell-service-pipewire
+	URI Quickshell.Services.Pipewire
+	VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+qs_add_module_deps_light(quickshell-service-pipewire Quickshell)
+
+install_qml_module(quickshell-service-pipewire)
+
+target_link_libraries(quickshell-service-pipewire PRIVATE
+	Qt::Qml PkgConfig::pipewire
+	Qt::Quick # pch
+)
+
+qs_module_pch(quickshell-service-pipewire)
+
+target_link_libraries(quickshell PRIVATE quickshell-service-pipewireplugin)
diff --git a/src/services/pipewire/connection.cpp b/src/services/pipewire/connection.cpp
new file mode 100644
index 00000000..ac4c5e6a
--- /dev/null
+++ b/src/services/pipewire/connection.cpp
@@ -0,0 +1,23 @@
+#include "connection.hpp"
+
+#include <qobject.h>
+
+namespace qs::service::pipewire {
+
+PwConnection::PwConnection(QObject* parent): QObject(parent) {
+	if (this->core.isValid()) {
+		this->registry.init(this->core);
+	}
+}
+
+PwConnection* PwConnection::instance() {
+	static PwConnection* instance = nullptr; // NOLINT
+
+	if (instance == nullptr) {
+		instance = new PwConnection();
+	}
+
+	return instance;
+}
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/connection.hpp b/src/services/pipewire/connection.hpp
new file mode 100644
index 00000000..2b3e860e
--- /dev/null
+++ b/src/services/pipewire/connection.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "core.hpp"
+#include "defaults.hpp"
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+class PwConnection: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit PwConnection(QObject* parent = nullptr);
+
+	PwRegistry registry;
+	PwDefaultTracker defaults {&this->registry};
+
+	static PwConnection* instance();
+
+private:
+	// init/destroy order is important. do not rearrange.
+	PwCore core;
+};
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/core.cpp b/src/services/pipewire/core.cpp
new file mode 100644
index 00000000..22445aad
--- /dev/null
+++ b/src/services/pipewire/core.cpp
@@ -0,0 +1,119 @@
+#include "core.hpp"
+#include <cerrno>
+
+#include <pipewire/context.h>
+#include <pipewire/core.h>
+#include <pipewire/loop.h>
+#include <pipewire/pipewire.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qsocketnotifier.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <spa/utils/defs.h>
+#include <spa/utils/hook.h>
+
+#include "../../core/logcat.hpp"
+
+namespace qs::service::pipewire {
+
+namespace {
+QS_LOGGING_CATEGORY(logLoop, "quickshell.service.pipewire.loop", QtWarningMsg);
+}
+
+const pw_core_events PwCore::EVENTS = {
+    .version = PW_VERSION_CORE_EVENTS,
+    .info = nullptr,
+    .done = &PwCore::onSync,
+    .ping = nullptr,
+    .error = nullptr,
+    .remove_id = nullptr,
+    .bound_id = nullptr,
+    .add_mem = nullptr,
+    .remove_mem = nullptr,
+    .bound_props = nullptr,
+};
+
+PwCore::PwCore(QObject* parent): QObject(parent), notifier(QSocketNotifier::Read) {
+	qCInfo(logLoop) << "Creating pipewire event loop.";
+	pw_init(nullptr, nullptr);
+
+	this->loop = pw_loop_new(nullptr);
+	if (this->loop == nullptr) {
+		qCCritical(logLoop) << "Failed to create pipewire event loop.";
+		return;
+	}
+
+	this->context = pw_context_new(this->loop, nullptr, 0);
+	if (this->context == nullptr) {
+		qCCritical(logLoop) << "Failed to create pipewire context.";
+		return;
+	}
+
+	qCInfo(logLoop) << "Connecting to pipewire server.";
+	this->core = pw_context_connect(this->context, nullptr, 0);
+	if (this->core == nullptr) {
+		qCCritical(logLoop) << "Failed to connect pipewire context. Errno:" << errno;
+		return;
+	}
+
+	pw_core_add_listener(this->core, &this->listener.hook, &PwCore::EVENTS, this);
+
+	qCInfo(logLoop) << "Linking pipewire event loop.";
+	// Tie the pw event loop into qt.
+	auto fd = pw_loop_get_fd(this->loop);
+	this->notifier.setSocket(fd);
+	QObject::connect(&this->notifier, &QSocketNotifier::activated, this, &PwCore::poll);
+	this->notifier.setEnabled(true);
+}
+
+PwCore::~PwCore() {
+	qCInfo(logLoop) << "Destroying PwCore.";
+
+	if (this->loop != nullptr) {
+		if (this->context != nullptr) {
+			if (this->core != nullptr) {
+				pw_core_disconnect(this->core);
+			}
+
+			pw_context_destroy(this->context);
+		}
+
+		pw_loop_destroy(this->loop);
+	}
+}
+
+bool PwCore::isValid() const {
+	// others must init first
+	return this->core != nullptr;
+}
+
+void PwCore::poll() {
+	qCDebug(logLoop) << "Pipewire event loop received new events, iterating.";
+	// Spin pw event loop.
+	pw_loop_iterate(this->loop, 0);
+	qCDebug(logLoop) << "Done iterating pipewire event loop.";
+	emit this->polled();
+}
+
+qint32 PwCore::sync(quint32 id) const {
+	// Seq param doesn't seem to do anything. Seq is instead the returned value.
+	return pw_core_sync(this->core, id, 0);
+}
+
+void PwCore::onSync(void* data, quint32 id, qint32 seq) {
+	auto* self = static_cast<PwCore*>(data);
+	emit self->synced(id, seq);
+}
+
+SpaHook::SpaHook() { // NOLINT
+	spa_zero(this->hook);
+}
+
+void SpaHook::remove() {
+	spa_hook_remove(&this->hook);
+	spa_zero(this->hook);
+}
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/core.hpp b/src/services/pipewire/core.hpp
new file mode 100644
index 00000000..262e2d31
--- /dev/null
+++ b/src/services/pipewire/core.hpp
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <pipewire/context.h>
+#include <pipewire/core.h>
+#include <pipewire/loop.h>
+#include <pipewire/proxy.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qsocketnotifier.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <spa/utils/hook.h>
+
+namespace qs::service::pipewire {
+
+class SpaHook {
+public:
+	explicit SpaHook();
+
+	void remove();
+	spa_hook hook;
+};
+
+class PwCore: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit PwCore(QObject* parent = nullptr);
+	~PwCore() override;
+	Q_DISABLE_COPY_MOVE(PwCore);
+
+	[[nodiscard]] bool isValid() const;
+	[[nodiscard]] qint32 sync(quint32 id) const;
+
+	pw_loop* loop = nullptr;
+	pw_context* context = nullptr;
+	pw_core* core = nullptr;
+
+signals:
+	void polled();
+	void synced(quint32 id, qint32 seq);
+
+private slots:
+	void poll();
+
+private:
+	static const pw_core_events EVENTS;
+
+	static void onSync(void* data, quint32 id, qint32 seq);
+
+	QSocketNotifier notifier;
+	SpaHook listener;
+};
+
+template <typename T>
+class PwObject {
+public:
+	explicit PwObject(T* object = nullptr): object(object) {}
+	~PwObject() { pw_proxy_destroy(reinterpret_cast<pw_proxy*>(this->object)); }
+
+	Q_DISABLE_COPY_MOVE(PwObject);
+
+	T* object;
+};
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/defaults.cpp b/src/services/pipewire/defaults.cpp
new file mode 100644
index 00000000..b3d8bfc8
--- /dev/null
+++ b/src/services/pipewire/defaults.cpp
@@ -0,0 +1,305 @@
+#include "defaults.hpp"
+#include <array>
+#include <cstring>
+
+#include <qjsondocument.h>
+#include <qjsonobject.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qstringview.h>
+#include <qtmetamacros.h>
+#include <spa/utils/json.h>
+
+#include "../../core/logcat.hpp"
+#include "../../core/util.hpp"
+#include "metadata.hpp"
+#include "node.hpp"
+#include "registry.hpp"
+
+// This and spa_json_init are part of json-core.h, which is missing from older pw versions.
+struct spa_json;
+
+namespace qs::service::pipewire {
+
+namespace {
+QS_LOGGING_CATEGORY(logDefaults, "quickshell.service.pipewire.defaults", QtWarningMsg);
+}
+
+PwDefaultTracker::PwDefaultTracker(PwRegistry* registry): registry(registry) {
+	QObject::connect(registry, &PwRegistry::metadataAdded, this, &PwDefaultTracker::onMetadataAdded);
+	QObject::connect(registry, &PwRegistry::nodeAdded, this, &PwDefaultTracker::onNodeAdded);
+}
+
+void PwDefaultTracker::onMetadataAdded(PwMetadata* metadata) {
+	if (metadata->name() == "default") {
+		qCDebug(logDefaults) << "Got new defaults metadata object" << metadata;
+
+		if (this->defaultsMetadata.object()) {
+			QObject::disconnect(this->defaultsMetadata.object(), nullptr, this, nullptr);
+		}
+
+		QObject::connect(
+		    metadata,
+		    &PwMetadata::propertyChanged,
+		    this,
+		    &PwDefaultTracker::onMetadataProperty
+		);
+
+		this->defaultsMetadata.setObject(metadata);
+	}
+}
+
+void PwDefaultTracker::onMetadataProperty(const char* key, const char* type, const char* value) {
+	void (PwDefaultTracker::*nodeSetter)(PwNode*) = nullptr;
+	void (PwDefaultTracker::*nameSetter)(const QString&) = nullptr;
+
+	qCDebug(logDefaults).nospace() << "Got default metadata update for " << key << ": "
+	                               << QString(value);
+
+	if (key == nullptr) return; // NOLINT(bugprone-branch-clone)
+	else if (strcmp(key, "default.audio.sink") == 0) {
+		nodeSetter = &PwDefaultTracker::setDefaultSink;
+		nameSetter = &PwDefaultTracker::setDefaultSinkName;
+	} else if (strcmp(key, "default.audio.source") == 0) {
+		nodeSetter = &PwDefaultTracker::setDefaultSource;
+		nameSetter = &PwDefaultTracker::setDefaultSourceName;
+	} else if (strcmp(key, "default.configured.audio.sink") == 0) {
+		nodeSetter = &PwDefaultTracker::setDefaultConfiguredSink;
+		nameSetter = &PwDefaultTracker::setDefaultConfiguredSinkName;
+	} else if (strcmp(key, "default.configured.audio.source") == 0) {
+		nodeSetter = &PwDefaultTracker::setDefaultConfiguredSource;
+		nameSetter = &PwDefaultTracker::setDefaultConfiguredSourceName;
+	} else return;
+
+	QString name;
+	if (type != nullptr && value != nullptr && strcmp(type, "Spa:String:JSON") == 0) {
+		auto failed = true;
+		auto iter = std::array<spa_json, 2>();
+		spa_json_init(&iter[0], value, strlen(value)); // NOLINT (misc-include-cleaner)
+
+		if (spa_json_enter_object(&iter[0], &iter[1]) > 0) {
+			auto buf = std::array<char, 1024>();
+
+			if (spa_json_get_string(&iter[1], buf.data(), buf.size()) > 0) {
+				if (strcmp(buf.data(), "name") == 0) {
+					if (spa_json_get_string(&iter[1], buf.data(), buf.size()) > 0) {
+						name = buf.data();
+						failed = false;
+					}
+				}
+			}
+		}
+
+		if (failed) {
+			qCWarning(logDefaults) << "Failed to parse SPA default json:"
+			                       << QString::fromLocal8Bit(value);
+		}
+	}
+
+	(this->*nameSetter)(name);
+	(this->*nodeSetter)(this->registry->findNodeByName(name));
+}
+
+void PwDefaultTracker::onNodeAdded(PwNode* node) {
+	if (node->name.isEmpty()) return;
+
+	if (this->mDefaultSink == nullptr && node->name == this->mDefaultSinkName) {
+		this->setDefaultSink(node);
+	}
+
+	if (this->mDefaultSource == nullptr && node->name == this->mDefaultSourceName) {
+		this->setDefaultSource(node);
+	}
+
+	if (this->mDefaultConfiguredSink == nullptr && node->name == this->mDefaultConfiguredSinkName) {
+		this->setDefaultConfiguredSink(node);
+	}
+
+	if (this->mDefaultConfiguredSource == nullptr && node->name == this->mDefaultConfiguredSourceName)
+	{
+		this->setDefaultConfiguredSource(node);
+	}
+}
+
+void PwDefaultTracker::onNodeDestroyed(QObject* node) {
+	if (node == this->mDefaultSink) {
+		qCInfo(logDefaults) << "Default sink destroyed.";
+		this->mDefaultSink = nullptr;
+		emit this->defaultSinkChanged();
+	}
+
+	if (node == this->mDefaultSource) {
+		qCInfo(logDefaults) << "Default source destroyed.";
+		this->mDefaultSource = nullptr;
+		emit this->defaultSourceChanged();
+	}
+
+	if (node == this->mDefaultConfiguredSink) {
+		qCInfo(logDefaults) << "Default configured sink destroyed.";
+		this->mDefaultConfiguredSink = nullptr;
+		emit this->defaultConfiguredSinkChanged();
+	}
+
+	if (node == this->mDefaultConfiguredSource) {
+		qCInfo(logDefaults) << "Default configured source destroyed.";
+		this->mDefaultConfiguredSource = nullptr;
+		emit this->defaultConfiguredSourceChanged();
+	}
+}
+
+void PwDefaultTracker::changeConfiguredSink(PwNode* node) {
+	if (node != nullptr) {
+		if (!node->type.testFlags(PwNodeType::AudioSink)) {
+			qCCritical(logDefaults) << "Cannot change default sink to a node that is not a sink.";
+			return;
+		}
+
+		this->changeConfiguredSinkName(node->name);
+	} else {
+		this->changeConfiguredSinkName("");
+	}
+}
+
+void PwDefaultTracker::changeConfiguredSinkName(const QString& sink) {
+	if (sink == this->mDefaultConfiguredSinkName) return;
+
+	if (this->setConfiguredDefault("default.configured.audio.sink", sink)) {
+		this->mDefaultConfiguredSinkName = sink;
+		qCInfo(logDefaults) << "Set default configured sink to" << sink;
+	}
+}
+
+void PwDefaultTracker::changeConfiguredSource(PwNode* node) {
+	if (node != nullptr) {
+		if (!node->type.testFlags(PwNodeType::AudioSource)) {
+			qCCritical(logDefaults) << "Cannot change default source to a node that is not a source.";
+			return;
+		}
+
+		this->changeConfiguredSourceName(node->name);
+	} else {
+		this->changeConfiguredSourceName("");
+	}
+}
+
+void PwDefaultTracker::changeConfiguredSourceName(const QString& source) {
+	if (source == this->mDefaultConfiguredSourceName) return;
+
+	if (this->setConfiguredDefault("default.configured.audio.source", source)) {
+		this->mDefaultConfiguredSourceName = source;
+		qCInfo(logDefaults) << "Set default configured source to" << source;
+	}
+}
+
+bool PwDefaultTracker::setConfiguredDefault(const char* key, const QString& value) {
+	auto* meta = this->defaultsMetadata.object();
+
+	if (!meta || !meta->proxy()) {
+		qCCritical(logDefaults) << "Cannot set default node as metadata is not ready.";
+		return false;
+	}
+
+	if (!meta->hasSetPermission()) {
+		qCCritical(logDefaults
+		) << "Cannot set default node as write+execute permissions are missing for"
+		  << meta;
+		return false;
+	}
+
+	if (value.isEmpty()) {
+		meta->setProperty(key, "Spa:String:JSON", nullptr);
+	} else {
+		// Spa json is a superset of json so we can avoid the awful spa json api when serializing.
+		auto json = QJsonDocument({{"name", value}}).toJson(QJsonDocument::Compact);
+
+		meta->setProperty(key, "Spa:String:JSON", json.toStdString().c_str());
+	}
+
+	return true;
+}
+
+void PwDefaultTracker::setDefaultSink(PwNode* node) {
+	if (node == this->mDefaultSink) return;
+	qCInfo(logDefaults) << "Default sink changed to" << node;
+
+	setSimpleObjectHandle<
+	    &PwDefaultTracker::mDefaultSink,
+	    &PwDefaultTracker::onNodeDestroyed,
+	    &PwDefaultTracker::defaultSinkChanged>(this, node);
+}
+
+void PwDefaultTracker::setDefaultSinkName(const QString& name) {
+	if (name == this->mDefaultSinkName) return;
+	qCInfo(logDefaults) << "Default sink name changed to" << name;
+	this->mDefaultSinkName = name;
+	emit this->defaultSinkNameChanged();
+}
+
+void PwDefaultTracker::setDefaultSource(PwNode* node) {
+	if (node == this->mDefaultSource) return;
+	qCInfo(logDefaults) << "Default source changed to" << node;
+
+	setSimpleObjectHandle<
+	    &PwDefaultTracker::mDefaultSource,
+	    &PwDefaultTracker::onNodeDestroyed,
+	    &PwDefaultTracker::defaultSourceChanged>(this, node);
+}
+
+void PwDefaultTracker::setDefaultSourceName(const QString& name) {
+	if (name == this->mDefaultSourceName) return;
+	qCInfo(logDefaults) << "Default source name changed to" << name;
+	this->mDefaultSourceName = name;
+	emit this->defaultSourceNameChanged();
+}
+
+void PwDefaultTracker::setDefaultConfiguredSink(PwNode* node) {
+	if (node == this->mDefaultConfiguredSink) return;
+	qCInfo(logDefaults) << "Default configured sink changed to" << node;
+
+	setSimpleObjectHandle<
+	    &PwDefaultTracker::mDefaultConfiguredSink,
+	    &PwDefaultTracker::onNodeDestroyed,
+	    &PwDefaultTracker::defaultConfiguredSinkChanged>(this, node);
+}
+
+void PwDefaultTracker::setDefaultConfiguredSinkName(const QString& name) {
+	if (name == this->mDefaultConfiguredSinkName) return;
+	qCInfo(logDefaults) << "Default configured sink name changed to" << name;
+	this->mDefaultConfiguredSinkName = name;
+	emit this->defaultConfiguredSinkNameChanged();
+}
+
+void PwDefaultTracker::setDefaultConfiguredSource(PwNode* node) {
+	if (node == this->mDefaultConfiguredSource) return;
+	qCInfo(logDefaults) << "Default configured source changed to" << node;
+
+	setSimpleObjectHandle<
+	    &PwDefaultTracker::mDefaultConfiguredSource,
+	    &PwDefaultTracker::onNodeDestroyed,
+	    &PwDefaultTracker::defaultConfiguredSourceChanged>(this, node);
+}
+
+void PwDefaultTracker::setDefaultConfiguredSourceName(const QString& name) {
+	if (name == this->mDefaultConfiguredSourceName) return;
+	qCInfo(logDefaults) << "Default configured source name changed to" << name;
+	this->mDefaultConfiguredSourceName = name;
+	emit this->defaultConfiguredSourceNameChanged();
+}
+
+PwNode* PwDefaultTracker::defaultSink() const { return this->mDefaultSink; }
+PwNode* PwDefaultTracker::defaultSource() const { return this->mDefaultSource; }
+
+PwNode* PwDefaultTracker::defaultConfiguredSink() const { return this->mDefaultConfiguredSink; }
+
+const QString& PwDefaultTracker::defaultConfiguredSinkName() const {
+	return this->mDefaultConfiguredSinkName;
+}
+
+PwNode* PwDefaultTracker::defaultConfiguredSource() const { return this->mDefaultConfiguredSource; }
+
+const QString& PwDefaultTracker::defaultConfiguredSourceName() const {
+	return this->mDefaultConfiguredSourceName;
+}
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/defaults.hpp b/src/services/pipewire/defaults.hpp
new file mode 100644
index 00000000..f3a8e3f9
--- /dev/null
+++ b/src/services/pipewire/defaults.hpp
@@ -0,0 +1,79 @@
+#pragma once
+
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+class PwDefaultTracker: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit PwDefaultTracker(PwRegistry* registry);
+
+	[[nodiscard]] PwNode* defaultSink() const;
+	[[nodiscard]] PwNode* defaultSource() const;
+
+	[[nodiscard]] PwNode* defaultConfiguredSink() const;
+	[[nodiscard]] const QString& defaultConfiguredSinkName() const;
+	void changeConfiguredSink(PwNode* node);
+	void changeConfiguredSinkName(const QString& sink);
+
+	[[nodiscard]] PwNode* defaultConfiguredSource() const;
+	[[nodiscard]] const QString& defaultConfiguredSourceName() const;
+	void changeConfiguredSource(PwNode* node);
+	void changeConfiguredSourceName(const QString& source);
+
+signals:
+	void defaultSinkChanged();
+	void defaultSinkNameChanged();
+
+	void defaultSourceChanged();
+	void defaultSourceNameChanged();
+
+	void defaultConfiguredSinkChanged();
+	void defaultConfiguredSinkNameChanged();
+
+	void defaultConfiguredSourceChanged();
+	void defaultConfiguredSourceNameChanged();
+
+private slots:
+	void onMetadataAdded(PwMetadata* metadata);
+	void onMetadataProperty(const char* key, const char* type, const char* value);
+	void onNodeAdded(PwNode* node);
+	void onNodeDestroyed(QObject* node);
+
+private:
+	void setDefaultSink(PwNode* node);
+	void setDefaultSinkName(const QString& name);
+
+	void setDefaultSource(PwNode* node);
+	void setDefaultSourceName(const QString& name);
+
+	void setDefaultConfiguredSink(PwNode* node);
+	void setDefaultConfiguredSinkName(const QString& name);
+
+	void setDefaultConfiguredSource(PwNode* node);
+	void setDefaultConfiguredSourceName(const QString& name);
+
+	bool setConfiguredDefault(const char* key, const QString& value);
+
+	PwRegistry* registry;
+	PwBindableRef<PwMetadata> defaultsMetadata;
+
+	PwNode* mDefaultSink = nullptr;
+	QString mDefaultSinkName;
+
+	PwNode* mDefaultSource = nullptr;
+	QString mDefaultSourceName;
+
+	PwNode* mDefaultConfiguredSink = nullptr;
+	QString mDefaultConfiguredSinkName;
+
+	PwNode* mDefaultConfiguredSource = nullptr;
+	QString mDefaultConfiguredSourceName;
+};
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/device.cpp b/src/services/pipewire/device.cpp
new file mode 100644
index 00000000..616e7d02
--- /dev/null
+++ b/src/services/pipewire/device.cpp
@@ -0,0 +1,225 @@
+#include "device.hpp"
+#include <array>
+#include <cstdint>
+#include <functional>
+#include <utility>
+
+#include <pipewire/device.h>
+#include <qcontainerfwd.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <spa/param/param.h>
+#include <spa/param/props.h>
+#include <spa/param/route.h>
+#include <spa/pod/builder.h>
+#include <spa/pod/parser.h>
+#include <spa/pod/pod.h>
+#include <spa/pod/vararg.h>
+#include <spa/utils/type.h>
+
+#include "../../core/logcat.hpp"
+#include "core.hpp"
+#include "node.hpp"
+
+namespace qs::service::pipewire {
+
+namespace {
+QS_LOGGING_CATEGORY(logDevice, "quickshell.service.pipewire.device", QtWarningMsg);
+}
+
+// https://github.com/PipeWire/wireplumber/blob/895c1c7286e8809fad869059179e53ab39c807e9/modules/module-mixer-api.c#L397
+// https://github.com/PipeWire/pipewire/blob/48c2e9516585ccc791335bc7baf4af6952ec54a0/src/modules/module-protocol-pulse/pulse-server.c#L2743-L2743
+
+void PwDevice::bindHooks() {
+	pw_device_add_listener(this->proxy(), &this->listener.hook, &PwDevice::EVENTS, this);
+	QObject::connect(this->registry->core, &PwCore::polled, this, &PwDevice::polled);
+}
+
+void PwDevice::unbindHooks() {
+	QObject::disconnect(this->registry->core, &PwCore::polled, this, &PwDevice::polled);
+	this->listener.remove();
+	this->stagingIndexes.clear();
+	this->routeDeviceIndexes.clear();
+	this->mWaitingForDevice = false;
+}
+
+const pw_device_events PwDevice::EVENTS = {
+    .version = PW_VERSION_DEVICE_EVENTS,
+    .info = &PwDevice::onInfo,
+    .param = &PwDevice::onParam,
+};
+
+void PwDevice::onInfo(void* data, const pw_device_info* info) {
+	auto* self = static_cast<PwDevice*>(data);
+
+	if ((info->change_mask & PW_DEVICE_CHANGE_MASK_PARAMS) == PW_DEVICE_CHANGE_MASK_PARAMS) {
+		for (quint32 i = 0; i != info->n_params; i++) {
+			auto& param = info->params[i]; // NOLINT
+
+			if (param.id == SPA_PARAM_Route) {
+				if ((param.flags & SPA_PARAM_INFO_READWRITE) == SPA_PARAM_INFO_READWRITE) {
+					qCDebug(logDevice) << "Enumerating routes param for" << self;
+					self->stagingIndexes.clear();
+					self->deviceResponded = false;
+					pw_device_enum_params(self->proxy(), 0, param.id, 0, UINT32_MAX, nullptr);
+				} else {
+					qCWarning(logDevice) << "Unable to enumerate route param for" << self
+					                     << "as the param does not have read+write permissions.";
+				}
+
+				break;
+			}
+		}
+	}
+}
+
+void PwDevice::onParam(
+    void* data,
+    qint32 /*seq*/,
+    quint32 id,
+    quint32 /*index*/,
+    quint32 /*next*/,
+    const spa_pod* param
+) {
+	auto* self = static_cast<PwDevice*>(data);
+
+	if (id == SPA_PARAM_Route) {
+		if (!self->deviceResponded) {
+			self->deviceResponded = true;
+
+			if (self->mWaitingForDevice) {
+				self->mWaitingForDevice = false;
+				emit self->deviceReady();
+			}
+		}
+
+		self->addDeviceIndexPairs(param);
+	}
+}
+
+void PwDevice::addDeviceIndexPairs(const spa_pod* param) {
+	auto parser = spa_pod_parser();
+	spa_pod_parser_pod(&parser, param);
+
+	qint32 device = 0;
+	qint32 index = 0;
+
+	spa_pod* props = nullptr;
+
+	// clang-format off
+	quint32 id = SPA_PARAM_Route;
+	spa_pod_parser_get_object(
+			&parser, SPA_TYPE_OBJECT_ParamRoute, &id,
+			SPA_PARAM_ROUTE_device, SPA_POD_Int(&device),
+			SPA_PARAM_ROUTE_index, SPA_POD_Int(&index),
+			SPA_PARAM_ROUTE_props, SPA_POD_PodObject(&props)
+	);
+	// clang-format on
+
+	auto volumeProps = PwVolumeProps::parseSpaPod(props);
+
+	this->stagingIndexes.append(device);
+	// Insert into the main map as well, staging's purpose is to remove old entries.
+	this->routeDeviceIndexes.insert(device, index);
+
+	qCDebug(logDevice).nospace() << "Registered device/index pair for " << this
+	                             << ": [device: " << device << ", index: " << index << ']';
+
+	emit this->routeVolumesChanged(device, volumeProps);
+}
+
+void PwDevice::polled() {
+	// It is far more likely that the list content has not come in yet than it having no entries,
+	// and there isn't a way to check in the case that there *aren't* actually any entries.
+	if (!this->stagingIndexes.isEmpty()) {
+		this->routeDeviceIndexes.removeIf([&](const std::pair<qint32, qint32>& entry) {
+			if (!stagingIndexes.contains(entry.first)) {
+				qCDebug(logDevice).nospace() << "Removed device/index pair [device: " << entry.first
+				                             << ", index: " << entry.second << "] for" << this;
+				return true;
+			}
+
+			return false;
+		});
+	}
+}
+
+bool PwDevice::setVolumes(qint32 routeDevice, const QVector<float>& volumes) {
+	return this->setRouteProps(routeDevice, [this, routeDevice, &volumes](spa_pod_builder* builder) {
+		auto cubedVolumes = QVector<float>();
+		for (auto volume: volumes) {
+			cubedVolumes.push_back(volume * volume * volume);
+		}
+
+		// clang-format off
+		auto* props = spa_pod_builder_add_object(
+				builder, SPA_TYPE_OBJECT_Props, SPA_PARAM_Props,
+				SPA_PROP_channelVolumes, SPA_POD_Array(sizeof(float), SPA_TYPE_Float, cubedVolumes.length(), cubedVolumes.data())
+		);
+		// clang-format on
+
+		qCInfo(logDevice) << "Changing volumes of" << this << "on route device" << routeDevice << "to"
+		                  << volumes;
+		return props;
+	});
+}
+
+bool PwDevice::setMuted(qint32 routeDevice, bool muted) {
+	return this->setRouteProps(routeDevice, [this, routeDevice, muted](spa_pod_builder* builder) {
+		// clang-format off
+		auto* props = spa_pod_builder_add_object(
+				builder, SPA_TYPE_OBJECT_Props, SPA_PARAM_Props,
+				SPA_PROP_mute, SPA_POD_Bool(muted)
+		);
+		// clang-format on
+
+		qCInfo(logDevice) << "Changing muted state of" << this << "on route device" << routeDevice
+		                  << "to" << muted;
+		return props;
+	});
+}
+
+void PwDevice::waitForDevice() { this->mWaitingForDevice = true; }
+bool PwDevice::waitingForDevice() const { return this->mWaitingForDevice; }
+
+bool PwDevice::setRouteProps(
+    qint32 routeDevice,
+    const std::function<void*(spa_pod_builder*)>& propsCallback
+) {
+	if (this->proxy() == nullptr) {
+		qCCritical(logDevice) << "Tried to change device route props for" << this
+		                      << "which is not bound.";
+		return false;
+	}
+
+	if (!this->routeDeviceIndexes.contains(routeDevice)) {
+		qCCritical(logDevice) << "Tried to change device route props for" << this
+		                      << "with untracked route device" << routeDevice;
+		return false;
+	}
+
+	auto routeIndex = this->routeDeviceIndexes.value(routeDevice);
+
+	auto buffer = std::array<quint8, 1024>();
+	auto builder = SPA_POD_BUILDER_INIT(buffer.data(), buffer.size());
+
+	auto* props = propsCallback(&builder);
+
+	// clang-format off
+	auto* route = spa_pod_builder_add_object(
+	    &builder, SPA_TYPE_OBJECT_ParamRoute, SPA_PARAM_Route,
+			SPA_PARAM_ROUTE_device, SPA_POD_Int(routeDevice),
+			SPA_PARAM_ROUTE_index, SPA_POD_Int(routeIndex),
+			SPA_PARAM_ROUTE_props, SPA_POD_PodObject(props),
+			SPA_PARAM_ROUTE_save, SPA_POD_Bool(true)
+	);
+	// clang-format on
+
+	pw_device_set_param(this->proxy(), SPA_PARAM_Route, 0, static_cast<spa_pod*>(route));
+	return true;
+}
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/device.hpp b/src/services/pipewire/device.hpp
new file mode 100644
index 00000000..1a1f705f
--- /dev/null
+++ b/src/services/pipewire/device.hpp
@@ -0,0 +1,60 @@
+#pragma once
+
+#include <functional>
+
+#include <pipewire/core.h>
+#include <pipewire/device.h>
+#include <pipewire/type.h>
+#include <qcontainerfwd.h>
+#include <qhash.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <spa/pod/builder.h>
+
+#include "core.hpp"
+#include "node.hpp"
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+class PwDevice;
+
+class PwDevice: public PwBindable<pw_device, PW_TYPE_INTERFACE_Device, PW_VERSION_DEVICE> {
+	Q_OBJECT;
+
+public:
+	void bindHooks() override;
+	void unbindHooks() override;
+
+	bool setVolumes(qint32 routeDevice, const QVector<float>& volumes);
+	bool setMuted(qint32 routeDevice, bool muted);
+
+	void waitForDevice();
+	[[nodiscard]] bool waitingForDevice() const;
+
+signals:
+	void deviceReady();
+	void routeVolumesChanged(qint32 routeDevice, const PwVolumeProps& volumeProps);
+
+private slots:
+	void polled();
+
+private:
+	static const pw_device_events EVENTS;
+	static void onInfo(void* data, const pw_device_info* info);
+	static void
+	onParam(void* data, qint32 seq, quint32 id, quint32 index, quint32 next, const spa_pod* param);
+
+	QHash<qint32, qint32> routeDeviceIndexes;
+	QList<qint32> stagingIndexes;
+	void addDeviceIndexPairs(const spa_pod* param);
+
+	bool
+	setRouteProps(qint32 routeDevice, const std::function<void*(spa_pod_builder*)>& propsCallback);
+
+	bool mWaitingForDevice = false;
+	bool deviceResponded = false;
+	SpaHook listener;
+};
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/link.cpp b/src/services/pipewire/link.cpp
new file mode 100644
index 00000000..b2549f65
--- /dev/null
+++ b/src/services/pipewire/link.cpp
@@ -0,0 +1,187 @@
+#include "link.hpp"
+#include <cstring>
+
+#include <pipewire/link.h>
+#include <qdebug.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <spa/utils/dict.h>
+
+#include "../../core/logcat.hpp"
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+namespace {
+QS_LOGGING_CATEGORY(logLink, "quickshell.service.pipewire.link", QtWarningMsg);
+}
+
+QString PwLinkState::toString(Enum value) {
+	return QString(pw_link_state_as_string(static_cast<pw_link_state>(value)));
+}
+
+void PwLink::bindHooks() {
+	pw_link_add_listener(this->proxy(), &this->listener.hook, &PwLink::EVENTS, this);
+}
+
+void PwLink::unbindHooks() {
+	this->listener.remove();
+	this->setState(PW_LINK_STATE_UNLINKED);
+}
+
+void PwLink::initProps(const spa_dict* props) {
+	qCDebug(logLink) << "Parsing initial SPA props of link" << this;
+
+	const spa_dict_item* item = nullptr;
+	spa_dict_for_each(item, props) {
+		if (strcmp(item->key, "link.output.node") == 0) {
+			auto str = QString(item->value);
+			auto ok = false;
+			auto value = str.toInt(&ok);
+			if (ok) this->setOutputNode(value);
+			else {
+				qCWarning(logLink) << "Could not parse link.output.node for" << this << ":" << item->value;
+			}
+		} else if (strcmp(item->key, "link.input.node") == 0) {
+			auto str = QString(item->value);
+			auto ok = false;
+			auto value = str.toInt(&ok);
+			if (ok) this->setInputNode(value);
+			else {
+				qCWarning(logLink) << "Could not parse link.input.node for" << this << ":" << item->value;
+			}
+		}
+	}
+}
+
+const pw_link_events PwLink::EVENTS = {
+    .version = PW_VERSION_LINK_EVENTS,
+    .info = &PwLink::onInfo,
+};
+
+void PwLink::onInfo(void* data, const struct pw_link_info* info) {
+	auto* self = static_cast<PwLink*>(data);
+	qCDebug(logLink) << "Got link info update for" << self << "with mask" << info->change_mask;
+	self->setOutputNode(info->output_node_id);
+	self->setInputNode(info->input_node_id);
+
+	if ((info->change_mask & PW_LINK_CHANGE_MASK_STATE) != 0) {
+		self->setState(info->state);
+	}
+}
+
+quint32 PwLink::outputNode() const { return this->mOutputNode; }
+quint32 PwLink::inputNode() const { return this->mInputNode; }
+PwLinkState::Enum PwLink::state() const { return static_cast<PwLinkState::Enum>(this->mState); }
+
+void PwLink::setOutputNode(quint32 outputNode) {
+	if (outputNode == this->mOutputNode) return;
+
+	if (this->mOutputNode != 0) {
+		qCWarning(logLink) << "Got unexpected output node update for" << this << "to" << outputNode;
+	}
+
+	this->mOutputNode = outputNode;
+	qCDebug(logLink) << "Updated output node of" << this;
+}
+
+void PwLink::setInputNode(quint32 inputNode) {
+	if (inputNode == this->mInputNode) return;
+
+	if (this->mInputNode != 0) {
+		qCWarning(logLink) << "Got unexpected input node update for" << this << "to" << inputNode;
+	}
+
+	this->mInputNode = inputNode;
+	qCDebug(logLink) << "Updated input node of" << this;
+}
+
+void PwLink::setState(pw_link_state state) {
+	if (state == this->mState) return;
+
+	this->mState = state;
+	qCDebug(logLink) << "Updated state of" << this;
+	emit this->stateChanged();
+}
+
+QDebug operator<<(QDebug debug, const PwLink* link) {
+	if (link == nullptr) {
+		debug << "PwLink(0x0)";
+	} else {
+		auto saver = QDebugStateSaver(debug);
+		debug.nospace() << "PwLink(" << link->outputNode() << " -> " << link->inputNode() << ", "
+		                << static_cast<const void*>(link) << ", id=";
+		link->debugId(debug);
+		debug << ", state=" << link->state() << ')';
+	}
+
+	return debug;
+}
+
+PwLinkGroup::PwLinkGroup(PwLink* firstLink, QObject* parent)
+    : QObject(parent)
+    , mOutputNode(firstLink->outputNode())
+    , mInputNode(firstLink->inputNode()) {
+	this->tryAddLink(firstLink);
+}
+
+void PwLinkGroup::ref() {
+	this->refcount++;
+
+	if (this->refcount == 1) {
+		this->trackedLink = *this->links.begin();
+		this->trackedLink->ref();
+		QObject::connect(this->trackedLink, &PwLink::stateChanged, this, &PwLinkGroup::stateChanged);
+		emit this->stateChanged();
+	}
+}
+
+void PwLinkGroup::unref() {
+	if (this->refcount == 0) return;
+	this->refcount--;
+
+	if (this->refcount == 0) {
+		this->trackedLink->unref();
+		this->trackedLink = nullptr;
+		emit this->stateChanged();
+	}
+}
+
+quint32 PwLinkGroup::outputNode() const { return this->mOutputNode; }
+
+quint32 PwLinkGroup::inputNode() const { return this->mInputNode; }
+
+PwLinkState::Enum PwLinkGroup::state() const {
+	if (this->trackedLink == nullptr) {
+		return PwLinkState::Unlinked;
+	} else {
+		return this->trackedLink->state();
+	}
+}
+
+bool PwLinkGroup::tryAddLink(PwLink* link) {
+	if (link->outputNode() != this->mOutputNode || link->inputNode() != this->mInputNode)
+		return false;
+
+	this->links.insert(link->id, link);
+	QObject::connect(link, &PwBindableObject::destroying, this, &PwLinkGroup::onLinkRemoved);
+	return true;
+}
+
+void PwLinkGroup::onLinkRemoved(QObject* object) {
+	auto* link = static_cast<PwLink*>(object); // NOLINT
+	this->links.remove(link->id);
+
+	if (this->links.empty()) {
+		delete this;
+	} else if (link == this->trackedLink) {
+		this->trackedLink = *this->links.begin();
+		QObject::connect(this->trackedLink, &PwLink::stateChanged, this, &PwLinkGroup::stateChanged);
+		emit this->stateChanged();
+	}
+}
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/link.hpp b/src/services/pipewire/link.hpp
new file mode 100644
index 00000000..d87c7c5d
--- /dev/null
+++ b/src/services/pipewire/link.hpp
@@ -0,0 +1,100 @@
+#pragma once
+
+#include <pipewire/link.h>
+#include <pipewire/type.h>
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+///! State of a pipewire link.
+/// See @@PwLink.state.
+class PwLinkState: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : qint8 {
+		Error = PW_LINK_STATE_ERROR,
+		Unlinked = PW_LINK_STATE_UNLINKED,
+		Init = PW_LINK_STATE_INIT,
+		Negotiating = PW_LINK_STATE_NEGOTIATING,
+		Allocating = PW_LINK_STATE_ALLOCATING,
+		Paused = PW_LINK_STATE_PAUSED,
+		Active = PW_LINK_STATE_ACTIVE,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(qs::service::pipewire::PwLinkState::Enum value);
+};
+
+class PwLink: public PwBindable<pw_link, PW_TYPE_INTERFACE_Link, PW_VERSION_LINK> {
+	Q_OBJECT;
+
+public:
+	void bindHooks() override;
+	void unbindHooks() override;
+	void initProps(const spa_dict* props) override;
+
+	[[nodiscard]] quint32 outputNode() const;
+	[[nodiscard]] quint32 inputNode() const;
+	[[nodiscard]] PwLinkState::Enum state() const;
+
+signals:
+	void stateChanged();
+
+private:
+	static const pw_link_events EVENTS;
+	static void onInfo(void* data, const struct pw_link_info* info);
+
+	void setOutputNode(quint32 outputNode);
+	void setInputNode(quint32 inputNode);
+	void setState(pw_link_state state);
+
+	SpaHook listener;
+
+	quint32 mOutputNode = 0;
+	quint32 mInputNode = 0;
+	pw_link_state mState = PW_LINK_STATE_UNLINKED;
+};
+
+QDebug operator<<(QDebug debug, const PwLink* link);
+
+class PwLinkGroup: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit PwLinkGroup(PwLink* firstLink, QObject* parent = nullptr);
+
+	void ref();
+	void unref();
+
+	[[nodiscard]] quint32 outputNode() const;
+	[[nodiscard]] quint32 inputNode() const;
+	[[nodiscard]] PwLinkState::Enum state() const;
+
+	QHash<quint32, PwLink*> links;
+
+	bool tryAddLink(PwLink* link);
+
+signals:
+	void stateChanged();
+
+private slots:
+	void onLinkRemoved(QObject* object);
+
+private:
+	quint32 mOutputNode = 0;
+	quint32 mInputNode = 0;
+	PwLink* trackedLink = nullptr;
+	quint32 refcount = 0;
+};
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/metadata.cpp b/src/services/pipewire/metadata.cpp
new file mode 100644
index 00000000..f2f4ec84
--- /dev/null
+++ b/src/services/pipewire/metadata.cpp
@@ -0,0 +1,77 @@
+#include "metadata.hpp"
+
+#include <pipewire/core.h>
+#include <pipewire/extensions/metadata.h>
+#include <pipewire/permission.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qstringview.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <spa/utils/dict.h>
+
+#include "../../core/logcat.hpp"
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+namespace {
+QS_LOGGING_CATEGORY(logMeta, "quickshell.service.pipewire.metadata", QtWarningMsg);
+}
+
+void PwMetadata::bindHooks() {
+	pw_metadata_add_listener(this->proxy(), &this->listener.hook, &PwMetadata::EVENTS, this);
+}
+
+void PwMetadata::unbindHooks() { this->listener.remove(); }
+
+void PwMetadata::initProps(const spa_dict* props) {
+	if (const auto* name = spa_dict_lookup(props, PW_KEY_METADATA_NAME)) {
+		this->mName = name;
+	}
+}
+
+const QString& PwMetadata::name() const { return this->mName; }
+
+const pw_metadata_events PwMetadata::EVENTS = {
+    .version = PW_VERSION_METADATA_EVENTS,
+    .property = &PwMetadata::onProperty,
+};
+
+int PwMetadata::onProperty(
+    void* data,
+    quint32 subject,
+    const char* key,
+    const char* type,
+    const char* value
+) {
+	auto* self = static_cast<PwMetadata*>(data);
+	qCDebug(logMeta) << "Received metadata for" << self << "- subject:" << subject
+	                 << "key:" << QString(key) << "type:" << QString(type)
+	                 << "value:" << QString(value);
+
+	emit self->propertyChanged(key, type, value);
+
+	return 0; // ??? - no docs and no reason for a callback to return an int
+}
+
+bool PwMetadata::hasSetPermission() const {
+	return (this->perms & (PW_PERM_W | PW_PERM_X)) == (PW_PERM_W | PW_PERM_X);
+}
+
+void PwMetadata::setProperty(const char* key, const char* type, const char* value) {
+	if (this->proxy() == nullptr) {
+		qCCritical(logMeta) << "Tried to change property of" << this << "which is not bound.";
+		return;
+	}
+
+	if (!this->hasSetPermission()) {
+		qCCritical(logMeta) << "Tried to change property of" << this
+		                    << "which is missing write+execute permissions.";
+	}
+
+	pw_metadata_set_property(this->proxy(), PW_ID_CORE, key, type, value);
+}
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/metadata.hpp b/src/services/pipewire/metadata.hpp
new file mode 100644
index 00000000..f257dc23
--- /dev/null
+++ b/src/services/pipewire/metadata.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <pipewire/extensions/metadata.h>
+#include <pipewire/type.h>
+#include <qobject.h>
+#include <qstringview.h>
+#include <qtmetamacros.h>
+
+#include "core.hpp"
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+class PwMetadata: public PwBindable<pw_metadata, PW_TYPE_INTERFACE_Metadata, PW_VERSION_METADATA> {
+	Q_OBJECT;
+
+public:
+	void bindHooks() override;
+	void unbindHooks() override;
+	void initProps(const spa_dict* props) override;
+
+	[[nodiscard]] const QString& name() const;
+	[[nodiscard]] bool hasSetPermission() const;
+
+	// null value clears
+	void setProperty(const char* key, const char* type, const char* value);
+
+signals:
+	void propertyChanged(const char* key, const char* type, const char* value);
+
+private:
+	static const pw_metadata_events EVENTS;
+	static int
+	onProperty(void* data, quint32 subject, const char* key, const char* type, const char* value);
+
+	QString mName;
+
+	SpaHook listener;
+};
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/module.md b/src/services/pipewire/module.md
new file mode 100644
index 00000000..d109f05a
--- /dev/null
+++ b/src/services/pipewire/module.md
@@ -0,0 +1,8 @@
+name = "Quickshell.Services.Pipewire"
+description = "Pipewire API"
+headers = [
+	"qml.hpp",
+	"link.hpp",
+	"node.hpp",
+]
+-----
diff --git a/src/services/pipewire/node.cpp b/src/services/pipewire/node.cpp
new file mode 100644
index 00000000..3e681491
--- /dev/null
+++ b/src/services/pipewire/node.cpp
@@ -0,0 +1,543 @@
+#include "node.hpp"
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+
+#include <pipewire/core.h>
+#include <pipewire/keys.h>
+#include <pipewire/node.h>
+#include <qcontainerfwd.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qstringliteral.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <spa/node/keys.h>
+#include <spa/param/param.h>
+#include <spa/param/props.h>
+#include <spa/pod/builder.h>
+#include <spa/pod/iter.h>
+#include <spa/pod/pod.h>
+#include <spa/pod/vararg.h>
+#include <spa/utils/dict.h>
+#include <spa/utils/keys.h>
+#include <spa/utils/type.h>
+
+#include "../../core/logcat.hpp"
+#include "connection.hpp"
+#include "core.hpp"
+#include "device.hpp"
+
+namespace qs::service::pipewire {
+
+namespace {
+QS_LOGGING_CATEGORY(logNode, "quickshell.service.pipewire.node", QtWarningMsg);
+}
+
+QString PwAudioChannel::toString(Enum value) {
+	switch (value) {
+	case Unknown: return "Unknown";
+	case NA: return "N/A";
+	case Mono: return "Mono";
+	case FrontCenter: return "Front Center";
+	case FrontLeft: return "Front Left";
+	case FrontRight: return "Front Right";
+	case FrontLeftCenter: return "Front Left Center";
+	case FrontRightCenter: return "Front Right Center";
+	case FrontLeftWide: return "Front Left Wide";
+	case FrontRightWide: return "Front Right Wide";
+	case FrontCenterHigh: return "Front Center High";
+	case FrontLeftHigh: return "Front Left High";
+	case FrontRightHigh: return "Front Right High";
+	case LowFrequencyEffects: return "Low Frequency Effects";
+	case LowFrequencyEffects2: return "Low Frequency Effects 2";
+	case LowFrequencyEffectsLeft: return "Low Frequency Effects Left";
+	case LowFrequencyEffectsRight: return "Low Frequency Effects Right";
+	case SideLeft: return "Side Left";
+	case SideRight: return "Side Right";
+	case RearCenter: return "Rear Center";
+	case RearLeft: return "Rear Left";
+	case RearRight: return "Rear Right";
+	case RearLeftCenter: return "Rear Left Center";
+	case RearRightCenter: return "Rear Right Center";
+	case TopCenter: return "Top Center";
+	case TopFrontCenter: return "Top Front Center";
+	case TopFrontLeft: return "Top Front Left";
+	case TopFrontRight: return "Top Front Right";
+	case TopFrontLeftCenter: return "Top Front Left Center";
+	case TopFrontRightCenter: return "Top Front Right Center";
+	case TopSideLeft: return "Top Side Left";
+	case TopSideRight: return "Top Side Right";
+	case TopRearCenter: return "Top Rear Center";
+	case TopRearLeft: return "Top Rear Left";
+	case TopRearRight: return "Top Rear Right";
+	case BottomCenter: return "Bottom Center";
+	case BottomLeftCenter: return "Bottom Left Center";
+	case BottomRightCenter: return "Bottom Right Center";
+	default:
+		if (value >= AuxRangeStart && value <= AuxRangeEnd) {
+			return QString("Aux %1").arg(value - AuxRangeStart + 1);
+		} else if (value >= CustomRangeStart) {
+			return QString("Custom %1").arg(value - CustomRangeStart + 1);
+		} else {
+			return "Unknown";
+		}
+	}
+}
+
+QString PwNodeType::toString(PwNodeType::Flags type) {
+	switch (type) {
+	case PwNodeType::VideoSource: return QStringLiteral("VideoSource");
+	case PwNodeType::VideoSink: return QStringLiteral("VideoSink");
+	case PwNodeType::AudioSource: return QStringLiteral("AudioSource");
+	case PwNodeType::AudioSink: return QStringLiteral("AudioSink");
+	case PwNodeType::AudioDuplex: return QStringLiteral("AudioDuplex");
+	case PwNodeType::AudioOutStream: return QStringLiteral("AudioOutStream");
+	case PwNodeType::AudioInStream: return QStringLiteral("AudioInStream");
+	case PwNodeType::Untracked: return QStringLiteral("Untracked");
+	default: return QStringLiteral("Invalid");
+	}
+}
+
+void PwNode::bindHooks() {
+	// Bind the device first as pw is in order, meaning the device should be bound before
+	// we want to do anything with it.
+	if (this->device) this->device->ref();
+
+	pw_node_add_listener(this->proxy(), &this->listener.hook, &PwNode::EVENTS, this);
+}
+
+void PwNode::unbindHooks() {
+	if (this->ready) {
+		this->ready = false;
+		emit this->readyChanged();
+	}
+
+	this->syncSeq = 0;
+	this->listener.remove();
+	this->routeDevice = -1;
+	this->properties.clear();
+	emit this->propertiesChanged();
+
+	if (this->boundData != nullptr) {
+		this->boundData->onUnbind();
+	}
+
+	// unbind after the node is unbound
+	if (this->device) this->device->unref();
+}
+
+void PwNode::initProps(const spa_dict* props) {
+	if (const auto* mediaClass = spa_dict_lookup(props, SPA_KEY_MEDIA_CLASS)) {
+		if (strcmp(mediaClass, "Audio/Sink") == 0) {
+			this->type = PwNodeType::AudioSink;
+		} else if (strcmp(mediaClass, "Audio/Source") == 0) {
+			this->type = PwNodeType::AudioSource;
+		} else if (strcmp(mediaClass, "Audio/Duplex") == 0) {
+			this->type = PwNodeType::AudioDuplex;
+		} else if (strcmp(mediaClass, "Stream/Output/Audio") == 0) {
+			this->type = PwNodeType::AudioOutStream;
+		} else if (strcmp(mediaClass, "Stream/Input/Audio") == 0) {
+			this->type = PwNodeType::AudioInStream;
+		} else if (strcmp(mediaClass, "Video/Sink") == 0) {
+			this->type = PwNodeType::VideoSink;
+		} else if (strcmp(mediaClass, "Video/Source") == 0) {
+			this->type = PwNodeType::VideoSource;
+		}
+	}
+
+	if (const auto* nodeName = spa_dict_lookup(props, SPA_KEY_NODE_NAME)) {
+		this->name = nodeName;
+	}
+
+	if (const auto* nodeDesc = spa_dict_lookup(props, SPA_KEY_NODE_DESCRIPTION)) {
+		this->description = nodeDesc;
+	}
+
+	if (const auto* nodeNick = spa_dict_lookup(props, PW_KEY_NODE_NICK)) {
+		this->nick = nodeNick;
+	}
+
+	if (const auto* deviceId = spa_dict_lookup(props, PW_KEY_DEVICE_ID)) {
+		auto ok = false;
+		auto id = QString::fromUtf8(deviceId).toInt(&ok);
+
+		if (!ok) {
+			qCCritical(logNode) << this << "has a device.id property but the value is not an integer. Id:"
+			                    << deviceId;
+		} else {
+			this->device = this->registry->devices.value(id);
+
+			if (this->device == nullptr) {
+				qCCritical(logNode
+				) << this
+				  << "has a device.id property that does not corrospond to a device object. Id:" << id;
+			}
+		}
+	}
+
+	if (this->type.testFlags(PwNodeType::Audio)) {
+		this->boundData = new PwNodeBoundAudio(this);
+	}
+}
+
+const pw_node_events PwNode::EVENTS = {
+    .version = PW_VERSION_NODE_EVENTS,
+    .info = &PwNode::onInfo,
+    .param = &PwNode::onParam,
+};
+
+void PwNode::onInfo(void* data, const pw_node_info* info) {
+	auto* self = static_cast<PwNode*>(data);
+
+	if ((info->change_mask & PW_NODE_CHANGE_MASK_PROPS) != 0) {
+		auto properties = QMap<QString, QString>();
+
+		if (self->device) {
+			if (const auto* routeDevice = spa_dict_lookup(info->props, "card.profile.device")) {
+				auto ok = false;
+				auto id = QString::fromUtf8(routeDevice).toInt(&ok);
+
+				if (!ok) {
+					qCCritical(logNode
+					) << self
+					  << "has a card.profile.device property but the value is not an integer. Value:" << id;
+				}
+
+				self->routeDevice = id;
+			} else {
+				qCCritical(logNode) << self << "has attached device" << self->device
+				                    << "but no card.profile.device property.";
+			}
+		}
+
+		const spa_dict_item* item = nullptr;
+		spa_dict_for_each(item, info->props) { properties.insert(item->key, item->value); }
+
+		self->properties = properties;
+		emit self->propertiesChanged();
+	}
+
+	if (self->boundData != nullptr) {
+		self->boundData->onInfo(info);
+	}
+
+	if (!self->ready && !self->syncSeq) {
+		auto* core = PwConnection::instance()->registry.core;
+		QObject::connect(core, &PwCore::synced, self, &PwNode::onCoreSync);
+		self->syncSeq = core->sync(self->id);
+	}
+}
+
+void PwNode::onCoreSync(quint32 id, qint32 seq) {
+	if (id != this->id || seq != this->syncSeq) return;
+	qCInfo(logNode) << "Completed initial sync for" << this;
+	this->ready = true;
+	this->syncSeq = 0;
+	emit this->readyChanged();
+}
+
+void PwNode::onParam(
+    void* data,
+    qint32 /*seq*/,
+    quint32 id,
+    quint32 index,
+    quint32 /*next*/,
+    const spa_pod* param
+) {
+	auto* self = static_cast<PwNode*>(data);
+	if (self->boundData != nullptr) {
+		self->boundData->onSpaParam(id, index, param);
+	}
+}
+
+PwNodeBoundAudio::PwNodeBoundAudio(PwNode* node): QObject(node), node(node) {
+	if (node->device) {
+		QObject::connect(node->device, &PwDevice::deviceReady, this, &PwNodeBoundAudio::onDeviceReady);
+
+		QObject::connect(
+		    node->device,
+		    &PwDevice::routeVolumesChanged,
+		    this,
+		    &PwNodeBoundAudio::onDeviceVolumesChanged
+		);
+	}
+}
+
+void PwNodeBoundAudio::onInfo(const pw_node_info* info) {
+	if ((info->change_mask & PW_NODE_CHANGE_MASK_PARAMS) != 0) {
+		for (quint32 i = 0; i < info->n_params; i++) {
+			auto& param = info->params[i]; // NOLINT
+
+			if (param.id == SPA_PARAM_Props) {
+				if ((param.flags & SPA_PARAM_INFO_READWRITE) == SPA_PARAM_INFO_READWRITE) {
+					qCDebug(logNode) << "Enumerating props param for" << this->node;
+					pw_node_enum_params(this->node->proxy(), 0, param.id, 0, UINT32_MAX, nullptr);
+				} else {
+					qCWarning(logNode) << "Unable to enumerate props param for" << this->node
+					                   << "as the param does not have read+write permissions.";
+				}
+			}
+		}
+	}
+}
+
+void PwNodeBoundAudio::onSpaParam(quint32 id, quint32 index, const spa_pod* param) {
+	if (id == SPA_PARAM_Props && index == 0) {
+		if (this->node->device) {
+			qCDebug(logNode) << "Skipping node volume props update for" << this->node
+			                 << "in favor of device updates.";
+			return;
+		}
+
+		this->updateVolumeProps(PwVolumeProps::parseSpaPod(param));
+	}
+}
+
+void PwNodeBoundAudio::updateVolumeProps(const PwVolumeProps& volumeProps) {
+	if (volumeProps.volumes.size() != volumeProps.channels.size()) {
+		qCWarning(logNode) << "Cannot update volume props of" << this->node
+		                   << "- channelVolumes and channelMap are not the same size. Sizes:"
+		                   << volumeProps.volumes.size() << volumeProps.channels.size();
+		return;
+	}
+
+	// It is important that the lengths of channels and volumes stay in sync whenever you read them.
+	auto channelsChanged = false;
+	auto volumesChanged = false;
+	auto mutedChanged = false;
+
+	if (this->mChannels != volumeProps.channels) {
+		this->mChannels = volumeProps.channels;
+		channelsChanged = true;
+		qCInfo(logNode) << "Got updated channels of" << this->node << '-' << this->mChannels;
+	}
+
+	if (this->mServerVolumes != volumeProps.volumes) {
+		this->mServerVolumes = volumeProps.volumes;
+	}
+
+	if (this->mVolumes != volumeProps.volumes) {
+		this->mVolumes = volumeProps.volumes;
+		volumesChanged = true;
+		qCInfo(logNode) << "Got updated volumes of" << this->node << '-' << this->mVolumes;
+	}
+
+	if (volumeProps.mute != this->mMuted) {
+		this->mMuted = volumeProps.mute;
+		mutedChanged = true;
+		qCInfo(logNode) << "Got updated mute status of" << this->node << '-' << volumeProps.mute;
+	}
+
+	if (channelsChanged) emit this->channelsChanged();
+	if (volumesChanged) emit this->volumesChanged();
+	if (mutedChanged) emit this->mutedChanged();
+}
+
+void PwNodeBoundAudio::onUnbind() {
+	this->mChannels.clear();
+	this->mVolumes.clear();
+	this->mServerVolumes.clear();
+	this->mDeviceVolumes.clear();
+	this->waitingVolumes.clear();
+	emit this->channelsChanged();
+	emit this->volumesChanged();
+}
+
+bool PwNodeBoundAudio::isMuted() const { return this->mMuted; }
+
+void PwNodeBoundAudio::setMuted(bool muted) {
+	if (this->node->proxy() == nullptr) {
+		qCCritical(logNode) << "Tried to change mute state for" << this->node << "which is not bound.";
+		return;
+	}
+
+	if (muted == this->mMuted) return;
+
+	if (this->node->device) {
+		qCInfo(logNode) << "Changing muted state of" << this->node << "to" << muted << "via device";
+		if (!this->node->device->setMuted(this->node->routeDevice, muted)) {
+			return;
+		}
+	} else {
+		auto buffer = std::array<quint8, 1024>();
+		auto builder = SPA_POD_BUILDER_INIT(buffer.data(), buffer.size());
+
+		// is this a leak? seems like probably not? docs don't say, as usual.
+		// clang-format off
+		auto* pod = spa_pod_builder_add_object(
+				&builder, SPA_TYPE_OBJECT_Props, SPA_PARAM_Props,
+				SPA_PROP_mute, SPA_POD_Bool(muted)
+		);
+		// clang-format on
+
+		qCInfo(logNode) << "Changed muted state of" << this->node << "to" << muted << "via node";
+		pw_node_set_param(this->node->proxy(), SPA_PARAM_Props, 0, static_cast<spa_pod*>(pod));
+	}
+
+	this->mMuted = muted;
+	emit this->mutedChanged();
+}
+
+float PwNodeBoundAudio::averageVolume() const {
+	float total = 0;
+
+	for (auto volume: this->mVolumes) {
+		total += volume;
+	}
+
+	return total / static_cast<float>(this->mVolumes.size());
+}
+
+void PwNodeBoundAudio::setAverageVolume(float volume) {
+	auto oldAverage = this->averageVolume();
+	auto mul = oldAverage == 0 ? 0 : volume / oldAverage;
+	auto volumes = QVector<float>();
+
+	for (auto oldVolume: this->mVolumes) {
+		volumes.push_back(mul == 0 ? volume : oldVolume * mul);
+	}
+
+	this->setVolumes(volumes);
+}
+
+QVector<PwAudioChannel::Enum> PwNodeBoundAudio::channels() const { return this->mChannels; }
+
+QVector<float> PwNodeBoundAudio::volumes() const { return this->mVolumes; }
+
+void PwNodeBoundAudio::setVolumes(const QVector<float>& volumes) {
+	if (this->node->proxy() == nullptr) {
+		qCCritical(logNode) << "Tried to change node volumes for" << this->node
+		                    << "which is not bound.";
+		return;
+	}
+
+	auto realVolumes = QVector<float>();
+	for (auto volume: volumes) {
+		realVolumes.push_back(volume < 0 ? 0 : volume);
+	}
+
+	if (realVolumes == this->mVolumes) return;
+
+	if (realVolumes.length() != this->mVolumes.length()) {
+		qCCritical(logNode) << "Tried to change node volumes for" << this->node << "from"
+		                    << this->mVolumes << "to" << volumes
+		                    << "which has a different length than the list of channels"
+		                    << this->mChannels;
+		return;
+	}
+
+	if (this->node->device) {
+		if (this->node->device->waitingForDevice()) {
+			qCInfo(logNode) << "Waiting to change volumes of" << this->node << "to" << realVolumes
+			                << "via device";
+			this->waitingVolumes = realVolumes;
+		} else {
+			auto significantChange = this->mServerVolumes.isEmpty();
+			for (auto i = 0; i < this->mServerVolumes.length(); i++) {
+				auto serverVolume = this->mServerVolumes.value(i);
+				auto targetVolume = realVolumes.value(i);
+				if (targetVolume == 0 || abs(targetVolume - serverVolume) >= 0.0001) {
+					significantChange = true;
+					break;
+				}
+			}
+
+			if (significantChange) {
+				qCInfo(logNode) << "Changing volumes of" << this->node << "to" << realVolumes
+				                << "via device";
+				if (!this->node->device->setVolumes(this->node->routeDevice, realVolumes)) {
+					return;
+				}
+
+				this->mDeviceVolumes = realVolumes;
+				this->node->device->waitForDevice();
+			} else {
+				// Insignificant changes won't cause an info event on the device, leaving qs hung in the
+				// "waiting for acknowledgement" state forever.
+				qCInfo(logNode) << "Ignoring volume change for" << this->node << "to" << realVolumes
+				                << "from" << this->mServerVolumes
+				                << "as it is a device node and the change is too small.";
+			}
+		}
+	} else {
+		auto buffer = std::array<quint8, 1024>();
+		auto builder = SPA_POD_BUILDER_INIT(buffer.data(), buffer.size());
+
+		auto cubedVolumes = QVector<float>();
+		for (auto volume: realVolumes) {
+			cubedVolumes.push_back(volume * volume * volume);
+		}
+
+		// clang-format off
+		auto* pod = spa_pod_builder_add_object(
+				&builder, SPA_TYPE_OBJECT_Props, SPA_PARAM_Props,
+				SPA_PROP_channelVolumes, SPA_POD_Array(sizeof(float), SPA_TYPE_Float, cubedVolumes.length(), cubedVolumes.data())
+		);
+		// clang-format on
+
+		qCInfo(logNode) << "Changing volumes of" << this->node << "to" << volumes << "via node";
+		pw_node_set_param(this->node->proxy(), SPA_PARAM_Props, 0, static_cast<spa_pod*>(pod));
+	}
+
+	this->mVolumes = realVolumes;
+	emit this->volumesChanged();
+}
+
+void PwNodeBoundAudio::onDeviceReady() {
+	if (!this->waitingVolumes.isEmpty()) {
+		if (this->waitingVolumes != this->mDeviceVolumes) {
+			qCInfo(logNode) << "Changing volumes of" << this->node << "to" << this->waitingVolumes
+			                << "via device (delayed)";
+
+			this->node->device->setVolumes(this->node->routeDevice, this->waitingVolumes);
+			this->mDeviceVolumes = this->waitingVolumes;
+			this->mVolumes = this->waitingVolumes;
+		}
+
+		this->waitingVolumes.clear();
+	}
+}
+
+void PwNodeBoundAudio::onDeviceVolumesChanged(
+    qint32 routeDevice,
+    const PwVolumeProps& volumeProps
+) {
+	if (this->node->device && this->node->routeDevice == routeDevice) {
+		qCDebug(logNode) << "Got updated device volume props for" << this->node << "via"
+		                 << this->node->device;
+
+		this->updateVolumeProps(volumeProps);
+	}
+}
+
+PwVolumeProps PwVolumeProps::parseSpaPod(const spa_pod* param) {
+	auto props = PwVolumeProps();
+
+	const auto* volumesProp = spa_pod_find_prop(param, nullptr, SPA_PROP_channelVolumes);
+	const auto* channelsProp = spa_pod_find_prop(param, nullptr, SPA_PROP_channelMap);
+	const auto* muteProp = spa_pod_find_prop(param, nullptr, SPA_PROP_mute);
+
+	const auto* volumes = reinterpret_cast<const spa_pod_array*>(&volumesProp->value);
+	const auto* channels = reinterpret_cast<const spa_pod_array*>(&channelsProp->value);
+
+	spa_pod* iter = nullptr;
+	SPA_POD_ARRAY_FOREACH(volumes, iter) {
+		// Cubing behavior found in MPD source, and appears to corrospond to everyone else's measurements correctly.
+		auto linear = *reinterpret_cast<float*>(iter);
+		auto visual = std::cbrt(linear);
+		props.volumes.push_back(visual);
+	}
+
+	SPA_POD_ARRAY_FOREACH(channels, iter) {
+		props.channels.push_back(*reinterpret_cast<PwAudioChannel::Enum*>(iter));
+	}
+
+	spa_pod_get_bool(&muteProp->value, &props.mute);
+
+	return props;
+}
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/node.hpp b/src/services/pipewire/node.hpp
new file mode 100644
index 00000000..0d4c92e0
--- /dev/null
+++ b/src/services/pipewire/node.hpp
@@ -0,0 +1,259 @@
+#pragma once
+
+#include <pipewire/core.h>
+#include <pipewire/node.h>
+#include <pipewire/type.h>
+#include <qcontainerfwd.h>
+#include <qflags.h>
+#include <qmap.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <spa/param/audio/raw.h>
+#include <spa/pod/pod.h>
+
+#include "core.hpp"
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+class PwDevice;
+
+///! Audio channel of a pipewire node.
+/// See @@PwNodeAudio.channels.
+class PwAudioChannel: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum {
+		Unknown = SPA_AUDIO_CHANNEL_UNKNOWN,
+		NA = SPA_AUDIO_CHANNEL_NA,
+		Mono = SPA_AUDIO_CHANNEL_MONO,
+		FrontCenter = SPA_AUDIO_CHANNEL_FC,
+		FrontLeft = SPA_AUDIO_CHANNEL_FL,
+		FrontRight = SPA_AUDIO_CHANNEL_FR,
+		FrontLeftCenter = SPA_AUDIO_CHANNEL_FLC,
+		FrontRightCenter = SPA_AUDIO_CHANNEL_FRC,
+		FrontLeftWide = SPA_AUDIO_CHANNEL_FLW,
+		FrontRightWide = SPA_AUDIO_CHANNEL_FRW,
+		FrontCenterHigh = SPA_AUDIO_CHANNEL_FCH,
+		FrontLeftHigh = SPA_AUDIO_CHANNEL_FLH,
+		FrontRightHigh = SPA_AUDIO_CHANNEL_FRH,
+		LowFrequencyEffects = SPA_AUDIO_CHANNEL_LFE,
+		LowFrequencyEffects2 = SPA_AUDIO_CHANNEL_LFE2,
+		LowFrequencyEffectsLeft = SPA_AUDIO_CHANNEL_LLFE,
+		LowFrequencyEffectsRight = SPA_AUDIO_CHANNEL_RLFE,
+		SideLeft = SPA_AUDIO_CHANNEL_SL,
+		SideRight = SPA_AUDIO_CHANNEL_SR,
+		RearCenter = SPA_AUDIO_CHANNEL_RC,
+		RearLeft = SPA_AUDIO_CHANNEL_RL,
+		RearRight = SPA_AUDIO_CHANNEL_RR,
+		RearLeftCenter = SPA_AUDIO_CHANNEL_RLC,
+		RearRightCenter = SPA_AUDIO_CHANNEL_RRC,
+		TopCenter = SPA_AUDIO_CHANNEL_TC,
+		TopFrontCenter = SPA_AUDIO_CHANNEL_TFC,
+		TopFrontLeft = SPA_AUDIO_CHANNEL_TFL,
+		TopFrontRight = SPA_AUDIO_CHANNEL_TFR,
+		TopFrontLeftCenter = SPA_AUDIO_CHANNEL_TFLC,
+		TopFrontRightCenter = SPA_AUDIO_CHANNEL_TFRC,
+		TopSideLeft = SPA_AUDIO_CHANNEL_TSL,
+		TopSideRight = SPA_AUDIO_CHANNEL_TSR,
+		TopRearCenter = SPA_AUDIO_CHANNEL_TRC,
+		TopRearLeft = SPA_AUDIO_CHANNEL_TRL,
+		TopRearRight = SPA_AUDIO_CHANNEL_TRR,
+		BottomCenter = SPA_AUDIO_CHANNEL_BC,
+		BottomLeftCenter = SPA_AUDIO_CHANNEL_BLC,
+		BottomRightCenter = SPA_AUDIO_CHANNEL_BRC,
+		/// The start of the aux channel range.
+		///
+		/// Values between AuxRangeStart and AuxRangeEnd are valid.
+		AuxRangeStart = SPA_AUDIO_CHANNEL_START_Aux,
+		/// The end of the aux channel range.
+		///
+		/// Values between AuxRangeStart and AuxRangeEnd are valid.
+		AuxRangeEnd = SPA_AUDIO_CHANNEL_LAST_Aux,
+		/// The end of the custom channel range.
+		///
+		/// Values starting at CustomRangeStart are valid.
+		CustomRangeStart = SPA_AUDIO_CHANNEL_START_Custom,
+	};
+	Q_ENUM(Enum);
+
+	/// Print a human readable representation of the given channel,
+	/// including aux and custom channel ranges.
+	Q_INVOKABLE static QString toString(qs::service::pipewire::PwAudioChannel::Enum value);
+};
+///! The type of a pipewire node.
+/// Use bitwise comparisons to filter for audio, video, sink, source or stream nodes
+class PwNodeType: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Flag : quint8 {
+		// A Pipewire node which is not being managed.
+		Untracked = 0b0,
+		// This flag is set when this node is an Audio node.
+		Audio = 0b1,
+		// This flag is set when this node is an Video node.
+		Video = 0b10,
+		// This flag is set when this node is a stream node.
+		Stream = 0b100,
+		// This flag is set when this node is producing some form of data,
+		// such as a microphone, screenshare or webcam.
+		Source = 0b1000,
+		// This flag is set when this node is receiving data.
+		Sink = 0b10000,
+		// A sink for audio samples, like an audio card.
+		//
+		// This is equivalent to the media class `Video/Source` and is
+		// composed of the @@PwNodeType.Audio and @@PwNodeType.Sink flags.
+		AudioSink = Audio | Sink,
+		// A source of audio samples like a microphone.
+		//
+		// This is quivalent to the media class `Video/Sink` and is composed
+		// of the @@PwNodeType.Audio and @@PwNodeType.Source flags.
+		AudioSource = Audio | Source,
+		// A node that is both a sink and a source.
+		//
+		// This is equivalent to the media class `Audio/Duplex` and is composed of the
+		// @@PwNodeType.Audio, @@PwNodeType.Source and @@PwNodeType.Sink flags.
+		AudioDuplex = Audio | Sink | Source,
+		// A playback stream.
+		//
+		// This is equivalent to the media class `Stream/Output/Audio` and is composed
+		// of the @@PwNodeType.Audio, @@PwNodeType.Sink and @@PwNodeType.Stream flags.
+		AudioOutStream = Audio | Sink | Stream,
+		// A capture stream.
+		//
+		// This is equivalent to the media class `Stream/Input/Audio` and is composed
+		// of the @@PwNodeType.Audio, @@PwNodeType.Source and @@PwNodeType.Stream flags.
+		AudioInStream = Audio | Source | Stream,
+		// A producer of video, like a webcam or a screenshare.
+		//
+		// This is equivalent to the media class `Video/Source` and is composed
+		// of the @@PwNodeType.Video and @@PwNodeType.Source flags.
+		VideoSource = Video | Source,
+		// A consumer of video, such as a program that is recieving a video stream.
+		//
+		// This is equivalent to the media class `Video/Sink` and is composed of the
+		// @@PwNodeType.Video and @@PwNodeType.Sink flags.
+		VideoSink = Video | Sink,
+	};
+	Q_ENUM(Flag);
+	Q_DECLARE_FLAGS(Flags, Flag);
+	Q_INVOKABLE static QString toString(qs::service::pipewire::PwNodeType::Flags type);
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(PwNodeType::Flags)
+
+class PwNode;
+
+struct PwVolumeProps {
+	QVector<PwAudioChannel::Enum> channels;
+	QVector<float> volumes;
+	bool mute = false;
+
+	static PwVolumeProps parseSpaPod(const spa_pod* param);
+};
+
+class PwNodeBoundData {
+public:
+	PwNodeBoundData() = default;
+	virtual ~PwNodeBoundData() = default;
+	Q_DISABLE_COPY_MOVE(PwNodeBoundData);
+
+	virtual void onInfo(const pw_node_info* /*info*/) {}
+	virtual void onSpaParam(quint32 /*id*/, quint32 /*index*/, const spa_pod* /*param*/) {}
+	virtual void onUnbind() {}
+};
+
+class PwNodeBoundAudio
+    : public QObject
+    , public PwNodeBoundData {
+	Q_OBJECT;
+
+public:
+	explicit PwNodeBoundAudio(PwNode* node);
+
+	void onInfo(const pw_node_info* info) override;
+	void onSpaParam(quint32 id, quint32 index, const spa_pod* param) override;
+	void onUnbind() override;
+
+	[[nodiscard]] bool isMuted() const;
+	void setMuted(bool muted);
+
+	[[nodiscard]] float averageVolume() const;
+	void setAverageVolume(float volume);
+
+	[[nodiscard]] QVector<PwAudioChannel::Enum> channels() const;
+
+	[[nodiscard]] QVector<float> volumes() const;
+	void setVolumes(const QVector<float>& volumes);
+
+signals:
+	void volumesChanged();
+	void channelsChanged();
+	void mutedChanged();
+
+private slots:
+	void onDeviceReady();
+	void onDeviceVolumesChanged(qint32 routeDevice, const PwVolumeProps& props);
+
+private:
+	void updateVolumeProps(const PwVolumeProps& volumeProps);
+
+	bool mMuted = false;
+	QVector<PwAudioChannel::Enum> mChannels;
+	QVector<float> mVolumes;
+	QVector<float> mServerVolumes;
+	QVector<float> mDeviceVolumes;
+	QVector<float> waitingVolumes;
+	PwNode* node;
+};
+
+class PwNode: public PwBindable<pw_node, PW_TYPE_INTERFACE_Node, PW_VERSION_NODE> {
+	Q_OBJECT;
+
+public:
+	void bindHooks() override;
+	void unbindHooks() override;
+	void initProps(const spa_dict* props) override;
+
+	QString name;
+	QString description;
+	QString nick;
+	QMap<QString, QString> properties;
+
+	PwNodeType::Flags type = PwNodeType::Untracked;
+
+	bool ready = false;
+
+	PwNodeBoundData* boundData = nullptr;
+
+	PwDevice* device = nullptr;
+	qint32 routeDevice = -1;
+
+signals:
+	void propertiesChanged();
+	void readyChanged();
+
+private slots:
+	void onCoreSync(quint32 id, qint32 seq);
+
+private:
+	static const pw_node_events EVENTS;
+	static void onInfo(void* data, const pw_node_info* info);
+	static void
+	onParam(void* data, qint32 seq, quint32 id, quint32 index, quint32 next, const spa_pod* param);
+
+	qint32 syncSeq = 0;
+	SpaHook listener;
+};
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/qml.cpp b/src/services/pipewire/qml.cpp
new file mode 100644
index 00000000..9efb17eb
--- /dev/null
+++ b/src/services/pipewire/qml.cpp
@@ -0,0 +1,484 @@
+#include "qml.hpp"
+
+#include <qcontainerfwd.h>
+#include <qlist.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+#include "../../core/model.hpp"
+#include "connection.hpp"
+#include "defaults.hpp"
+#include "link.hpp"
+#include "node.hpp"
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+PwObjectIface::PwObjectIface(PwBindableObject* object): QObject(object), object(object) {
+	// We want to destroy the interface before QObject::destroyed is fired, as handlers
+	// connected before PwObjectIface will run first and emit signals that hit user code,
+	// which can then try to reference the iface again after ~PwNode() has been called but
+	// before ~QObject() has finished.
+	QObject::connect(object, &PwBindableObject::destroying, this, &PwObjectIface::onObjectDestroying);
+}
+
+void PwObjectIface::onObjectDestroying() { delete this; }
+
+void PwObjectIface::ref() {
+	this->refcount++;
+
+	if (this->refcount == 1) {
+		this->object->ref();
+	}
+}
+
+void PwObjectIface::unref() {
+	if (this->refcount == 0) return;
+	this->refcount--;
+
+	if (this->refcount == 0) {
+		this->object->unref();
+	}
+}
+
+Pipewire::Pipewire(QObject* parent): QObject(parent) {
+	auto* connection = PwConnection::instance();
+
+	for (auto* node: connection->registry.nodes.values()) {
+		this->onNodeAdded(node);
+	}
+
+	QObject::connect(&connection->registry, &PwRegistry::nodeAdded, this, &Pipewire::onNodeAdded);
+
+	for (auto* link: connection->registry.links.values()) {
+		this->onLinkAdded(link);
+	}
+
+	QObject::connect(&connection->registry, &PwRegistry::linkAdded, this, &Pipewire::onLinkAdded);
+
+	for (auto* group: connection->registry.linkGroups) {
+		this->onLinkGroupAdded(group);
+	}
+
+	QObject::connect(
+	    &connection->registry,
+	    &PwRegistry::linkGroupAdded,
+	    this,
+	    &Pipewire::onLinkGroupAdded
+	);
+
+	QObject::connect(
+	    &connection->defaults,
+	    &PwDefaultTracker::defaultSinkChanged,
+	    this,
+	    &Pipewire::defaultAudioSinkChanged
+	);
+
+	QObject::connect(
+	    &connection->defaults,
+	    &PwDefaultTracker::defaultSourceChanged,
+	    this,
+	    &Pipewire::defaultAudioSourceChanged
+	);
+
+	QObject::connect(
+	    &connection->defaults,
+	    &PwDefaultTracker::defaultConfiguredSinkChanged,
+	    this,
+	    &Pipewire::defaultConfiguredAudioSinkChanged
+	);
+
+	QObject::connect(
+	    &connection->defaults,
+	    &PwDefaultTracker::defaultConfiguredSourceChanged,
+	    this,
+	    &Pipewire::defaultConfiguredAudioSourceChanged
+	);
+
+	if (!connection->registry.isInitialized()) {
+		QObject::connect(
+		    &connection->registry,
+		    &PwRegistry::initialized,
+		    this,
+		    &Pipewire::readyChanged,
+		    Qt::SingleShotConnection
+		);
+	}
+}
+
+ObjectModel<PwNodeIface>* Pipewire::nodes() { return &this->mNodes; }
+
+void Pipewire::onNodeAdded(PwNode* node) {
+	auto* iface = PwNodeIface::instance(node);
+	QObject::connect(iface, &QObject::destroyed, this, &Pipewire::onNodeRemoved);
+	this->mNodes.insertObject(iface);
+}
+
+void Pipewire::onNodeRemoved(QObject* object) {
+	auto* iface = static_cast<PwNodeIface*>(object); // NOLINT
+	this->mNodes.removeObject(iface);
+}
+
+ObjectModel<PwLinkIface>* Pipewire::links() { return &this->mLinks; }
+
+void Pipewire::onLinkAdded(PwLink* link) {
+	auto* iface = PwLinkIface::instance(link);
+	QObject::connect(iface, &QObject::destroyed, this, &Pipewire::onLinkRemoved);
+	this->mLinks.insertObject(iface);
+}
+
+void Pipewire::onLinkRemoved(QObject* object) {
+	auto* iface = static_cast<PwLinkIface*>(object); // NOLINT
+	this->mLinks.removeObject(iface);
+}
+
+ObjectModel<PwLinkGroupIface>* Pipewire::linkGroups() { return &this->mLinkGroups; }
+
+void Pipewire::onLinkGroupAdded(PwLinkGroup* linkGroup) {
+	auto* iface = PwLinkGroupIface::instance(linkGroup);
+	QObject::connect(iface, &QObject::destroyed, this, &Pipewire::onLinkGroupRemoved);
+	this->mLinkGroups.insertObject(iface);
+}
+
+void Pipewire::onLinkGroupRemoved(QObject* object) {
+	auto* iface = static_cast<PwLinkGroupIface*>(object); // NOLINT
+	this->mLinkGroups.removeObject(iface);
+}
+
+PwNodeIface* Pipewire::defaultAudioSink() const { // NOLINT
+	auto* node = PwConnection::instance()->defaults.defaultSink();
+	return PwNodeIface::instance(node);
+}
+
+PwNodeIface* Pipewire::defaultAudioSource() const { // NOLINT
+	auto* node = PwConnection::instance()->defaults.defaultSource();
+	return PwNodeIface::instance(node);
+}
+
+PwNodeIface* Pipewire::defaultConfiguredAudioSink() const { // NOLINT
+	auto* node = PwConnection::instance()->defaults.defaultConfiguredSink();
+	return PwNodeIface::instance(node);
+}
+
+void Pipewire::setDefaultConfiguredAudioSink(PwNodeIface* node) {
+	PwConnection::instance()->defaults.changeConfiguredSink(node ? node->node() : nullptr);
+}
+
+PwNodeIface* Pipewire::defaultConfiguredAudioSource() const { // NOLINT
+	auto* node = PwConnection::instance()->defaults.defaultConfiguredSource();
+	return PwNodeIface::instance(node);
+}
+
+void Pipewire::setDefaultConfiguredAudioSource(PwNodeIface* node) {
+	PwConnection::instance()->defaults.changeConfiguredSource(node ? node->node() : nullptr);
+}
+
+bool Pipewire::isReady() { return PwConnection::instance()->registry.isInitialized(); }
+
+PwNodeIface* PwNodeLinkTracker::node() const { return this->mNode; }
+
+void PwNodeLinkTracker::setNode(PwNodeIface* node) {
+	if (node == this->mNode) return;
+
+	if (this->mNode != nullptr) {
+		if (node == nullptr) {
+			QObject::disconnect(&PwConnection::instance()->registry, nullptr, this, nullptr);
+		}
+
+		QObject::disconnect(this->mNode, nullptr, this, nullptr);
+	}
+
+	if (node != nullptr) {
+		if (this->mNode == nullptr) {
+			QObject::connect(
+			    &PwConnection::instance()->registry,
+			    &PwRegistry::linkGroupAdded,
+			    this,
+			    &PwNodeLinkTracker::onLinkGroupCreated
+			);
+		}
+
+		QObject::connect(node, &QObject::destroyed, this, &PwNodeLinkTracker::onNodeDestroyed);
+	}
+
+	this->mNode = node;
+	this->updateLinks();
+	emit this->nodeChanged();
+}
+
+void PwNodeLinkTracker::updateLinks() {
+	// done first to avoid unref->reref of nodes
+	auto newLinks = QVector<PwLinkGroupIface*>();
+	if (this->mNode != nullptr) {
+		auto* connection = PwConnection::instance();
+
+		for (auto* link: connection->registry.linkGroups) {
+			if ((!this->mNode->isSink() && link->outputNode() == this->mNode->id())
+			    || (this->mNode->isSink() && link->inputNode() == this->mNode->id()))
+			{
+				auto* iface = PwLinkGroupIface::instance(link);
+
+				// do not connect twice
+				if (!this->mLinkGroups.contains(iface)) {
+					QObject::connect(
+					    iface,
+					    &QObject::destroyed,
+					    this,
+					    &PwNodeLinkTracker::onLinkGroupDestroyed
+					);
+				}
+
+				newLinks.push_back(iface);
+			}
+		}
+	}
+
+	for (auto* iface: this->mLinkGroups) {
+		// only disconnect no longer used nodes
+		if (!newLinks.contains(iface)) {
+			QObject::disconnect(iface, nullptr, this, nullptr);
+		}
+	}
+
+	this->mLinkGroups = newLinks;
+	emit this->linkGroupsChanged();
+}
+
+QQmlListProperty<PwLinkGroupIface> PwNodeLinkTracker::linkGroups() {
+	return QQmlListProperty<PwLinkGroupIface>(
+	    this,
+	    nullptr,
+	    &PwNodeLinkTracker::linkGroupsCount,
+	    &PwNodeLinkTracker::linkGroupAt
+	);
+}
+
+qsizetype PwNodeLinkTracker::linkGroupsCount(QQmlListProperty<PwLinkGroupIface>* property) {
+	return static_cast<PwNodeLinkTracker*>(property->object)->mLinkGroups.count(); // NOLINT
+}
+
+PwLinkGroupIface*
+PwNodeLinkTracker::linkGroupAt(QQmlListProperty<PwLinkGroupIface>* property, qsizetype index) {
+	return static_cast<PwNodeLinkTracker*>(property->object)->mLinkGroups.at(index); // NOLINT
+}
+
+void PwNodeLinkTracker::onNodeDestroyed() {
+	this->mNode = nullptr;
+	QObject::disconnect(&PwConnection::instance()->registry, nullptr, this, nullptr);
+
+	this->updateLinks();
+	emit this->nodeChanged();
+}
+
+void PwNodeLinkTracker::onLinkGroupCreated(PwLinkGroup* linkGroup) {
+	if ((!this->mNode->isSink() && linkGroup->outputNode() == this->mNode->id())
+	    || (this->mNode->isSink() && linkGroup->inputNode() == this->mNode->id()))
+	{
+		auto* iface = PwLinkGroupIface::instance(linkGroup);
+		QObject::connect(iface, &QObject::destroyed, this, &PwNodeLinkTracker::onLinkGroupDestroyed);
+		this->mLinkGroups.push_back(iface);
+		emit this->linkGroupsChanged();
+	}
+}
+
+void PwNodeLinkTracker::onLinkGroupDestroyed(QObject* object) {
+	if (this->mLinkGroups.removeOne(object)) {
+		emit this->linkGroupsChanged();
+	}
+}
+
+PwNodeAudioIface::PwNodeAudioIface(PwNodeBoundAudio* boundData, QObject* parent)
+    : QObject(parent)
+    , boundData(boundData) {
+	// clang-format off
+	QObject::connect(boundData, &PwNodeBoundAudio::mutedChanged, this, &PwNodeAudioIface::mutedChanged);
+	QObject::connect(boundData, &PwNodeBoundAudio::channelsChanged, this, &PwNodeAudioIface::channelsChanged);
+	QObject::connect(boundData, &PwNodeBoundAudio::volumesChanged, this, &PwNodeAudioIface::volumesChanged);
+	// clang-format on
+}
+
+bool PwNodeAudioIface::isMuted() const { return this->boundData->isMuted(); }
+
+void PwNodeAudioIface::setMuted(bool muted) { this->boundData->setMuted(muted); }
+
+float PwNodeAudioIface::averageVolume() const { return this->boundData->averageVolume(); }
+
+void PwNodeAudioIface::setAverageVolume(float volume) { this->boundData->setAverageVolume(volume); }
+
+QVector<PwAudioChannel::Enum> PwNodeAudioIface::channels() const {
+	return this->boundData->channels();
+}
+
+QVector<float> PwNodeAudioIface::volumes() const { return this->boundData->volumes(); }
+
+void PwNodeAudioIface::setVolumes(const QVector<float>& volumes) {
+	this->boundData->setVolumes(volumes);
+}
+
+PwNodeIface::PwNodeIface(PwNode* node): PwObjectIface(node), mNode(node) {
+	QObject::connect(node, &PwNode::propertiesChanged, this, &PwNodeIface::propertiesChanged);
+	QObject::connect(node, &PwNode::readyChanged, this, &PwNodeIface::readyChanged);
+
+	if (auto* audioBoundData = dynamic_cast<PwNodeBoundAudio*>(node->boundData)) {
+		this->audioIface = new PwNodeAudioIface(audioBoundData, this);
+	}
+}
+
+PwNode* PwNodeIface::node() const { return this->mNode; }
+
+QString PwNodeIface::name() const { return this->mNode->name; }
+
+quint32 PwNodeIface::id() const { return this->mNode->id; }
+
+QString PwNodeIface::description() const { return this->mNode->description; }
+
+QString PwNodeIface::nickname() const { return this->mNode->nick; }
+
+bool PwNodeIface::isSink() const { return this->mNode->type.testFlags(PwNodeType::Sink); }
+
+bool PwNodeIface::isStream() const { return this->mNode->type.testFlags(PwNodeType::Stream); }
+
+bool PwNodeIface::isReady() const { return this->mNode->ready; }
+
+PwNodeType::Flags PwNodeIface::type() const { return this->mNode->type; };
+
+QVariantMap PwNodeIface::properties() const {
+	auto map = QVariantMap();
+	for (auto [k, v]: this->mNode->properties.asKeyValueRange()) {
+		map.insert(k, QVariant::fromValue(v));
+	}
+
+	return map;
+}
+
+PwNodeAudioIface* PwNodeIface::audio() const { return this->audioIface; }
+
+PwNodeIface* PwNodeIface::instance(PwNode* node) {
+	if (node == nullptr) return nullptr;
+
+	auto v = node->property("iface");
+	if (v.canConvert<PwNodeIface*>()) {
+		return v.value<PwNodeIface*>();
+	}
+
+	auto* instance = new PwNodeIface(node);
+	node->setProperty("iface", QVariant::fromValue(instance));
+
+	return instance;
+}
+
+PwLinkIface::PwLinkIface(PwLink* link): PwObjectIface(link), mLink(link) {
+	QObject::connect(link, &PwLink::stateChanged, this, &PwLinkIface::stateChanged);
+}
+
+PwLink* PwLinkIface::link() const { return this->mLink; }
+
+quint32 PwLinkIface::id() const { return this->mLink->id; }
+
+PwNodeIface* PwLinkIface::target() const {
+	return PwNodeIface::instance(
+	    PwConnection::instance()->registry.nodes.value(this->mLink->inputNode())
+	);
+}
+
+PwNodeIface* PwLinkIface::source() const {
+	return PwNodeIface::instance(
+	    PwConnection::instance()->registry.nodes.value(this->mLink->outputNode())
+	);
+}
+
+PwLinkState::Enum PwLinkIface::state() const { return this->mLink->state(); }
+
+PwLinkIface* PwLinkIface::instance(PwLink* link) {
+	auto v = link->property("iface");
+	if (v.canConvert<PwLinkIface*>()) {
+		return v.value<PwLinkIface*>();
+	}
+
+	auto* instance = new PwLinkIface(link);
+	link->setProperty("iface", QVariant::fromValue(instance));
+
+	return instance;
+}
+
+PwLinkGroupIface::PwLinkGroupIface(PwLinkGroup* group): QObject(group), mGroup(group) {
+	QObject::connect(group, &PwLinkGroup::stateChanged, this, &PwLinkGroupIface::stateChanged);
+}
+
+void PwLinkGroupIface::ref() { this->mGroup->ref(); }
+
+void PwLinkGroupIface::unref() { this->mGroup->unref(); }
+
+PwLinkGroup* PwLinkGroupIface::group() const { return this->mGroup; }
+
+PwNodeIface* PwLinkGroupIface::target() const {
+	return PwNodeIface::instance(
+	    PwConnection::instance()->registry.nodes.value(this->mGroup->inputNode())
+	);
+}
+
+PwNodeIface* PwLinkGroupIface::source() const {
+	return PwNodeIface::instance(
+	    PwConnection::instance()->registry.nodes.value(this->mGroup->outputNode())
+	);
+}
+
+PwLinkState::Enum PwLinkGroupIface::state() const { return this->mGroup->state(); }
+
+PwLinkGroupIface* PwLinkGroupIface::instance(PwLinkGroup* group) {
+	auto v = group->property("iface");
+	if (v.canConvert<PwLinkGroupIface*>()) {
+		return v.value<PwLinkGroupIface*>();
+	}
+
+	auto* instance = new PwLinkGroupIface(group);
+	group->setProperty("iface", QVariant::fromValue(instance));
+
+	return instance;
+}
+
+PwObjectTracker::~PwObjectTracker() { this->clearList(); }
+
+QList<QObject*> PwObjectTracker::objects() const { return this->trackedObjects; }
+
+void PwObjectTracker::setObjects(const QList<QObject*>& objects) {
+	// +1 ref before removing old refs to avoid an unbind->bind.
+	for (auto* object: objects) {
+		if (auto* pwObject = dynamic_cast<PwObjectRefIface*>(object)) {
+			pwObject->ref();
+		}
+	}
+
+	this->clearList();
+
+	// connect destroy
+	for (auto* object: objects) {
+		if (dynamic_cast<PwObjectRefIface*>(object) != nullptr) {
+			QObject::connect(object, &QObject::destroyed, this, &PwObjectTracker::objectDestroyed);
+		}
+	}
+
+	this->trackedObjects = objects;
+}
+
+void PwObjectTracker::clearList() {
+	for (auto* object: this->trackedObjects) {
+		if (auto* pwObject = dynamic_cast<PwObjectRefIface*>(object)) {
+			pwObject->unref();
+			QObject::disconnect(object, nullptr, this, nullptr);
+		}
+	}
+
+	this->trackedObjects.clear();
+}
+
+void PwObjectTracker::objectDestroyed(QObject* object) {
+	this->trackedObjects.removeOne(object);
+	emit this->objectsChanged();
+}
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/qml.hpp b/src/services/pipewire/qml.hpp
new file mode 100644
index 00000000..e3489a1c
--- /dev/null
+++ b/src/services/pipewire/qml.hpp
@@ -0,0 +1,463 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qqmllist.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/doc.hpp"
+#include "../../core/model.hpp"
+#include "link.hpp"
+#include "node.hpp"
+#include "registry.hpp"
+
+namespace qs::service::pipewire {
+
+class PwNodeIface;
+class PwLinkIface;
+class PwLinkGroupIface;
+
+class PwObjectRefIface {
+public:
+	PwObjectRefIface() = default;
+	virtual ~PwObjectRefIface() = default;
+	Q_DISABLE_COPY_MOVE(PwObjectRefIface);
+
+	virtual void ref() = 0;
+	virtual void unref() = 0;
+};
+
+class PwObjectIface
+    : public QObject
+    , public PwObjectRefIface {
+	Q_OBJECT;
+
+public:
+	explicit PwObjectIface(PwBindableObject* object);
+	// destructor should ONLY be called by the pw object destructor, making an unref unnecessary
+	~PwObjectIface() override = default;
+	Q_DISABLE_COPY_MOVE(PwObjectIface);
+
+	void ref() override;
+	void unref() override;
+
+private slots:
+	void onObjectDestroying();
+
+private:
+	quint32 refcount = 0;
+	PwBindableObject* object;
+};
+
+///! Contains links to all pipewire objects.
+class Pipewire: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// All nodes present in pipewire.
+	///
+	/// This list contains every node on the system.
+	/// To find a useful subset, filtering with the following properties may be helpful:
+	/// - @@PwNode.isStream - if the node is an application or hardware device.
+	/// - @@PwNode.isSink - if the node is a sink or source.
+	/// - @@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);
+	/// All links present in pipewire.
+	///
+	/// Links connect pipewire nodes to each other, and can be used to determine
+	/// their relationship.
+	///
+	/// If you already have a node you want to check for connections to,
+	/// use @@PwNodeLinkTracker instead of filtering this list.
+	///
+	/// > [!INFO] Multiple links may exist between the same nodes. See @@linkGroups
+	/// > for a deduplicated list containing only one entry per link between nodes.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::service::pipewire::PwLinkIface>*);
+	Q_PROPERTY(UntypedObjectModel* links READ links CONSTANT);
+	/// All link groups present in pipewire.
+	///
+	/// The same as @@links but deduplicated.
+	///
+	/// If you already have a node you want to check for connections to,
+	/// use @@PwNodeLinkTracker instead of filtering this list.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::service::pipewire::PwLinkGroupIface>*);
+	Q_PROPERTY(UntypedObjectModel* linkGroups READ linkGroups CONSTANT);
+	/// The default audio sink (output) or `null`.
+	///
+	/// This is the default sink currently in use by pipewire, and the one applications
+	/// are currently using.
+	///
+	/// To set the default sink, use @@preferredDefaultAudioSink.
+	///
+	/// > [!INFO] When the default sink changes, this property may breifly become null.
+	/// > This depends on your hardware.
+	Q_PROPERTY(qs::service::pipewire::PwNodeIface* defaultAudioSink READ defaultAudioSink NOTIFY defaultAudioSinkChanged);
+	/// The default audio source (input) or `null`.
+	///
+	/// This is the default source currently in use by pipewire, and the one applications
+	/// are currently using.
+	///
+	/// To set the default source, use @@preferredDefaultAudioSource.
+	///
+	/// > [!INFO] When the default source changes, this property may breifly become null.
+	/// > This depends on your hardware.
+	Q_PROPERTY(qs::service::pipewire::PwNodeIface* defaultAudioSource READ defaultAudioSource NOTIFY defaultAudioSourceChanged);
+	/// The preferred default audio sink (output) or `null`.
+	///
+	/// This is a hint to pipewire telling it which sink should be the default when possible.
+	/// @@defaultAudioSink may differ when it is not possible for pipewire to pick this node.
+	///
+	/// See @@defaultAudioSink for the current default sink, regardless of preference.
+	Q_PROPERTY(qs::service::pipewire::PwNodeIface* preferredDefaultAudioSink READ defaultConfiguredAudioSink WRITE setDefaultConfiguredAudioSink NOTIFY defaultConfiguredAudioSinkChanged);
+	/// The preferred default audio source (input) or `null`.
+	///
+	/// This is a hint to pipewire telling it which source should be the default when possible.
+	/// @@defaultAudioSource may differ when it is not possible for pipewire to pick this node.
+	///
+	/// See @@defaultAudioSource for the current default source, regardless of preference.
+	Q_PROPERTY(qs::service::pipewire::PwNodeIface* preferredDefaultAudioSource READ defaultConfiguredAudioSource WRITE setDefaultConfiguredAudioSource NOTIFY defaultConfiguredAudioSourceChanged);
+	/// This property is true if quickshell has completed its initial sync with
+	/// the pipewire server. If true, nodes, links and sync/source preferences will be
+	/// in a good state.
+	///
+	/// > [!NOTE] You can use the pipewire object before it is ready, but some nodes/links
+	/// > may be missing, and preference metadata may be null.
+	Q_PROPERTY(bool ready READ isReady NOTIFY readyChanged);
+	// clang-format on
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	explicit Pipewire(QObject* parent = nullptr);
+
+	[[nodiscard]] ObjectModel<PwNodeIface>* nodes();
+	[[nodiscard]] ObjectModel<PwLinkIface>* links();
+	[[nodiscard]] ObjectModel<PwLinkGroupIface>* linkGroups();
+
+	[[nodiscard]] PwNodeIface* defaultAudioSink() const;
+	[[nodiscard]] PwNodeIface* defaultAudioSource() const;
+
+	[[nodiscard]] PwNodeIface* defaultConfiguredAudioSink() const;
+	static void setDefaultConfiguredAudioSink(PwNodeIface* node);
+
+	[[nodiscard]] PwNodeIface* defaultConfiguredAudioSource() const;
+	static void setDefaultConfiguredAudioSource(PwNodeIface* node);
+
+	[[nodiscard]] static bool isReady();
+
+signals:
+	void defaultAudioSinkChanged();
+	void defaultAudioSourceChanged();
+
+	void defaultConfiguredAudioSinkChanged();
+	void defaultConfiguredAudioSourceChanged();
+
+	void readyChanged();
+
+private slots:
+	void onNodeAdded(PwNode* node);
+	void onNodeRemoved(QObject* object);
+	void onLinkAdded(PwLink* link);
+	void onLinkRemoved(QObject* object);
+	void onLinkGroupAdded(PwLinkGroup* group);
+	void onLinkGroupRemoved(QObject* object);
+
+private:
+	ObjectModel<PwNodeIface> mNodes {this};
+	ObjectModel<PwLinkIface> mLinks {this};
+	ObjectModel<PwLinkGroupIface> mLinkGroups {this};
+};
+
+///! Tracks all link connections to a given node.
+class PwNodeLinkTracker: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// The node to track connections to.
+	Q_PROPERTY(qs::service::pipewire::PwNodeIface* node READ node WRITE setNode NOTIFY nodeChanged);
+	/// Link groups connected to the given node.
+	///
+	/// If the node is a sink, links which target the node will be tracked.
+	/// If the node is a source, links which source the node will be tracked.
+	Q_PROPERTY(QQmlListProperty<qs::service::pipewire::PwLinkGroupIface> linkGroups READ linkGroups NOTIFY linkGroupsChanged);
+	// clang-format on
+	QML_ELEMENT;
+
+public:
+	explicit PwNodeLinkTracker(QObject* parent = nullptr): QObject(parent) {}
+
+	[[nodiscard]] PwNodeIface* node() const;
+	void setNode(PwNodeIface* node);
+
+	[[nodiscard]] QQmlListProperty<PwLinkGroupIface> linkGroups();
+
+signals:
+	void nodeChanged();
+	void linkGroupsChanged();
+
+private slots:
+	void onNodeDestroyed();
+	void onLinkGroupCreated(PwLinkGroup* linkGroup);
+	void onLinkGroupDestroyed(QObject* object);
+
+private:
+	static qsizetype linkGroupsCount(QQmlListProperty<PwLinkGroupIface>* property);
+	static PwLinkGroupIface*
+	linkGroupAt(QQmlListProperty<PwLinkGroupIface>* property, qsizetype index);
+
+	void updateLinks();
+
+	PwNodeIface* mNode = nullptr;
+	QVector<PwLinkGroupIface*> mLinkGroups;
+};
+
+///! Audio specific properties of pipewire nodes.
+/// Extra properties of a @@PwNode if the node is an audio node.
+///
+/// See @@PwNode.audio.
+class PwNodeAudioIface: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// If the node is currently muted. Setting this property changes the mute state.
+	///
+	/// > [!WARNING] This property is invalid unless the node is bound using @@PwObjectTracker.
+	Q_PROPERTY(bool muted READ isMuted WRITE setMuted NOTIFY mutedChanged);
+	/// The average volume over all channels of the node.
+	/// Setting this property modifies the volume of all channels proportionately.
+	///
+	/// > [!WARNING] This property is invalid unless the node is bound using @@PwObjectTracker.
+	Q_PROPERTY(float volume READ averageVolume WRITE setAverageVolume NOTIFY volumesChanged);
+	/// The audio channels present on the node.
+	///
+	/// > [!WARNING] This property is invalid unless the node is bound using @@PwObjectTracker.
+	Q_PROPERTY(QVector<qs::service::pipewire::PwAudioChannel::Enum> channels READ channels NOTIFY channelsChanged);
+	/// The volumes of each audio channel individually. Each entry corrosponds to
+	/// the volume of the channel at the same index in @@channels. @@volumes and @@channels
+	/// will always be the same length.
+	///
+	/// > [!WARNING] This property is invalid unless the node is bound using @@PwObjectTracker.
+	Q_PROPERTY(QVector<float> volumes READ volumes WRITE setVolumes NOTIFY volumesChanged);
+	// clang-format on
+	QML_NAMED_ELEMENT(PwNodeAudio);
+	QML_UNCREATABLE("PwNodeAudio cannot be created directly");
+
+public:
+	explicit PwNodeAudioIface(PwNodeBoundAudio* boundData, QObject* parent);
+
+	[[nodiscard]] bool isMuted() const;
+	void setMuted(bool muted);
+
+	[[nodiscard]] float averageVolume() const;
+	void setAverageVolume(float volume);
+
+	[[nodiscard]] QVector<PwAudioChannel::Enum> channels() const;
+
+	[[nodiscard]] QVector<float> volumes() const;
+	void setVolumes(const QVector<float>& volumes);
+
+signals:
+	void mutedChanged();
+	void channelsChanged();
+	void volumesChanged();
+
+private:
+	PwNodeBoundAudio* boundData;
+};
+
+///! A node in the pipewire connection graph.
+class PwNodeIface: public PwObjectIface {
+	Q_OBJECT;
+	/// The pipewire object id of the node.
+	///
+	/// Mainly useful for debugging. You can inspect the node directly
+	/// with `pw-cli i <id>`.
+	Q_PROPERTY(quint32 id READ id CONSTANT);
+	/// The node's name, corrosponding to the object's `node.name` property.
+	Q_PROPERTY(QString name READ name CONSTANT);
+	/// The node's description, corrosponding to the object's `node.description` property.
+	///
+	/// May be empty. Generally more human readable than @@name.
+	Q_PROPERTY(QString description READ description CONSTANT);
+	/// The node's nickname, corrosponding to the object's `node.nickname` property.
+	///
+	/// May be empty. Generally but not always more human readable than @@description.
+	Q_PROPERTY(QString nickname READ nickname CONSTANT);
+	/// If `true`, then the node accepts audio input from other nodes,
+	/// if `false` the node outputs audio to other nodes.
+	Q_PROPERTY(bool isSink READ isSink CONSTANT);
+	/// If `true` then the node is likely to be a program, if `false` it is likely to be
+	/// a hardware device.
+	Q_PROPERTY(bool isStream READ isStream CONSTANT);
+	/// The type of this node. Reflects Pipewire's [media.class](https://docs.pipewire.org/page_man_pipewire-props_7.html).
+	Q_PROPERTY(qs::service::pipewire::PwNodeType::Flags type READ type CONSTANT);
+	/// The property set present on the node, as an object containing key-value pairs.
+	/// You can inspect this directly with `pw-cli i <id>`.
+	///
+	/// A few properties of note, which may or may not be present:
+	/// - `application.name` - A suggested human readable name for the node.
+	/// - `application.icon-name` - The name of an icon recommended to display for the node.
+	/// - `media.name` - A description of the currently playing media.
+	///   (more likely to be present than `media.title` and `media.artist`)
+	/// - `media.title` - The title of the currently playing media.
+	/// - `media.artist` - The artist of the currently playing media.
+	///
+	/// > [!WARNING] This property is invalid unless the node is bound using @@PwObjectTracker.
+	Q_PROPERTY(QVariantMap properties READ properties NOTIFY propertiesChanged);
+	/// Extra information present only if the node sends or receives audio.
+	///
+	/// The presence or absence of this property can be used to determine if a node
+	/// manages audio, regardless of if it is bound. If non null, the node is an audio node.
+	Q_PROPERTY(qs::service::pipewire::PwNodeAudioIface* audio READ audio CONSTANT);
+	/// True if the node is fully bound and ready to use.
+	///
+	/// > [!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);
+	QML_NAMED_ELEMENT(PwNode);
+	QML_UNCREATABLE("PwNodes cannot be created directly");
+
+public:
+	explicit PwNodeIface(PwNode* node);
+
+	[[nodiscard]] PwNode* node() const;
+	[[nodiscard]] quint32 id() const;
+	[[nodiscard]] QString name() const;
+	[[nodiscard]] QString description() const;
+	[[nodiscard]] QString nickname() const;
+	[[nodiscard]] bool isSink() const;
+	[[nodiscard]] bool isStream() const;
+	[[nodiscard]] bool isReady() const;
+	[[nodiscard]] PwNodeType::Flags type() const;
+	[[nodiscard]] QVariantMap properties() const;
+	[[nodiscard]] PwNodeAudioIface* audio() const;
+
+	static PwNodeIface* instance(PwNode* node);
+
+signals:
+	void propertiesChanged();
+	void readyChanged();
+
+private:
+	PwNode* mNode;
+	PwNodeAudioIface* audioIface = nullptr;
+};
+
+///! A connection between pipewire nodes.
+/// Note that there is one link per *channel* of a connection between nodes.
+/// You usually want @@PwLinkGroup.
+class PwLinkIface: public PwObjectIface {
+	Q_OBJECT;
+	/// The pipewire object id of the link.
+	///
+	/// Mainly useful for debugging. you can inspect the link directly
+	/// with `pw-cli i <id>`.
+	Q_PROPERTY(quint32 id READ id CONSTANT);
+	/// The node that is *receiving* information. (the sink)
+	Q_PROPERTY(qs::service::pipewire::PwNodeIface* target READ target CONSTANT);
+	/// The node that is *sending* information. (the source)
+	Q_PROPERTY(qs::service::pipewire::PwNodeIface* source READ source CONSTANT);
+	/// The current state of the link.
+	///
+	/// > [!WARNING] This property is invalid unless the node is bound using @@PwObjectTracker.
+	Q_PROPERTY(PwLinkState::Enum state READ state NOTIFY stateChanged);
+	QML_NAMED_ELEMENT(PwLink);
+	QML_UNCREATABLE("PwLinks cannot be created directly");
+
+public:
+	explicit PwLinkIface(PwLink* link);
+
+	[[nodiscard]] PwLink* link() const;
+	[[nodiscard]] quint32 id() const;
+	[[nodiscard]] PwNodeIface* target() const;
+	[[nodiscard]] PwNodeIface* source() const;
+	[[nodiscard]] PwLinkState::Enum state() const;
+
+	static PwLinkIface* instance(PwLink* link);
+
+signals:
+	void stateChanged();
+
+private:
+	PwLink* mLink;
+};
+
+///! A group of connections between pipewire nodes.
+/// A group of connections between pipewire nodes, one per source->target pair.
+class PwLinkGroupIface
+    : public QObject
+    , public PwObjectRefIface {
+	Q_OBJECT;
+	/// The node that is *receiving* information. (the sink)
+	Q_PROPERTY(qs::service::pipewire::PwNodeIface* target READ target CONSTANT);
+	/// The node that is *sending* information. (the source)
+	Q_PROPERTY(qs::service::pipewire::PwNodeIface* source READ source CONSTANT);
+	/// The current state of the link group.
+	///
+	/// > [!WARNING] This property is invalid unless the node is bound using @@PwObjectTracker.
+	Q_PROPERTY(qs::service::pipewire::PwLinkState::Enum state READ state NOTIFY stateChanged);
+	QML_NAMED_ELEMENT(PwLinkGroup);
+	QML_UNCREATABLE("PwLinkGroups cannot be created directly");
+
+public:
+	explicit PwLinkGroupIface(PwLinkGroup* group);
+	// destructor should ONLY be called by the pw object destructor, making an unref unnecessary
+	~PwLinkGroupIface() override = default;
+	Q_DISABLE_COPY_MOVE(PwLinkGroupIface);
+
+	void ref() override;
+	void unref() override;
+
+	[[nodiscard]] PwLinkGroup* group() const;
+	[[nodiscard]] PwNodeIface* target() const;
+	[[nodiscard]] PwNodeIface* source() const;
+	[[nodiscard]] PwLinkState::Enum state() const;
+
+	static PwLinkGroupIface* instance(PwLinkGroup* group);
+
+signals:
+	void stateChanged();
+
+private:
+	PwLinkGroup* mGroup;
+};
+
+///! Binds pipewire objects.
+/// PwObjectTracker binds every node given in its @@objects list.
+///
+/// #### Object Binding
+/// By default, pipewire objects are unbound. Unbound objects only have a subset of
+/// information available for use or modification. **Binding an object makes all of its
+/// properties available for use or modification if applicable.**
+///
+/// Properties that require their object be bound to use are clearly marked. You do not
+/// need to bind the object unless mentioned in the description of the property you
+/// want to use.
+class PwObjectTracker: public QObject {
+	Q_OBJECT;
+	/// The list of objects to bind. May contain nulls.
+	Q_PROPERTY(QList<QObject*> objects READ objects WRITE setObjects NOTIFY objectsChanged);
+	QML_ELEMENT;
+
+public:
+	explicit PwObjectTracker(QObject* parent = nullptr): QObject(parent) {}
+	~PwObjectTracker() override;
+	Q_DISABLE_COPY_MOVE(PwObjectTracker);
+
+	[[nodiscard]] QList<QObject*> objects() const;
+	void setObjects(const QList<QObject*>& objects);
+
+signals:
+	void objectsChanged();
+
+private slots:
+	void objectDestroyed(QObject* object);
+
+private:
+	void clearList();
+
+	QList<QObject*> trackedObjects;
+};
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/registry.cpp b/src/services/pipewire/registry.cpp
new file mode 100644
index 00000000..c08fc1d9
--- /dev/null
+++ b/src/services/pipewire/registry.cpp
@@ -0,0 +1,243 @@
+#include "registry.hpp"
+#include <cstring>
+
+#include <pipewire/core.h>
+#include <pipewire/device.h>
+#include <pipewire/extensions/metadata.h>
+#include <pipewire/link.h>
+#include <pipewire/node.h>
+#include <pipewire/proxy.h>
+#include <qdebug.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qstringview.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/logcat.hpp"
+#include "core.hpp"
+#include "device.hpp"
+#include "link.hpp"
+#include "metadata.hpp"
+#include "node.hpp"
+
+namespace qs::service::pipewire {
+
+QS_LOGGING_CATEGORY(logRegistry, "quickshell.service.pipewire.registry", QtWarningMsg);
+
+PwBindableObject::~PwBindableObject() {
+	if (this->id != 0) {
+		qCFatal(logRegistry) << "Destroyed pipewire object" << this
+		                     << "without causing safeDestroy. THIS IS UNDEFINED BEHAVIOR.";
+	}
+}
+
+void PwBindableObject::init(PwRegistry* registry, quint32 id, quint32 perms) {
+	this->id = id;
+	this->perms = perms;
+	this->registry = registry;
+	this->setParent(registry);
+	qCDebug(logRegistry) << "Creating object" << this;
+}
+
+void PwBindableObject::safeDestroy() {
+	this->unbind();
+	qCDebug(logRegistry) << "Destroying object" << this;
+	emit this->destroying(this);
+	this->id = 0;
+	delete this;
+}
+
+void PwBindableObject::debugId(QDebug& debug) const {
+	auto saver = QDebugStateSaver(debug);
+	debug.nospace() << this->id << "/" << (this->object == nullptr ? "unbound" : "bound");
+}
+
+void PwBindableObject::ref() {
+	this->refcount++;
+	if (this->refcount == 1) this->bind();
+}
+
+void PwBindableObject::unref() {
+	this->refcount--;
+	if (this->refcount == 0) this->unbind();
+}
+
+void PwBindableObject::registryBind(const char* interface, quint32 version) {
+	// NOLINTNEXTLINE
+	auto* object = pw_registry_bind(this->registry->object, this->id, interface, version, 0);
+	this->object = static_cast<pw_proxy*>(object);
+}
+
+void PwBindableObject::bind() {
+	qCDebug(logRegistry) << "Bound object" << this;
+	this->bindHooks();
+}
+
+void PwBindableObject::unbind() {
+	if (this->object == nullptr) return;
+	qCDebug(logRegistry) << "Unbinding object" << this;
+	this->unbindHooks();
+	pw_proxy_destroy(this->object);
+	this->object = nullptr;
+}
+
+QDebug operator<<(QDebug debug, const PwBindableObject* object) {
+	if (object == nullptr) {
+		debug << "PwBindableObject(0x0)";
+	} else {
+		auto saver = QDebugStateSaver(debug);
+		// 0 if not present, start of class name if present
+		auto idx = QString(object->metaObject()->className()).lastIndexOf(':') + 1;
+		debug.nospace() << (object->metaObject()->className() + idx) << '(' // NOLINT
+		                << static_cast<const void*>(object) << ", id=";
+		object->debugId(debug);
+		debug << ')';
+	}
+
+	return debug;
+}
+
+PwBindableObjectRef::PwBindableObjectRef(PwBindableObject* object) { this->setObject(object); }
+
+PwBindableObjectRef::~PwBindableObjectRef() { this->setObject(nullptr); }
+
+void PwBindableObjectRef::setObject(PwBindableObject* object) {
+	if (this->mObject != nullptr) {
+		this->mObject->unref();
+		QObject::disconnect(this->mObject, nullptr, this, nullptr);
+	}
+
+	this->mObject = object;
+
+	if (object != nullptr) {
+		this->mObject->ref();
+		QObject::connect(object, &QObject::destroyed, this, &PwBindableObjectRef::onObjectDestroyed);
+	}
+}
+
+void PwBindableObjectRef::onObjectDestroyed() {
+	// allow references to it so consumers can disconnect themselves
+	emit this->objectDestroyed();
+	this->mObject = nullptr;
+}
+
+void PwRegistry::init(PwCore& core) {
+	this->core = &core;
+	this->object = pw_core_get_registry(core.core, PW_VERSION_REGISTRY, 0);
+	pw_registry_add_listener(this->object, &this->listener.hook, &PwRegistry::EVENTS, this);
+
+	QObject::connect(this->core, &PwCore::synced, this, &PwRegistry::onCoreSync);
+
+	qCDebug(logRegistry) << "Registry created. Sending core sync for initial object tracking.";
+	this->coreSyncSeq = this->core->sync(PW_ID_CORE);
+}
+
+void PwRegistry::onCoreSync(quint32 id, qint32 seq) {
+	if (id != PW_ID_CORE || seq != this->coreSyncSeq) return;
+
+	switch (this->initState) {
+	case InitState::SendingObjects:
+		qCDebug(logRegistry) << "Initial sync for objects received. Syncing for metadata binding.";
+		this->coreSyncSeq = this->core->sync(PW_ID_CORE);
+		this->initState = InitState::Binding;
+		break;
+	case InitState::Binding:
+		qCInfo(logRegistry) << "Initial state sync complete.";
+		this->initState = InitState::Done;
+		emit this->initialized();
+		break;
+	default: break;
+	}
+}
+
+const pw_registry_events PwRegistry::EVENTS = {
+    .version = PW_VERSION_REGISTRY_EVENTS,
+    .global = &PwRegistry::onGlobal,
+    .global_remove = &PwRegistry::onGlobalRemoved,
+};
+
+void PwRegistry::onGlobal(
+    void* data,
+    quint32 id,
+    quint32 permissions,
+    const char* type,
+    quint32 /*version*/,
+    const spa_dict* props
+) {
+	auto* self = static_cast<PwRegistry*>(data);
+
+	if (strcmp(type, PW_TYPE_INTERFACE_Metadata) == 0) {
+		auto* meta = new PwMetadata();
+		meta->init(self, id, permissions);
+		meta->initProps(props);
+
+		self->metadata.emplace(id, meta);
+		emit self->metadataAdded(meta);
+	} else if (strcmp(type, PW_TYPE_INTERFACE_Link) == 0) {
+		auto* link = new PwLink();
+		link->init(self, id, permissions);
+		link->initProps(props);
+
+		self->links.emplace(id, link);
+		self->addLinkToGroup(link);
+		emit self->linkAdded(link);
+	} else if (strcmp(type, PW_TYPE_INTERFACE_Node) == 0) {
+		auto* node = new PwNode();
+		node->init(self, id, permissions);
+		node->initProps(props);
+
+		self->nodes.emplace(id, node);
+		emit self->nodeAdded(node);
+	} else if (strcmp(type, PW_TYPE_INTERFACE_Device) == 0) {
+		auto* device = new PwDevice();
+		device->init(self, id, permissions);
+		device->initProps(props);
+
+		self->devices.emplace(id, device);
+	}
+}
+
+void PwRegistry::onGlobalRemoved(void* data, quint32 id) {
+	auto* self = static_cast<PwRegistry*>(data);
+
+	if (auto* meta = self->metadata.value(id)) {
+		self->metadata.remove(id);
+		meta->safeDestroy();
+	} else if (auto* link = self->links.value(id)) {
+		self->links.remove(id);
+		link->safeDestroy();
+	} else if (auto* node = self->nodes.value(id)) {
+		self->nodes.remove(id);
+		node->safeDestroy();
+	}
+}
+
+void PwRegistry::addLinkToGroup(PwLink* link) {
+	for (auto* group: this->linkGroups) {
+		if (group->tryAddLink(link)) return;
+	}
+
+	auto* group = new PwLinkGroup(link);
+	QObject::connect(group, &QObject::destroyed, this, &PwRegistry::onLinkGroupDestroyed);
+	this->linkGroups.push_back(group);
+	emit this->linkGroupAdded(group);
+}
+
+void PwRegistry::onLinkGroupDestroyed(QObject* object) {
+	auto* group = static_cast<PwLinkGroup*>(object); // NOLINT
+	this->linkGroups.removeOne(group);
+}
+
+PwNode* PwRegistry::findNodeByName(QStringView name) const {
+	if (name.isEmpty()) return nullptr;
+
+	for (auto* node: this->nodes.values()) {
+		if (node->name == name) return node;
+	}
+
+	return nullptr;
+}
+
+} // namespace qs::service::pipewire
diff --git a/src/services/pipewire/registry.hpp b/src/services/pipewire/registry.hpp
new file mode 100644
index 00000000..8473f041
--- /dev/null
+++ b/src/services/pipewire/registry.hpp
@@ -0,0 +1,170 @@
+#pragma once
+
+#include <pipewire/core.h>
+#include <pipewire/proxy.h>
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qhash.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qstringview.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/logcat.hpp"
+#include "../../core/util.hpp"
+#include "core.hpp"
+
+namespace qs::service::pipewire {
+
+QS_DECLARE_LOGGING_CATEGORY(logRegistry);
+
+class PwRegistry;
+class PwMetadata;
+class PwNode;
+class PwLink;
+class PwDevice;
+class PwLinkGroup;
+
+class PwBindableObject: public QObject {
+	Q_OBJECT;
+
+public:
+	PwBindableObject() = default;
+	~PwBindableObject() override;
+	Q_DISABLE_COPY_MOVE(PwBindableObject);
+
+	// constructors and destructors can't do virtual calls.
+	virtual void init(PwRegistry* registry, quint32 id, quint32 perms);
+	virtual void initProps(const spa_dict* /*props*/) {}
+	virtual void safeDestroy();
+
+	quint32 id = 0;
+	quint32 perms = 0;
+
+	void debugId(QDebug& debug) const;
+	void ref();
+	void unref();
+
+signals:
+	// goes with safeDestroy
+	void destroying(PwBindableObject* self);
+
+protected:
+	void registryBind(const char* interface, quint32 version);
+	virtual void bind();
+	void unbind();
+	virtual void bindHooks() {}
+	virtual void unbindHooks() {}
+
+	quint32 refcount = 0;
+	pw_proxy* object = nullptr;
+	PwRegistry* registry = nullptr;
+};
+
+QDebug operator<<(QDebug debug, const PwBindableObject* object);
+
+template <typename T, StringLiteral INTERFACE, quint32 VERSION>
+class PwBindable: public PwBindableObject {
+public:
+	T* proxy() { return reinterpret_cast<T*>(this->object); }
+
+protected:
+	void bind() override {
+		if (this->object != nullptr) return;
+		this->registryBind(INTERFACE, VERSION);
+		this->PwBindableObject::bind();
+	}
+
+	friend class PwRegistry;
+};
+
+class PwBindableObjectRef: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit PwBindableObjectRef(PwBindableObject* object = nullptr);
+	~PwBindableObjectRef() override;
+	Q_DISABLE_COPY_MOVE(PwBindableObjectRef);
+
+signals:
+	void objectDestroyed();
+
+private slots:
+	void onObjectDestroyed();
+
+protected:
+	void setObject(PwBindableObject* object);
+
+	PwBindableObject* mObject = nullptr;
+};
+
+template <typename T>
+class PwBindableRef: public PwBindableObjectRef {
+public:
+	explicit PwBindableRef(T* object = nullptr): PwBindableObjectRef(object) {}
+
+	T* object() { return static_cast<T*>(this->mObject); }
+	void setObject(T* object) { this->PwBindableObjectRef::setObject(object); }
+};
+
+class PwRegistry
+    : public QObject
+    , public PwObject<pw_registry> {
+	Q_OBJECT;
+
+public:
+	void init(PwCore& core);
+
+	[[nodiscard]] bool isInitialized() const { return this->initState == InitState::Done; }
+
+	//QHash<quint32, PwClient*> clients;
+	QHash<quint32, PwMetadata*> metadata;
+	QHash<quint32, PwNode*> nodes;
+	QHash<quint32, PwDevice*> devices;
+	QHash<quint32, PwLink*> links;
+	QVector<PwLinkGroup*> linkGroups;
+
+	PwCore* core = nullptr;
+
+	[[nodiscard]] PwNode* findNodeByName(QStringView name) const;
+
+signals:
+	void nodeAdded(PwNode* node);
+	void linkAdded(PwLink* link);
+	void linkGroupAdded(PwLinkGroup* group);
+	void metadataAdded(PwMetadata* metadata);
+	void initialized();
+
+private slots:
+	void onLinkGroupDestroyed(QObject* object);
+	void onCoreSync(quint32 id, qint32 seq);
+
+private:
+	static const pw_registry_events EVENTS;
+
+	static void onGlobal(
+	    void* data,
+	    quint32 id,
+	    quint32 permissions,
+	    const char* type,
+	    quint32 version,
+	    const spa_dict* props
+	);
+
+	static void onGlobalRemoved(void* data, quint32 id);
+
+	void addLinkToGroup(PwLink* link);
+
+	enum class InitState : quint8 {
+		SendingObjects,
+		Binding,
+		Done
+	} initState = InitState::SendingObjects;
+
+	qint32 coreSyncSeq = 0;
+	SpaHook listener;
+};
+
+} // namespace qs::service::pipewire
diff --git a/src/services/status_notifier/CMakeLists.txt b/src/services/status_notifier/CMakeLists.txt
new file mode 100644
index 00000000..7e0bf2b9
--- /dev/null
+++ b/src/services/status_notifier/CMakeLists.txt
@@ -0,0 +1,54 @@
+qt_add_dbus_adaptor(DBUS_INTERFACES
+	org.kde.StatusNotifierWatcher.xml
+	watcher.hpp
+	qs::service::sni::StatusNotifierWatcher
+	dbus_watcher
+	StatusNotifierWatcherAdaptor
+)
+
+set_source_files_properties(org.kde.StatusNotifierItem.xml PROPERTIES
+	CLASSNAME DBusStatusNotifierItem
+	INCLUDE dbus_item_types.hpp
+)
+
+qt_add_dbus_interface(DBUS_INTERFACES
+	org.kde.StatusNotifierItem.xml
+	dbus_item
+)
+
+set_source_files_properties(org.kde.StatusNotifierWatcher.xml PROPERTIES
+	CLASSNAME DBusStatusNotifierWatcher
+)
+
+qt_add_dbus_interface(DBUS_INTERFACES
+	org.kde.StatusNotifierWatcher.xml
+	dbus_watcher_interface
+)
+
+qt_add_library(quickshell-service-statusnotifier STATIC
+	qml.cpp
+
+	watcher.cpp
+	host.cpp
+	item.cpp
+	dbus_item_types.cpp
+	${DBUS_INTERFACES}
+)
+
+# dbus headers
+target_include_directories(quickshell-service-statusnotifier PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+
+qt_add_qml_module(quickshell-service-statusnotifier
+  URI Quickshell.Services.SystemTray
+  VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+qs_add_module_deps_light(quickshell-service-statusnotifier Quickshell Quickshell.DBusMenu)
+
+install_qml_module(quickshell-service-statusnotifier)
+
+target_link_libraries(quickshell-service-statusnotifier PRIVATE Qt::Quick Qt::DBus)
+target_link_libraries(quickshell PRIVATE quickshell-service-statusnotifierplugin)
+
+qs_module_pch(quickshell-service-statusnotifier SET dbus)
diff --git a/src/services/status_notifier/dbus_item_types.cpp b/src/services/status_notifier/dbus_item_types.cpp
new file mode 100644
index 00000000..6678e943
--- /dev/null
+++ b/src/services/status_notifier/dbus_item_types.cpp
@@ -0,0 +1,123 @@
+#include "dbus_item_types.hpp"
+
+#include <qdbusargument.h>
+#include <qdebug.h>
+#include <qendian.h>
+#include <qimage.h>
+#include <qlogging.h>
+#include <qmetatype.h>
+#include <qsysinfo.h>
+#include <qtypes.h>
+
+bool DBusSniIconPixmap::operator==(const DBusSniIconPixmap& other) const {
+	return this->width == other.width && this->height == other.height && this->data == other.data;
+}
+
+bool DBusSniTooltip::operator==(const DBusSniTooltip& other) const {
+	return this->icon == other.icon && this->title == other.title
+	    && this->description == other.description && this->iconPixmaps == other.iconPixmaps;
+}
+
+QImage DBusSniIconPixmap::createImage() const {
+	// fix byte order if on a little endian machine
+	if (QSysInfo::ByteOrder == QSysInfo::LittleEndian) {
+		auto* newbuf = new quint32[this->data.size()];
+		const auto* oldbuf = reinterpret_cast<const quint32*>(this->data.constData());
+
+		for (uint i = 0; i < this->data.size() / sizeof(quint32); ++i) {
+			newbuf[i] = qFromBigEndian(oldbuf[i]); // NOLINT
+		}
+
+		return QImage(
+		    reinterpret_cast<const uchar*>(newbuf),
+		    this->width,
+		    this->height,
+		    QImage::Format_ARGB32,
+		    [](void* ptr) { delete[] reinterpret_cast<quint32*>(ptr); },
+		    newbuf
+		);
+	} else {
+		return QImage(
+		    reinterpret_cast<const uchar*>(this->data.constData()),
+		    this->width,
+		    this->height,
+		    QImage::Format_ARGB32
+		);
+	}
+}
+
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusSniIconPixmap& pixmap) {
+	argument.beginStructure();
+	argument >> pixmap.width;
+	argument >> pixmap.height;
+	argument >> pixmap.data;
+	argument.endStructure();
+	return argument;
+}
+
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusSniIconPixmap& pixmap) {
+	argument.beginStructure();
+	argument << pixmap.width;
+	argument << pixmap.height;
+	argument << pixmap.data;
+	argument.endStructure();
+	return argument;
+}
+
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusSniIconPixmapList& pixmaps) {
+	argument.beginArray();
+	pixmaps.clear();
+
+	while (!argument.atEnd()) {
+		pixmaps.append(qdbus_cast<DBusSniIconPixmap>(argument));
+	}
+
+	argument.endArray();
+	return argument;
+}
+
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusSniIconPixmapList& pixmaps) {
+	argument.beginArray(qMetaTypeId<DBusSniIconPixmap>());
+
+	for (const auto& pixmap: pixmaps) {
+		argument << pixmap;
+	}
+
+	argument.endArray();
+	return argument;
+}
+
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusSniTooltip& tooltip) {
+	argument.beginStructure();
+	argument >> tooltip.icon;
+	argument >> tooltip.iconPixmaps;
+	argument >> tooltip.title;
+	argument >> tooltip.description;
+	argument.endStructure();
+	return argument;
+}
+
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusSniTooltip& tooltip) {
+	argument.beginStructure();
+	argument << tooltip.icon;
+	argument << tooltip.iconPixmaps;
+	argument << tooltip.title;
+	argument << tooltip.description;
+	argument.endStructure();
+	return argument;
+}
+
+QDebug operator<<(QDebug debug, const DBusSniIconPixmap& pixmap) {
+	debug.nospace() << "DBusSniIconPixmap(width=" << pixmap.width << ", height=" << pixmap.height
+	                << ")";
+
+	return debug;
+}
+
+QDebug operator<<(QDebug debug, const DBusSniTooltip& tooltip) {
+	debug.nospace() << "DBusSniTooltip(title=" << tooltip.title
+	                << ", description=" << tooltip.description << ", icon=" << tooltip.icon
+	                << ", iconPixmaps=" << tooltip.iconPixmaps << ")";
+
+	return debug;
+}
diff --git a/src/services/status_notifier/dbus_item_types.hpp b/src/services/status_notifier/dbus_item_types.hpp
new file mode 100644
index 00000000..cef38f36
--- /dev/null
+++ b/src/services/status_notifier/dbus_item_types.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <qdbusargument.h>
+#include <qdebug.h>
+#include <qlist.h>
+
+struct DBusSniIconPixmap {
+	qint32 width = 0;
+	qint32 height = 0;
+	QByteArray data;
+
+	// valid only for the lifetime of the pixmap
+	[[nodiscard]] QImage createImage() const;
+
+	bool operator==(const DBusSniIconPixmap& other) const;
+};
+
+using DBusSniIconPixmapList = QList<DBusSniIconPixmap>;
+
+struct DBusSniTooltip {
+	QString icon;
+	DBusSniIconPixmapList iconPixmaps;
+	QString title;
+	QString description;
+
+	bool operator==(const DBusSniTooltip& other) const;
+};
+
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusSniIconPixmap& pixmap);
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusSniIconPixmap& pixmap);
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusSniIconPixmapList& pixmaps);
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusSniIconPixmapList& pixmaps);
+const QDBusArgument& operator>>(const QDBusArgument& argument, DBusSniTooltip& tooltip);
+const QDBusArgument& operator<<(QDBusArgument& argument, const DBusSniTooltip& tooltip);
+
+QDebug operator<<(QDebug debug, const DBusSniIconPixmap& pixmap);
+QDebug operator<<(QDebug debug, const DBusSniTooltip& tooltip);
diff --git a/src/services/status_notifier/host.cpp b/src/services/status_notifier/host.cpp
new file mode 100644
index 00000000..0e4530ac
--- /dev/null
+++ b/src/services/status_notifier/host.cpp
@@ -0,0 +1,193 @@
+#include "host.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdbusconnection.h>
+#include <qdbuserror.h>
+#include <qdbusservicewatcher.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <unistd.h>
+
+#include "../../core/common.hpp"
+#include "../../core/logcat.hpp"
+#include "../../dbus/properties.hpp"
+#include "dbus_watcher_interface.h"
+#include "item.hpp"
+#include "watcher.hpp"
+
+QS_LOGGING_CATEGORY(logStatusNotifierHost, "quickshell.service.sni.host", QtWarningMsg);
+
+namespace qs::service::sni {
+
+StatusNotifierHost::StatusNotifierHost(QObject* parent): QObject(parent) {
+	StatusNotifierWatcher::instance(); // ensure at least one watcher exists
+
+	auto bus = QDBusConnection::sessionBus();
+
+	if (!bus.isConnected()) {
+		qCWarning(logStatusNotifierHost)
+		    << "Could not connect to DBus. StatusNotifier service will not work.";
+		return;
+	}
+
+	this->hostId = QString("org.kde.StatusNotifierHost-%1-%2")
+	                   .arg(QString::number(getpid()))
+	                   .arg(QString::number(qs::Common::LAUNCH_TIME.toMSecsSinceEpoch()));
+
+	auto success = bus.registerService(this->hostId);
+
+	if (!success) {
+		qCWarning(logStatusNotifierHost) << "Could not register StatusNotifierHost object with DBus. "
+		                                    "StatusNotifer service will not work.";
+		return;
+	}
+
+	QObject::connect(
+	    &this->serviceWatcher,
+	    &QDBusServiceWatcher::serviceRegistered,
+	    this,
+	    &StatusNotifierHost::onWatcherRegistered
+	);
+
+	QObject::connect(
+	    &this->serviceWatcher,
+	    &QDBusServiceWatcher::serviceUnregistered,
+	    this,
+	    &StatusNotifierHost::onWatcherUnregistered
+	);
+
+	this->serviceWatcher.addWatchedService("org.kde.StatusNotifierWatcher");
+	this->serviceWatcher.setConnection(bus);
+
+	this->watcher = new DBusStatusNotifierWatcher(
+	    "org.kde.StatusNotifierWatcher",
+	    "/StatusNotifierWatcher",
+	    bus,
+	    this
+	);
+
+	QObject::connect(
+	    this->watcher,
+	    &DBusStatusNotifierWatcher::StatusNotifierItemRegistered,
+	    this,
+	    &StatusNotifierHost::onItemRegistered
+	);
+
+	QObject::connect(
+	    this->watcher,
+	    &DBusStatusNotifierWatcher::StatusNotifierItemUnregistered,
+	    this,
+	    &StatusNotifierHost::onItemUnregistered
+	);
+
+	if (!this->watcher->isValid()) {
+		qCWarning(logStatusNotifierHost)
+		    << "Could not find active StatusNotifierWatcher. StatusNotifier service will not work "
+		       "until one is present.";
+		return;
+	}
+
+	this->connectToWatcher();
+}
+
+void StatusNotifierHost::connectToWatcher() {
+	qCDebug(logStatusNotifierHost) << "Registering host with active StatusNotifierWatcher";
+	this->watcher->RegisterStatusNotifierHost(this->hostId);
+
+	qs::dbus::asyncReadProperty<QStringList>(
+	    *this->watcher,
+	    "RegisteredStatusNotifierItems",
+	    [this](QStringList value, QDBusError error) { // NOLINT
+		    if (error.isValid()) {
+			    qCWarning(logStatusNotifierHost).noquote()
+			        << "Error reading \"RegisteredStatusNotifierItems\" property of watcher"
+			        << this->watcher->service();
+
+			    qCWarning(logStatusNotifierHost) << error;
+		    } else {
+			    qCDebug(logStatusNotifierHost)
+			        << "Registering preexisting status notifier items from watcher:" << value;
+
+			    for (auto& item: value) {
+				    this->onItemRegistered(item);
+			    }
+		    }
+	    }
+	);
+}
+
+QList<StatusNotifierItem*> StatusNotifierHost::items() const {
+	auto items = this->mItems.values();
+	items.removeIf([](StatusNotifierItem* item) { return !item->isReady(); });
+	return items;
+}
+
+StatusNotifierItem* StatusNotifierHost::itemByService(const QString& service) const {
+	return this->mItems.value(service);
+}
+
+void StatusNotifierHost::onWatcherRegistered() { this->connectToWatcher(); }
+
+void StatusNotifierHost::onWatcherUnregistered() {
+	qCDebug(logStatusNotifierHost) << "Unregistering StatusNotifierItems from old watcher";
+
+	for (auto [service, item]: this->mItems.asKeyValueRange()) {
+		emit this->itemUnregistered(item);
+		delete item;
+		qCDebug(logStatusNotifierHost).noquote()
+		    << "Unregistered StatusNotifierItem" << service << "from host";
+	}
+
+	this->mItems.clear();
+}
+
+void StatusNotifierHost::onItemRegistered(const QString& item) {
+	if (this->mItems.contains(item)) {
+		qCDebug(logStatusNotifierHost).noquote()
+		    << "Ignoring duplicate registration of StatusNotifierItem" << item;
+		return;
+	}
+
+	qCDebug(logStatusNotifierHost).noquote() << "Registering StatusNotifierItem" << item << "to host";
+	auto* dItem = new StatusNotifierItem(item, this);
+	if (!dItem->isValid()) {
+		qCWarning(logStatusNotifierHost).noquote()
+		    << "Unable to connect to StatusNotifierItem at" << item;
+		delete dItem;
+		return;
+	}
+
+	this->mItems.insert(item, dItem);
+	QObject::connect(dItem, &StatusNotifierItem::ready, this, &StatusNotifierHost::onItemReady);
+	emit this->itemRegistered(dItem);
+}
+
+void StatusNotifierHost::onItemUnregistered(const QString& item) {
+	if (auto* dItem = this->mItems.value(item)) {
+		this->mItems.remove(item);
+		emit this->itemUnregistered(dItem);
+		delete dItem;
+		qCDebug(logStatusNotifierHost).noquote()
+		    << "Unregistered StatusNotifierItem" << item << "from host";
+	} else {
+		qCWarning(logStatusNotifierHost).noquote()
+		    << "Ignoring unregistration for missing StatusNotifierItem at" << item;
+	}
+}
+
+void StatusNotifierHost::onItemReady() {
+	if (auto* item = qobject_cast<StatusNotifierItem*>(this->sender())) {
+		emit this->itemReady(item);
+	}
+}
+
+StatusNotifierHost* StatusNotifierHost::instance() {
+	static StatusNotifierHost* instance = nullptr; // NOLINT
+	if (instance == nullptr) instance = new StatusNotifierHost();
+	return instance;
+}
+
+} // namespace qs::service::sni
diff --git a/src/services/status_notifier/host.hpp b/src/services/status_notifier/host.hpp
new file mode 100644
index 00000000..87b3137b
--- /dev/null
+++ b/src/services/status_notifier/host.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qdbusservicewatcher.h>
+#include <qhash.h>
+#include <qlist.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+#include "../../core/logcat.hpp"
+#include "dbus_watcher_interface.h"
+#include "item.hpp"
+
+QS_DECLARE_LOGGING_CATEGORY(logStatusNotifierHost);
+
+namespace qs::service::sni {
+
+class StatusNotifierHost: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit StatusNotifierHost(QObject* parent = nullptr);
+
+	void connectToWatcher();
+	[[nodiscard]] QList<StatusNotifierItem*> items() const;
+	[[nodiscard]] StatusNotifierItem* itemByService(const QString& service) const;
+
+	static StatusNotifierHost* instance();
+
+signals:
+	void itemRegistered(StatusNotifierItem* item);
+	void itemReady(StatusNotifierItem* item);
+	void itemUnregistered(StatusNotifierItem* item);
+
+private slots:
+	void onWatcherRegistered();
+	void onWatcherUnregistered();
+	void onItemRegistered(const QString& item);
+	void onItemUnregistered(const QString& item);
+	void onItemReady();
+
+private:
+	QString hostId;
+	QDBusServiceWatcher serviceWatcher;
+	DBusStatusNotifierWatcher* watcher = nullptr;
+	QHash<QString, StatusNotifierItem*> mItems;
+};
+
+} // namespace qs::service::sni
diff --git a/src/services/status_notifier/item.cpp b/src/services/status_notifier/item.cpp
new file mode 100644
index 00000000..650c812e
--- /dev/null
+++ b/src/services/status_notifier/item.cpp
@@ -0,0 +1,381 @@
+#include "item.hpp"
+
+#include <qdbuserror.h>
+#include <qdbusextratypes.h>
+#include <qdbusmetatype.h>
+#include <qdbuspendingcall.h>
+#include <qdbuspendingreply.h>
+#include <qicon.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qpainter.h>
+#include <qpixmap.h>
+#include <qqmlengine.h>
+#include <qrect.h>
+#include <qsize.h>
+#include <qstring.h>
+#include <qstringliteral.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/iconimageprovider.hpp"
+#include "../../core/imageprovider.hpp"
+#include "../../core/logcat.hpp"
+#include "../../core/platformmenu.hpp"
+#include "../../dbus/dbusmenu/dbusmenu.hpp"
+#include "../../dbus/properties.hpp"
+#include "dbus_item.h"
+#include "dbus_item_types.hpp"
+#include "host.hpp"
+#include "watcher.hpp"
+
+using namespace qs::dbus;
+using namespace qs::dbus::dbusmenu;
+using namespace qs::menu::platform;
+
+QS_LOGGING_CATEGORY(logStatusNotifierItem, "quickshell.service.sni.item", QtWarningMsg);
+
+namespace qs::service::sni {
+
+StatusNotifierItem::StatusNotifierItem(const QString& address, QObject* parent)
+    : QObject(parent)
+    , watcherId(address) {
+	qDBusRegisterMetaType<DBusSniIconPixmap>();
+	qDBusRegisterMetaType<DBusSniIconPixmapList>();
+	qDBusRegisterMetaType<DBusSniTooltip>();
+
+	// spec is unclear about what exactly an item address is, so account for both combinations
+	auto splitIdx = address.indexOf('/');
+	auto conn = splitIdx == -1 ? address : address.sliced(0, splitIdx);
+	auto path = splitIdx == -1 ? "/StatusNotifierItem" : address.sliced(splitIdx);
+
+	this->item = new DBusStatusNotifierItem(conn, path, QDBusConnection::sessionBus(), this);
+
+	if (!this->item->isValid()) {
+		qCWarning(logStatusNotifierHost).noquote() << "Cannot create StatusNotifierItem for" << conn;
+		return;
+	}
+
+	// clang-format off
+	QObject::connect(this->item, &DBusStatusNotifierItem::NewTitle, this, [this]() {
+		this->pTitle.requestUpdate();
+	});
+
+	QObject::connect(this->item, &DBusStatusNotifierItem::NewIcon, this, [this]() {
+		this->pIconName.requestUpdate();
+		this->pIconPixmaps.requestUpdate();
+		if (this->pIconThemePath.exists()) this->pIconThemePath.requestUpdate();
+	});
+
+	QObject::connect(this->item, &DBusStatusNotifierItem::NewOverlayIcon, this, [this]() {
+		this->pOverlayIconName.requestUpdate();
+		this->pOverlayIconPixmaps.requestUpdate();
+		if (this->pIconThemePath.exists()) this->pIconThemePath.requestUpdate();
+	});
+
+	QObject::connect(this->item, &DBusStatusNotifierItem::NewAttentionIcon, this, [this]() {
+		this->pAttentionIconName.requestUpdate();
+		this->pAttentionIconPixmaps.requestUpdate();
+		if (this->pIconThemePath.exists()) this->pIconThemePath.requestUpdate();
+	});
+
+	QObject::connect(this->item, &DBusStatusNotifierItem::NewToolTip, this, [this]() {
+		this->pTooltip.requestUpdate();
+	});
+
+	QObject::connect(&this->properties, &DBusPropertyGroup::getAllFinished, this, &StatusNotifierItem::onGetAllFinished);
+	QObject::connect(&this->properties, &DBusPropertyGroup::getAllFailed, this, &StatusNotifierItem::onGetAllFailed);
+	// clang-format on
+
+	this->bIcon.setBinding([this]() -> QString {
+		if (this->bStatus.value() == Status::NeedsAttention) {
+			auto name = this->bAttentionIconName.value();
+			if (!name.isEmpty())
+				return IconImageProvider::requestString(name, this->bIconThemePath.value());
+		} else {
+			auto name = this->bIconName.value();
+			auto overlayName = this->bOverlayIconName.value();
+			if (!name.isEmpty() && overlayName.isEmpty())
+				return IconImageProvider::requestString(name, this->bIconThemePath.value());
+		}
+
+		return this->imageHandle.url() % "/" % QString::number(this->pixmapIndex);
+	});
+
+	this->bHasMenu.setBinding([this]() { return !this->bMenuPath.value().path().isEmpty(); });
+
+	QObject::connect(
+	    this->item,
+	    &DBusStatusNotifierItem::NewStatus,
+	    this,
+	    [this](const QString& value) {
+		    auto result = DBusDataTransform<Status::Enum>::fromWire(value);
+
+		    if (result.isValid()) {
+			    this->bStatus = result.value;
+			    qCDebug(logStatusNotifierItem)
+			        << "Received status update for" << this->properties.toString() << result.value;
+		    } else {
+			    qCWarning(logStatusNotifierItem)
+			        << "Received invalid status update for" << this->properties.toString() << value;
+		    }
+	    }
+	);
+
+	this->properties.setInterface(this->item);
+	this->properties.updateAllViaGetAll();
+}
+
+bool StatusNotifierItem::isValid() const { return this->item->isValid(); }
+bool StatusNotifierItem::isReady() const { return this->mReady; }
+
+QPixmap StatusNotifierItem::createPixmap(const QSize& size) const {
+	auto needsAttention = this->bStatus.value() == Status::NeedsAttention;
+
+	auto closestPixmap = [](const QSize& size, const DBusSniIconPixmapList& pixmaps) {
+		const DBusSniIconPixmap* ret = nullptr;
+
+		for (const auto& pixmap: pixmaps) {
+			if (ret == nullptr) {
+				ret = &pixmap;
+				continue;
+			}
+
+			auto existingAdequate = ret->width >= size.width() && ret->height >= size.height();
+			auto newAdequite = pixmap.width >= size.width() && pixmap.height >= size.height();
+			auto newSmaller = pixmap.width < ret->width || pixmap.height < ret->height;
+
+			if ((existingAdequate && newAdequite && newSmaller) || (!existingAdequate && !newSmaller)) {
+				ret = &pixmap;
+			}
+		}
+
+		return ret;
+	};
+
+	QPixmap pixmap;
+	if (needsAttention) {
+		if (!this->bAttentionIconName.value().isEmpty()) {
+			auto icon = QIcon::fromTheme(this->bAttentionIconName.value());
+			pixmap = icon.pixmap(size.width(), size.height());
+		} else {
+			const auto* icon = closestPixmap(size, this->bAttentionIconPixmaps.value());
+
+			if (icon == nullptr) {
+				icon = closestPixmap(size, this->bIconPixmaps.value());
+			}
+
+			if (icon != nullptr) {
+				const auto image =
+				    icon->createImage().scaled(size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+
+				pixmap = QPixmap::fromImage(image);
+			}
+		}
+	} else {
+		if (!this->bIconName.value().isEmpty()) {
+			auto icon = QIcon::fromTheme(this->bIconName.value());
+			pixmap = icon.pixmap(size.width(), size.height());
+		} else {
+			const auto* icon = closestPixmap(size, this->bIconPixmaps.value());
+
+			if (icon != nullptr) {
+				const auto image =
+				    icon->createImage().scaled(size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+
+				pixmap = QPixmap::fromImage(image);
+			}
+		}
+
+		QPixmap overlay;
+		if (!this->bOverlayIconName.value().isEmpty()) {
+			auto icon = QIcon::fromTheme(this->bOverlayIconName.value());
+			overlay = icon.pixmap(pixmap.width(), pixmap.height());
+		} else {
+			const auto* icon = closestPixmap(pixmap.size(), this->bOverlayIconPixmaps.value());
+
+			if (icon != nullptr) {
+				const auto image =
+				    icon->createImage().scaled(size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
+
+				overlay = QPixmap::fromImage(image);
+			}
+		}
+
+		if (!overlay.isNull()) {
+			auto painter = QPainter(&pixmap);
+			painter.drawPixmap(QRect(0, 0, pixmap.width(), pixmap.height()), overlay);
+			painter.end();
+		}
+	}
+
+	return pixmap;
+}
+
+void StatusNotifierItem::activate() {
+	auto pendingCall = this->item->Activate(0, 0);
+	auto* call = new QDBusPendingCallWatcher(pendingCall, this);
+
+	auto responseCallback = [this](QDBusPendingCallWatcher* call) {
+		const QDBusPendingReply<> reply = *call;
+
+		if (reply.isError()) {
+			if (reply.error().type() == QDBusError::UnknownMethod) {
+				qCDebug(logStatusNotifierItem) << "Tried to call Activate method of StatusNotifierItem"
+				                               << this->properties.toString() << "but it does not exist.";
+			} else {
+				qCWarning(logStatusNotifierItem).noquote()
+				    << "Error calling Activate method of StatusNotifierItem" << this->properties.toString();
+				qCWarning(logStatusNotifierItem) << reply.error();
+			}
+		}
+
+		delete call;
+	};
+
+	QObject::connect(call, &QDBusPendingCallWatcher::finished, this, responseCallback);
+}
+
+void StatusNotifierItem::secondaryActivate() {
+	auto pendingCall = this->item->SecondaryActivate(0, 0);
+	auto* call = new QDBusPendingCallWatcher(pendingCall, this);
+
+	auto responseCallback = [this](QDBusPendingCallWatcher* call) {
+		const QDBusPendingReply<> reply = *call;
+
+		if (reply.isError()) {
+			if (reply.error().type() == QDBusError::UnknownMethod) {
+				qCDebug(logStatusNotifierItem)
+				    << "Tried to call SecondaryActivate method of StatusNotifierItem"
+				    << this->properties.toString() << "but it does not exist.";
+			} else {
+				qCWarning(logStatusNotifierItem).noquote()
+				    << "Error calling SecondaryActivate method of StatusNotifierItem"
+				    << this->properties.toString();
+				qCWarning(logStatusNotifierItem) << reply.error();
+			}
+		}
+
+		delete call;
+	};
+
+	QObject::connect(call, &QDBusPendingCallWatcher::finished, this, responseCallback);
+}
+
+void StatusNotifierItem::scroll(qint32 delta, bool horizontal) const {
+	this->item->Scroll(delta, horizontal ? "horizontal" : "vertical");
+}
+
+void StatusNotifierItem::updatePixmapIndex() { this->pixmapIndex = this->pixmapIndex + 1; }
+
+DBusMenuHandle* StatusNotifierItem::menuHandle() {
+	return this->bMenuPath.value().path().isEmpty() ? nullptr : &this->mMenuHandle;
+}
+
+void StatusNotifierItem::onMenuPathChanged() {
+	this->mMenuHandle.setAddress(this->item->service(), this->bMenuPath.value().path());
+}
+
+void StatusNotifierItem::onGetAllFinished() {
+	if (this->mReady) return;
+	this->mReady = true;
+	emit this->ready();
+}
+
+void StatusNotifierItem::onGetAllFailed() const {
+	// Not changing the item to ready, as it is almost definitely broken.
+	if (!this->mReady) {
+		qWarning(logStatusNotifierItem) << "Failed to load tray item" << this->properties.toString();
+
+		if (!StatusNotifierWatcher::instance()->isRegistered()) {
+			qWarning(logStatusNotifierItem)
+			    << "Another StatusNotifier host seems to be running. Please disable it and check that "
+			       "the problem persists before reporting an issue.";
+		}
+	}
+}
+
+TrayImageHandle::TrayImageHandle(StatusNotifierItem* item)
+    : QsImageHandle(QQmlImageProviderBase::Pixmap)
+    , item(item) {}
+
+QPixmap
+TrayImageHandle::requestPixmap(const QString& /*unused*/, QSize* size, const QSize& requestedSize) {
+	auto targetSize = requestedSize.isValid() ? requestedSize : QSize(100, 100);
+	if (targetSize.width() == 0 || targetSize.height() == 0) targetSize = QSize(2, 2);
+
+	auto pixmap = this->item->createPixmap(targetSize);
+	if (pixmap.isNull()) {
+		qCWarning(logStatusNotifierItem) << "Unable to create pixmap for tray icon" << this->item;
+		pixmap = IconImageProvider::missingPixmap(targetSize);
+	}
+
+	if (size != nullptr) *size = pixmap.size();
+	return pixmap;
+}
+
+void StatusNotifierItem::display(QObject* parentWindow, qint32 relativeX, qint32 relativeY) {
+	if (!this->menuHandle()) {
+		qCritical() << "No menu present for" << this;
+		return;
+	}
+
+	auto* handle = this->menuHandle();
+
+	auto onMenuChanged = [this, parentWindow, relativeX, relativeY, handle]() {
+		QObject::disconnect(handle, nullptr, this, nullptr);
+
+		if (!handle->menu()) {
+			handle->unrefHandle();
+			return;
+		}
+
+		auto* platform = new PlatformMenuEntry(handle->menu());
+
+		// clang-format off
+		QObject::connect(platform, &PlatformMenuEntry::closed, this, [=]() { platform->deleteLater(); });
+		QObject::connect(platform, &QObject::destroyed, this, [=]() { handle->unrefHandle(); });
+		// clang-format on
+
+		auto success = platform->display(parentWindow, relativeX, relativeY);
+
+		// calls destroy which also unrefs
+		if (!success) delete platform;
+	};
+
+	if (handle->menu()) onMenuChanged();
+	QObject::connect(handle, &DBusMenuHandle::menuChanged, this, onMenuChanged);
+	handle->refHandle();
+}
+
+} // namespace qs::service::sni
+
+namespace qs::dbus {
+using namespace qs::service::sni;
+
+DBusResult<Status::Enum> DBusDataTransform<Status::Enum>::fromWire(const QString& wire) {
+	if (wire == QStringLiteral("Passive")) return DBusResult(Status::Passive);
+	if (wire == QStringLiteral("Active")) return DBusResult(Status::Active);
+	if (wire == QStringLiteral("NeedsAttention")) return DBusResult(Status::NeedsAttention);
+
+	return DBusResult<Status::Enum>(QDBusError(
+	    QDBusError::InvalidArgs,
+	    QString("Nonconformant StatusNotifierItem Status: %1").arg(wire)
+	));
+}
+
+DBusResult<Category::Enum> DBusDataTransform<Category::Enum>::fromWire(const QString& wire) {
+	if (wire == "ApplicationStatus") return DBusResult(Category::ApplicationStatus);
+	if (wire == "Communications") return DBusResult(Category::Communications);
+	if (wire == "SystemServices") return DBusResult(Category::SystemServices);
+	if (wire == "Hardware") return DBusResult(Category::Hardware);
+
+	return DBusResult<Category::Enum>(QDBusError(
+	    QDBusError::InvalidArgs,
+	    QString("Nonconformant StatusNotifierItem Category: %1").arg(wire)
+	));
+}
+
+} // namespace qs::dbus
diff --git a/src/services/status_notifier/item.hpp b/src/services/status_notifier/item.hpp
new file mode 100644
index 00000000..5ce5a7ff
--- /dev/null
+++ b/src/services/status_notifier/item.hpp
@@ -0,0 +1,232 @@
+#pragma once
+
+#include <qdbusextratypes.h>
+#include <qdbuspendingcall.h>
+#include <qicon.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qpixmap.h>
+#include <qproperty.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/imageprovider.hpp"
+#include "../../core/logcat.hpp"
+#include "../../dbus/dbusmenu/dbusmenu.hpp"
+#include "../../dbus/properties.hpp"
+#include "dbus_item.h"
+#include "dbus_item_types.hpp"
+
+QS_DECLARE_LOGGING_CATEGORY(logStatusNotifierItem);
+
+namespace qs::service::sni {
+
+///! Status of a StatusNotifierItem.
+/// See @@StatusNotifierItem.status.
+namespace Status { // NOLINT
+Q_NAMESPACE;
+QML_ELEMENT;
+
+enum Enum : quint8 {
+	/// A passive item does not convey important information and can be considered idle. You may want to hide these.
+	Passive = 0,
+	/// An active item may have information more important than a passive one and you probably do not want to hide it.
+	Active = 1,
+	/// An item that needs attention conveys very important information such as low battery.
+	NeedsAttention = 2,
+};
+Q_ENUM_NS(Enum);
+} // namespace Status
+
+///! Category of a StatusNotifierItem.
+/// See @@StatusNotifierItem.category.
+namespace Category { // NOLINT
+Q_NAMESPACE;
+QML_ELEMENT;
+
+enum Enum : quint8 {
+	/// Hardware controls like battery indicators or volume control.
+	Hardware = 0,
+	/// System services such as IMEs or disk indexing.
+	SystemServices = 1,
+	/// The fallback category for general applications or anything that does
+	/// not fit into a different category.
+	ApplicationStatus = 2,
+	/// Communication related applications such as instant messengers or email clients.
+	Communications = 3,
+};
+Q_ENUM_NS(Enum);
+} // namespace Category
+
+} // namespace qs::service::sni
+
+namespace qs::dbus {
+
+template <>
+struct DBusDataTransform<qs::service::sni::Status::Enum> {
+	using Wire = QString;
+	using Data = qs::service::sni::Status::Enum;
+	static DBusResult<Data> fromWire(const QString& wire);
+};
+
+template <>
+struct DBusDataTransform<qs::service::sni::Category::Enum> {
+	using Wire = QString;
+	using Data = qs::service::sni::Category::Enum;
+	static DBusResult<Data> fromWire(const QString& wire);
+};
+
+} // namespace qs::dbus
+
+namespace qs::service::sni {
+
+class StatusNotifierItem;
+
+class TrayImageHandle: public QsImageHandle {
+public:
+	explicit TrayImageHandle(StatusNotifierItem* item);
+
+	QPixmap requestPixmap(const QString& id, QSize* size, const QSize& requestedSize) override;
+
+public:
+	StatusNotifierItem* item;
+};
+
+///! An item in the system tray.
+/// A system tray item, roughly conforming to the [kde/freedesktop spec]
+/// (there is no real spec, we just implemented whatever seemed to actually be used).
+///
+/// [kde/freedesktop spec]: https://www.freedesktop.org/wiki/Specifications/StatusNotifierItem/StatusNotifierItem/
+class StatusNotifierItem: public QObject {
+	Q_OBJECT;
+
+	// clang-format off
+	/// A name unique to the application, such as its name.
+	Q_PROPERTY(QString id READ default NOTIFY idChanged BINDABLE bindableId);
+	/// Text that describes the application.
+	Q_PROPERTY(QString title READ default NOTIFY titleChanged BINDABLE bindableTitle);
+	Q_PROPERTY(qs::service::sni::Status::Enum status READ default NOTIFY statusChanged BINDABLE bindableStatus);
+	Q_PROPERTY(qs::service::sni::Category::Enum category READ default NOTIFY categoryChanged BINDABLE bindableCategory);
+	/// Icon source string, usable as an Image source.
+	Q_PROPERTY(QString icon READ default NOTIFY iconChanged BINDABLE bindableIcon);
+	Q_PROPERTY(QString tooltipTitle READ tooltipTitle NOTIFY tooltipTitleChanged);
+	Q_PROPERTY(QString tooltipDescription READ tooltipDescription NOTIFY tooltipDescriptionChanged);
+	/// If this tray item has an associated menu accessible via @@display() or @@menu.
+	Q_PROPERTY(bool hasMenu READ default NOTIFY hasMenuChanged BINDABLE bindableHasMenu);
+	/// A handle to the menu associated with this tray item, if any.
+	///
+	/// Can be displayed with @@Quickshell.QsMenuAnchor or @@Quickshell.QsMenuOpener.
+	Q_PROPERTY(qs::dbus::dbusmenu::DBusMenuHandle* menu READ menuHandle NOTIFY hasMenuChanged);
+	/// If this tray item only offers a menu and activation will do nothing.
+	Q_PROPERTY(bool onlyMenu READ default NOTIFY onlyMenuChanged BINDABLE bindableOnlyMenu);
+	// clang-format on
+	QML_NAMED_ELEMENT(SystemTrayItem);
+	QML_UNCREATABLE("SystemTrayItems can only be acquired from SystemTray");
+
+public:
+	explicit StatusNotifierItem(const QString& address, QObject* parent = nullptr);
+
+	/// Primary activation action, generally triggered via a left click.
+	Q_INVOKABLE void activate();
+	/// Secondary activation action, generally triggered via a middle click.
+	Q_INVOKABLE void secondaryActivate();
+	/// Scroll action, such as changing volume on a mixer.
+	Q_INVOKABLE void scroll(qint32 delta, bool horizontal) const;
+	/// Display a platform menu at the given location relative to the parent window.
+	Q_INVOKABLE void display(QObject* parentWindow, qint32 relativeX, qint32 relativeY);
+
+	[[nodiscard]] bool isValid() const;
+	[[nodiscard]] bool isReady() const;
+	[[nodiscard]] QBindable<QString> bindableIcon() const { return &this->bIcon; }
+	[[nodiscard]] QPixmap createPixmap(const QSize& size) const;
+
+	[[nodiscard]] dbus::dbusmenu::DBusMenuHandle* menuHandle();
+
+	[[nodiscard]] QBindable<QString> bindableId() const { return &this->bId; }
+	[[nodiscard]] QBindable<QString> bindableTitle() const { return &this->bTitle; }
+	[[nodiscard]] QBindable<Status::Enum> bindableStatus() const { return &this->bStatus; }
+	[[nodiscard]] QBindable<Category::Enum> bindableCategory() const { return &this->bCategory; }
+	[[nodiscard]] QString tooltipTitle() const { return this->bTooltip.value().title; }
+	[[nodiscard]] QString tooltipDescription() const { return this->bTooltip.value().description; }
+	[[nodiscard]] QBindable<bool> bindableHasMenu() const { return &this->bHasMenu; }
+	[[nodiscard]] QBindable<bool> bindableOnlyMenu() const { return &this->bIsMenu; }
+
+signals:
+	void ready();
+
+	void idChanged();
+	void titleChanged();
+	void iconChanged();
+	void statusChanged();
+	void categoryChanged();
+	void tooltipTitleChanged();
+	void tooltipDescriptionChanged();
+	void hasMenuChanged();
+	void onlyMenuChanged();
+
+private slots:
+	void onGetAllFinished();
+	void onGetAllFailed() const;
+
+private:
+	void updateMenuState();
+	void updatePixmapIndex();
+	void onMenuPathChanged();
+
+	DBusStatusNotifierItem* item = nullptr;
+	TrayImageHandle imageHandle {this};
+	bool mReady = false;
+
+	dbus::dbusmenu::DBusMenuHandle mMenuHandle {this};
+
+	QString watcherId;
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, QString, bId, &StatusNotifierItem::idChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, QString, bTitle, &StatusNotifierItem::titleChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, Status::Enum, bStatus, &StatusNotifierItem::statusChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, Category::Enum, bCategory, &StatusNotifierItem::categoryChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, QString, bIconThemePath);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, QString, bIconName);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, QString, bOverlayIconName);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, QString, bAttentionIconName);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, DBusSniIconPixmapList, bIconPixmaps);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, DBusSniIconPixmapList, bOverlayIconPixmaps);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, DBusSniIconPixmapList, bAttentionIconPixmaps);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, QString, bAttentionMovieName);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, DBusSniTooltip, bTooltip);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, bool, bIsMenu);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, QDBusObjectPath, bMenuPath);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, bool, bHasMenu, &StatusNotifierItem::hasMenuChanged);
+
+	QS_BINDING_SUBSCRIBE_METHOD(StatusNotifierItem, bIconThemePath, updatePixmapIndex, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(StatusNotifierItem, bIconName, updatePixmapIndex, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(StatusNotifierItem, bOverlayIconName, updatePixmapIndex, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(StatusNotifierItem, bAttentionIconName, updatePixmapIndex, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(StatusNotifierItem, bIconPixmaps, updatePixmapIndex, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(StatusNotifierItem, bOverlayIconPixmaps, updatePixmapIndex, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(StatusNotifierItem, bAttentionIconPixmaps, updatePixmapIndex, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(StatusNotifierItem, bMenuPath, onMenuPathChanged, onValueChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, quint32, pixmapIndex);
+	Q_OBJECT_BINDABLE_PROPERTY(StatusNotifierItem, QString, bIcon, &StatusNotifierItem::iconChanged);
+
+	QS_DBUS_BINDABLE_PROPERTY_GROUP(StatusNotifierItem, properties);
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pId, bId, properties, "Id");
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pTitle, bTitle, properties, "Title");
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pStatus, bStatus, properties, "Status");
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pCategory, bCategory, properties, "Category", false);
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pIconThemePath, bIconThemePath, properties, "IconThemePath", false);
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pIconName, bIconName, properties, "IconName", false);
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pIconPixmaps, bIconPixmaps, properties, "IconPixmap", false);
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pOverlayIconName, bOverlayIconName, properties, "OverlayIconName", false);
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pOverlayIconPixmaps, bOverlayIconPixmaps, properties, "OverlayIconPixmap", false);
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pAttentionIconName, bAttentionIconName, properties, "AttentionIconName", false);
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pAttentionIconPixmaps, bAttentionIconPixmaps, properties, "AttentionIconPixmap", false);
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pAttentionMovieName, bAttentionMovieName, properties, "AttentionMovieName", false);
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pTooltip, bTooltip, properties, "ToolTip", false);
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pIsMenu, bIsMenu, properties, "ItemIsMenu", false);
+	QS_DBUS_PROPERTY_BINDING(StatusNotifierItem, pMenuPath, bMenuPath, properties, "Menu", false);
+	// clang-format on
+};
+
+} // namespace qs::service::sni
diff --git a/src/services/status_notifier/module.md b/src/services/status_notifier/module.md
new file mode 100644
index 00000000..a3a2efac
--- /dev/null
+++ b/src/services/status_notifier/module.md
@@ -0,0 +1,4 @@
+name = "Quickshell.Services.SystemTray"
+description = "Types for implementing a system tray"
+headers = [ "qml.hpp", "item.hpp" ]
+-----
diff --git a/src/services/status_notifier/org.kde.StatusNotifierItem.xml b/src/services/status_notifier/org.kde.StatusNotifierItem.xml
new file mode 100644
index 00000000..0aa43c7c
--- /dev/null
+++ b/src/services/status_notifier/org.kde.StatusNotifierItem.xml
@@ -0,0 +1,54 @@
+<node>
+  <interface name="org.kde.StatusNotifierItem">
+    <property name="Category" type="s" access="read"/>
+    <property name="Id" type="s" access="read"/>
+    <property name="Title" type="s" access="read"/>
+    <property name="Status" type="s" access="read"/>
+    <property name="WindowId" type="u" access="read"/>
+    <property name="IconThemePath" type="s" access="read"/>
+    <property name="IconName" type="s" access="read"/>
+    <property name="IconPixmap" type="a(iiay)" access="read">
+			<annotation name="org.qtproject.QtDBus.QtTypeName" value="DBusSniIconPixmapList"/>
+		</property>
+    <property name="OverlayIconName" type="s" access="read"/>
+    <property name="OverlayIconPixmap" type="a(iiay)" access="read">
+			<annotation name="org.qtproject.QtDBus.QtTypeName" value="DBusSniIconPixmapList"/>
+		</property>
+    <property name="AttentionIconName" type="s" access="read"/>
+    <property name="AttentionIconPixmap" type="a(iiay)" access="read">
+			<annotation name="org.qtproject.QtDBus.QtTypeName" value="DBusSniIconPixmapList"/>
+		</property>
+    <property name="AttentionMovieName" type="s" access="read"/>
+    <property name="ToolTip" type="(sa(iiay)ss)" access="read">
+			<annotation name="org.qtproject.QtDBus.QtTypeName" value="DBusSniTooltip"/>
+		</property>
+    <property name="Menu" type="o" access="read"/>
+    <property name="ItemIsMenu" type="b" access="read"/>
+
+    <method name="ContextMenu">
+      <arg type="i" direction="in" name="x"/>
+      <arg type="i" direction="in" name="y"/>
+    </method>
+    <method name="Activate">
+      <arg type="i" direction="in" name="x"/>
+      <arg type="i" direction="in" name="y"/>
+    </method>
+    <method name="SecondaryActivate">
+      <arg type="i" direction="in" name="x"/>
+      <arg type="i" direction="in" name="y"/>
+    </method>
+    <method name="Scroll">
+      <arg type="i" direction="in" name="delta"/>
+      <arg type="s" direction="in" name="orientation"/>
+    </method>
+
+    <signal name="NewTitle"/>
+    <signal name="NewIcon"/>
+    <signal name="NewAttentionIcon"/>
+    <signal name="NewOverlayIcon"/>
+    <signal name="NewToolTip"/>
+    <signal name="NewStatus">
+      <arg type="s" name="status"/>
+    </signal>
+  </interface>
+</node>
diff --git a/src/services/status_notifier/org.kde.StatusNotifierWatcher.xml b/src/services/status_notifier/org.kde.StatusNotifierWatcher.xml
new file mode 100644
index 00000000..5d5f3270
--- /dev/null
+++ b/src/services/status_notifier/org.kde.StatusNotifierWatcher.xml
@@ -0,0 +1,23 @@
+<node>
+  <interface name="org.kde.StatusNotifierWatcher">
+    <property name="ProtocolVersion" type="i" access="read"/>
+    <property name="RegisteredStatusNotifierItems" type="as" access="read"/>
+    <property name="IsStatusNotifierHostRegistered" type="b" access="read"/>
+
+    <method name="RegisterStatusNotifierItem">
+      <arg name="service" type="s" direction="in"/>
+    </method>
+    <method name="RegisterStatusNotifierHost">
+			<arg name="service" type="s" direction="in"/>
+    </method>
+
+    <signal name="StatusNotifierItemRegistered">
+      <arg type="s" direction="out" name="service"/>
+    </signal>
+    <signal name="StatusNotifierItemUnregistered">
+      <arg type="s" direction="out" name="service"/>
+    </signal>
+    <signal name="StatusNotifierHostRegistered"/>
+    <signal name="StatusNotifierHostUnregistered"/>
+  </interface>
+</node>
diff --git a/src/services/status_notifier/qml.cpp b/src/services/status_notifier/qml.cpp
new file mode 100644
index 00000000..ef8df502
--- /dev/null
+++ b/src/services/status_notifier/qml.cpp
@@ -0,0 +1,35 @@
+#include "qml.hpp"
+
+#include <qnamespace.h>
+#include <qobject.h>
+
+#include "../../core/model.hpp"
+#include "host.hpp"
+#include "item.hpp"
+
+using namespace qs::service::sni;
+
+SystemTray::SystemTray(QObject* parent): QObject(parent) {
+	auto* host = StatusNotifierHost::instance();
+
+	// clang-format off
+	QObject::connect(host, &StatusNotifierHost::itemReady, this, &SystemTray::onItemRegistered);
+	QObject::connect(host, &StatusNotifierHost::itemUnregistered, this, &SystemTray::onItemUnregistered);
+	// clang-format on
+
+	for (auto* item: host->items()) {
+		this->mItems.insertObjectSorted(item, &SystemTray::compareItems);
+	}
+}
+
+void SystemTray::onItemRegistered(StatusNotifierItem* item) {
+	this->mItems.insertObjectSorted(item, &SystemTray::compareItems);
+}
+
+void SystemTray::onItemUnregistered(StatusNotifierItem* item) { this->mItems.removeObject(item); }
+ObjectModel<StatusNotifierItem>* SystemTray::items() { return &this->mItems; }
+
+bool SystemTray::compareItems(StatusNotifierItem* a, StatusNotifierItem* b) {
+	return a->bindableCategory().value() < b->bindableCategory().value()
+	    || a->bindableId().value().compare(b->bindableId().value(), Qt::CaseInsensitive) >= 0;
+}
diff --git a/src/services/status_notifier/qml.hpp b/src/services/status_notifier/qml.hpp
new file mode 100644
index 00000000..f9ae9bad
--- /dev/null
+++ b/src/services/status_notifier/qml.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+
+#include "../../core/doc.hpp"
+#include "../../core/model.hpp"
+#include "item.hpp"
+
+///! System tray
+/// Referencing the SystemTray singleton will make quickshell start tracking
+/// system tray contents, which are updated as the tray changes, and can be
+/// accessed via the @@items property.
+class SystemTray: public QObject {
+	Q_OBJECT;
+	/// List of all system tray icons.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::service::sni::StatusNotifierItem>*);
+	Q_PROPERTY(UntypedObjectModel* items READ items CONSTANT);
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	explicit SystemTray(QObject* parent = nullptr);
+
+	[[nodiscard]] ObjectModel<qs::service::sni::StatusNotifierItem>* items();
+
+private slots:
+	void onItemRegistered(qs::service::sni::StatusNotifierItem* item);
+	void onItemUnregistered(qs::service::sni::StatusNotifierItem* item);
+
+private:
+	static bool
+	compareItems(qs::service::sni::StatusNotifierItem* a, qs::service::sni::StatusNotifierItem* b);
+
+	ObjectModel<qs::service::sni::StatusNotifierItem> mItems {this};
+};
diff --git a/src/services/status_notifier/watcher.cpp b/src/services/status_notifier/watcher.cpp
new file mode 100644
index 00000000..e5b841d8
--- /dev/null
+++ b/src/services/status_notifier/watcher.cpp
@@ -0,0 +1,177 @@
+#include "watcher.hpp"
+
+#include <dbus_watcher.h>
+#include <qdbusconnection.h>
+#include <qdbusconnectioninterface.h>
+#include <qdbusservicewatcher.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+#include "../../core/logcat.hpp"
+
+QS_LOGGING_CATEGORY(logStatusNotifierWatcher, "quickshell.service.sni.watcher", QtWarningMsg);
+
+namespace qs::service::sni {
+
+StatusNotifierWatcher::StatusNotifierWatcher(QObject* parent): QObject(parent) {
+	new StatusNotifierWatcherAdaptor(this);
+
+	qCDebug(logStatusNotifierWatcher) << "Starting StatusNotifierWatcher";
+
+	auto bus = QDBusConnection::sessionBus();
+
+	if (!bus.isConnected()) {
+		qCWarning(logStatusNotifierWatcher)
+		    << "Could not connect to DBus. StatusNotifier service will not work.";
+		return;
+	}
+
+	if (!bus.registerObject("/StatusNotifierWatcher", this)) {
+		qCWarning(logStatusNotifierWatcher) << "Could not register StatusNotifierWatcher object with "
+		                                       "DBus. StatusNotifer service will not work.";
+		return;
+	}
+
+	QObject::connect(
+	    &this->serviceWatcher,
+	    &QDBusServiceWatcher::serviceUnregistered,
+	    this,
+	    &StatusNotifierWatcher::onServiceUnregistered
+	);
+
+	this->serviceWatcher.setWatchMode(QDBusServiceWatcher::WatchForUnregistration);
+	this->serviceWatcher.addWatchedService("org.kde.StatusNotifierWatcher");
+	this->serviceWatcher.setConnection(bus);
+
+	this->tryRegister();
+}
+
+bool StatusNotifierWatcher::isRegistered() const { return this->registered; }
+
+void StatusNotifierWatcher::tryRegister() { // NOLINT
+	auto bus = QDBusConnection::sessionBus();
+	auto success = bus.registerService("org.kde.StatusNotifierWatcher");
+
+	if (success) {
+		qCDebug(logStatusNotifierWatcher) << "Registered watcher at org.kde.StatusNotifierWatcher";
+		this->registered = true;
+	} else {
+		qCDebug(logStatusNotifierWatcher)
+		    << "Could not register watcher at org.kde.StatusNotifierWatcher, presumably because one is "
+		       "already registered.";
+		qCDebug(logStatusNotifierWatcher)
+		    << "Registration will be attempted again if the active service is unregistered.";
+	}
+}
+
+void StatusNotifierWatcher::onServiceUnregistered(const QString& service) {
+	if (service == "org.kde.StatusNotifierWatcher") {
+		qCDebug(logStatusNotifierWatcher)
+		    << "Active StatusNotifierWatcher unregistered, attempting registration";
+		this->tryRegister();
+		return;
+	} else {
+		QString qualifiedItem;
+		this->items.removeIf([&](const QString& item) {
+			if (item.startsWith(service)) {
+				qualifiedItem = item;
+				return true;
+			} else return false;
+		});
+
+		if (!qualifiedItem.isEmpty()) {
+			qCDebug(logStatusNotifierWatcher).noquote()
+			    << "Unregistered StatusNotifierItem" << qualifiedItem << "from watcher";
+
+			emit this->StatusNotifierItemUnregistered(qualifiedItem);
+		} else if (this->hosts.removeAll(service) != 0) {
+			qCDebug(logStatusNotifierWatcher).noquote()
+			    << "Unregistered StatusNotifierHost" << service << "from watcher";
+			emit this->StatusNotifierHostUnregistered();
+		} else {
+			qCWarning(logStatusNotifierWatcher).noquote()
+			    << "Got service unregister event for untracked service" << service;
+		}
+	}
+
+	this->serviceWatcher.removeWatchedService(service);
+}
+
+bool StatusNotifierWatcher::isHostRegistered() const { // NOLINT
+	// no point ever returning false
+	return true;
+}
+
+QList<QString> StatusNotifierWatcher::registeredItems() const { return this->items; }
+
+void StatusNotifierWatcher::RegisterStatusNotifierHost(const QString& host) {
+	if (this->hosts.contains(host)) {
+		qCDebug(logStatusNotifierWatcher).noquote()
+		    << "Skipping duplicate registration of StatusNotifierHost" << host << "to watcher";
+		return;
+	}
+
+	if (!QDBusConnection::sessionBus().interface()->serviceOwner(host).isValid()) {
+		qCWarning(logStatusNotifierWatcher).noquote()
+		    << "Ignoring invalid StatusNotifierHost registration of" << host << "to watcher";
+		return;
+	}
+
+	this->serviceWatcher.addWatchedService(host);
+	this->hosts.push_back(host);
+	qCDebug(logStatusNotifierWatcher).noquote()
+	    << "Registered StatusNotifierHost" << host << "to watcher";
+	emit this->StatusNotifierHostRegistered();
+}
+
+void StatusNotifierWatcher::RegisterStatusNotifierItem(const QString& item) {
+	auto qualifiedItem = this->qualifiedItem(item);
+	auto service = qualifiedItem.split("/").at(0);
+
+	if (this->items.contains(qualifiedItem)) {
+		qCDebug(logStatusNotifierWatcher).noquote()
+		    << "Skipping duplicate registration of StatusNotifierItem" << qualifiedItem << "to watcher";
+		return;
+	}
+
+	if (!QDBusConnection::sessionBus().interface()->serviceOwner(service).isValid()) {
+		qCWarning(logStatusNotifierWatcher).noquote()
+		    << "Ignoring invalid StatusNotifierItem registration of" << qualifiedItem << "to watcher";
+		return;
+	}
+
+	this->serviceWatcher.addWatchedService(service);
+	this->items.push_back(qualifiedItem);
+
+	qCDebug(logStatusNotifierWatcher).noquote()
+	    << "Registered StatusNotifierItem" << qualifiedItem << "to watcher";
+
+	emit this->StatusNotifierItemRegistered(qualifiedItem);
+}
+
+QString StatusNotifierWatcher::qualifiedItem(const QString& item) {
+	// Registered items are often missing either the service id or the path.
+	QString qualifiedItem;
+	if (item.startsWith("/")) {
+		qualifiedItem = this->message().service() + item;
+	} else {
+		qualifiedItem = item;
+	}
+
+	if (!qualifiedItem.contains("/")) {
+		qualifiedItem += "/StatusNotifierItem";
+	}
+
+	return qualifiedItem;
+}
+
+StatusNotifierWatcher* StatusNotifierWatcher::instance() {
+	static StatusNotifierWatcher* instance = nullptr; // NOLINT
+	if (instance == nullptr) instance = new StatusNotifierWatcher();
+	return instance;
+}
+
+} // namespace qs::service::sni
diff --git a/src/services/status_notifier/watcher.hpp b/src/services/status_notifier/watcher.hpp
new file mode 100644
index 00000000..4f3c68f3
--- /dev/null
+++ b/src/services/status_notifier/watcher.hpp
@@ -0,0 +1,63 @@
+#pragma once
+
+#include <qdbuscontext.h>
+#include <qdbusinterface.h>
+#include <qdbusservicewatcher.h>
+#include <qlist.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/logcat.hpp"
+
+QS_DECLARE_LOGGING_CATEGORY(logStatusNotifierWatcher);
+
+namespace qs::service::sni {
+
+class StatusNotifierWatcher
+    : public QObject
+    , protected QDBusContext {
+	Q_OBJECT;
+	Q_PROPERTY(qint32 ProtocolVersion READ protocolVersion);
+	Q_PROPERTY(bool IsStatusNotifierHostRegistered READ isHostRegistered);
+	Q_PROPERTY(QList<QString> RegisteredStatusNotifierItems READ registeredItems);
+
+public:
+	explicit StatusNotifierWatcher(QObject* parent = nullptr);
+
+	void tryRegister();
+
+	[[nodiscard]] qint32 protocolVersion() const { return 0; } // NOLINT
+	[[nodiscard]] bool isHostRegistered() const;
+	[[nodiscard]] QList<QString> registeredItems() const;
+	[[nodiscard]] bool isRegistered() const;
+
+	// NOLINTBEGIN
+	void RegisterStatusNotifierHost(const QString& host);
+	void RegisterStatusNotifierItem(const QString& item);
+	// NOLINTEND
+
+	static StatusNotifierWatcher* instance();
+
+signals:
+	// NOLINTBEGIN
+	void StatusNotifierHostRegistered();
+	void StatusNotifierHostUnregistered();
+	void StatusNotifierItemRegistered(const QString& service);
+	void StatusNotifierItemUnregistered(const QString& service);
+	// NOLINTEND
+
+private slots:
+	void onServiceUnregistered(const QString& service);
+
+private:
+	QString qualifiedItem(const QString& item);
+
+	QDBusServiceWatcher serviceWatcher;
+	QList<QString> hosts;
+	QList<QString> items;
+	bool registered = false;
+};
+
+} // namespace qs::service::sni
diff --git a/src/services/upower/CMakeLists.txt b/src/services/upower/CMakeLists.txt
new file mode 100644
index 00000000..b18ec155
--- /dev/null
+++ b/src/services/upower/CMakeLists.txt
@@ -0,0 +1,45 @@
+set_source_files_properties(org.freedesktop.UPower.xml PROPERTIES
+	CLASSNAME DBusUPowerService
+	NO_NAMESPACE TRUE
+)
+
+qt_add_dbus_interface(DBUS_INTERFACES
+	org.freedesktop.UPower.xml
+	dbus_service
+)
+
+set_source_files_properties(org.freedesktop.UPower.Device.xml PROPERTIES
+	CLASSNAME DBusUPowerDevice
+	NO_NAMESPACE TRUE
+)
+
+qt_add_dbus_interface(DBUS_INTERFACES
+	org.freedesktop.UPower.Device.xml
+	dbus_device
+)
+
+qt_add_library(quickshell-service-upower STATIC
+	core.cpp
+	device.cpp
+	powerprofiles.cpp
+	${DBUS_INTERFACES}
+)
+
+# dbus headers
+target_include_directories(quickshell-service-upower PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+
+qt_add_qml_module(quickshell-service-upower
+	URI Quickshell.Services.UPower
+  VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+qs_add_module_deps_light(quickshell-service-upower Quickshell)
+
+install_qml_module(quickshell-service-upower)
+
+target_link_libraries(quickshell-service-upower PRIVATE Qt::Qml Qt::DBus)
+qs_add_link_dependencies(quickshell-service-upower quickshell-dbus)
+target_link_libraries(quickshell PRIVATE quickshell-service-upowerplugin)
+
+qs_module_pch(quickshell-service-upower SET dbus)
diff --git a/src/services/upower/core.cpp b/src/services/upower/core.cpp
new file mode 100644
index 00000000..0f9d9da0
--- /dev/null
+++ b/src/services/upower/core.cpp
@@ -0,0 +1,184 @@
+#include "core.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdbusconnection.h>
+#include <qdbusconnectioninterface.h>
+#include <qdbusextratypes.h>
+#include <qdbuspendingcall.h>
+#include <qdbuspendingreply.h>
+#include <qdbusservicewatcher.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qqmllist.h>
+
+#include "../../core/logcat.hpp"
+#include "../../core/model.hpp"
+#include "../../dbus/bus.hpp"
+#include "../../dbus/properties.hpp"
+#include "dbus_service.h"
+#include "device.hpp"
+
+namespace qs::service::upower {
+
+namespace {
+QS_LOGGING_CATEGORY(logUPower, "quickshell.service.upower", QtWarningMsg);
+}
+
+UPower::UPower() {
+	qCDebug(logUPower) << "Starting UPower Service";
+
+	auto bus = QDBusConnection::systemBus();
+
+	if (!bus.isConnected()) {
+		qCWarning(logUPower) << "Could not connect to DBus. UPower service will not work.";
+		return;
+	}
+
+	this->service =
+	    new DBusUPowerService("org.freedesktop.UPower", "/org/freedesktop/UPower", bus, this);
+
+	if (!this->service->isValid()) {
+		qCDebug(logUPower) << "UPower service is not currently running, attempting to start it.";
+
+		dbus::tryLaunchService(this, bus, "org.freedesktop.UPower", [this](bool success) {
+			if (success) {
+				qCDebug(logUPower) << "Successfully launched UPower service.";
+				this->init();
+			} else {
+				qCWarning(logUPower) << "Could not start UPower. The UPower service will not work.";
+			}
+		});
+	} else {
+		this->init();
+	}
+}
+
+void UPower::init() {
+	QObject::connect(this->service, &DBusUPowerService::DeviceAdded, this, &UPower::onDeviceAdded);
+
+	QObject::connect(
+	    this->service,
+	    &DBusUPowerService::DeviceRemoved,
+	    this,
+	    &UPower::onDeviceRemoved
+	);
+
+	this->serviceProperties.setInterface(this->service);
+	this->serviceProperties.updateAllViaGetAll();
+
+	this->registerDisplayDevice();
+	this->registerDevices();
+}
+
+void UPower::registerDevices() {
+	auto pending = this->service->EnumerateDevices();
+	auto* call = new QDBusPendingCallWatcher(pending, this);
+
+	auto responseCallback = [this](QDBusPendingCallWatcher* call) {
+		const QDBusPendingReply<QList<QDBusObjectPath>> reply = *call;
+
+		if (reply.isError()) {
+			qCWarning(logUPower) << "Failed to enumerate devices:" << reply.error().message();
+		} else {
+			for (const QDBusObjectPath& devicePath: reply.value()) {
+				this->registerDevice(devicePath.path());
+			}
+		}
+
+		delete call;
+	};
+
+	QObject::connect(call, &QDBusPendingCallWatcher::finished, this, responseCallback);
+}
+
+void UPower::registerDisplayDevice() {
+	auto pending = this->service->GetDisplayDevice();
+	auto* call = new QDBusPendingCallWatcher(pending, this);
+
+	auto responseCallback = [this](QDBusPendingCallWatcher* call) {
+		const QDBusPendingReply<QDBusObjectPath> reply = *call;
+
+		if (reply.isError()) {
+			qCWarning(logUPower) << "Failed to get default device:" << reply.error().message();
+		} else {
+			qCDebug(logUPower) << "UPower default device registered at" << reply.value().path();
+			this->mDisplayDevice.init(reply.value().path());
+		}
+
+		delete call;
+	};
+
+	QObject::connect(call, &QDBusPendingCallWatcher::finished, this, responseCallback);
+}
+
+void UPower::onDeviceAdded(const QDBusObjectPath& path) { this->registerDevice(path.path()); }
+
+void UPower::onDeviceRemoved(const QDBusObjectPath& path) {
+	auto iter = this->mDevices.find(path.path());
+
+	if (iter == this->mDevices.end()) {
+		qCWarning(logUPower) << "UPower service sent removal signal for" << path.path()
+		                     << "which is not registered.";
+	} else {
+		auto* device = iter.value();
+		this->mDevices.erase(iter);
+		this->readyDevices.removeObject(device);
+		qCDebug(logUPower) << "UPowerDevice" << device->path() << "removed.";
+	}
+}
+
+void UPower::onDeviceReady() {
+	auto* device = qobject_cast<UPowerDevice*>(this->sender());
+
+	this->readyDevices.insertObject(device);
+}
+
+void UPower::registerDevice(const QString& path) {
+	if (this->mDevices.contains(path)) {
+		qCDebug(logUPower) << "Skipping duplicate registration of UPowerDevice" << path;
+		return;
+	}
+
+	auto* device = new UPowerDevice(this);
+	device->init(path);
+
+	if (!device->isValid()) {
+		qCWarning(logUPower) << "Ignoring invalid UPowerDevice registration of" << path;
+		delete device;
+		return;
+	}
+
+	this->mDevices.insert(path, device);
+	QObject::connect(device, &UPowerDevice::readyChanged, this, &UPower::onDeviceReady);
+
+	qCDebug(logUPower) << "Registered UPowerDevice" << path;
+}
+
+UPowerDevice* UPower::displayDevice() { return &this->mDisplayDevice; }
+
+ObjectModel<UPowerDevice>* UPower::devices() { return &this->readyDevices; }
+
+UPower* UPower::instance() {
+	static UPower* instance = new UPower(); // NOLINT
+	return instance;
+}
+
+UPowerQml::UPowerQml(QObject* parent): QObject(parent) {
+	QObject::connect(
+	    UPower::instance(),
+	    &UPower::onBatteryChanged,
+	    this,
+	    &UPowerQml::onBatteryChanged
+	);
+}
+
+UPowerDevice* UPowerQml::displayDevice() { // NOLINT
+	return UPower::instance()->displayDevice();
+}
+
+ObjectModel<UPowerDevice>* UPowerQml::devices() { // NOLINT
+	return UPower::instance()->devices();
+}
+
+} // namespace qs::service::upower
diff --git a/src/services/upower/core.hpp b/src/services/upower/core.hpp
new file mode 100644
index 00000000..62fca1d9
--- /dev/null
+++ b/src/services/upower/core.hpp
@@ -0,0 +1,97 @@
+#pragma once
+
+#include <qdbusextratypes.h>
+#include <qdbusservicewatcher.h>
+#include <qhash.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+
+#include "../../core/doc.hpp"
+#include "../../core/model.hpp"
+#include "../../dbus/properties.hpp"
+#include "dbus_service.h"
+#include "device.hpp"
+
+namespace qs::service::upower {
+
+class UPower: public QObject {
+	Q_OBJECT;
+
+public:
+	[[nodiscard]] UPowerDevice* displayDevice();
+	[[nodiscard]] ObjectModel<UPowerDevice>* devices();
+	[[nodiscard]] QBindable<bool> bindableOnBattery() const { return &this->bOnBattery; }
+
+	static UPower* instance();
+
+signals:
+	void onBatteryChanged();
+
+private slots:
+	void onDeviceAdded(const QDBusObjectPath& path);
+	void onDeviceRemoved(const QDBusObjectPath& path);
+	void onDeviceReady();
+
+private:
+	explicit UPower();
+
+	void init();
+	void registerDevices();
+	void registerDisplayDevice();
+	void registerDevice(const QString& path);
+
+	UPowerDevice mDisplayDevice {this};
+	QHash<QString, UPowerDevice*> mDevices;
+	ObjectModel<UPowerDevice> readyDevices {this};
+
+	Q_OBJECT_BINDABLE_PROPERTY(UPower, bool, bOnBattery, &UPower::onBatteryChanged);
+
+	QS_DBUS_BINDABLE_PROPERTY_GROUP(UPower, serviceProperties);
+	QS_DBUS_PROPERTY_BINDING(UPower, pOnBattery, bOnBattery, serviceProperties, "OnBattery");
+
+	DBusUPowerService* service = nullptr;
+};
+
+///! Provides access to the UPower service.
+/// An interface to the [UPower daemon], which can be used to
+/// view battery and power statistics for your computer and
+/// connected devices.
+///
+/// > [!NOTE] The UPower daemon must be installed to use this service.
+///
+/// [UPower daemon]: https://upower.freedesktop.org
+class UPowerQml: public QObject {
+	Q_OBJECT;
+	QML_NAMED_ELEMENT(UPower);
+	QML_SINGLETON;
+	// clang-format off
+	/// UPower's DisplayDevice for your system. Cannot be null,
+	/// but might not be initialized (check @@UPowerDevice.ready if you need to know).
+	///
+	/// This is an aggregate device and not a physical one, meaning you will not find it in @@devices.
+	/// It is typically the device that is used for displaying information in desktop environments.
+	Q_PROPERTY(qs::service::upower::UPowerDevice* displayDevice READ displayDevice CONSTANT);
+	/// All connected UPower devices.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::service::upower::UPowerDevice>*);
+	Q_PROPERTY(UntypedObjectModel* devices READ devices CONSTANT);
+	/// If the system is currently running on battery power, or discharging.
+	Q_PROPERTY(bool onBattery READ default NOTIFY onBatteryChanged BINDABLE bindableOnBattery);
+	// clang-format on
+
+public:
+	explicit UPowerQml(QObject* parent = nullptr);
+
+	[[nodiscard]] UPowerDevice* displayDevice();
+	[[nodiscard]] ObjectModel<UPowerDevice>* devices();
+
+	[[nodiscard]] static QBindable<bool> bindableOnBattery() {
+		return UPower::instance()->bindableOnBattery();
+	}
+
+signals:
+	void onBatteryChanged();
+};
+
+} // namespace qs::service::upower
diff --git a/src/services/upower/device.cpp b/src/services/upower/device.cpp
new file mode 100644
index 00000000..2492b1fc
--- /dev/null
+++ b/src/services/upower/device.cpp
@@ -0,0 +1,140 @@
+#include "device.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdbusconnection.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qstring.h>
+#include <qtypes.h>
+
+#include "../../core/logcat.hpp"
+#include "../../dbus/properties.hpp"
+#include "dbus_device.h"
+
+using namespace qs::dbus;
+
+namespace qs::service::upower {
+
+namespace {
+QS_LOGGING_CATEGORY(logUPowerDevice, "quickshell.service.upower.device", QtWarningMsg);
+}
+
+QString UPowerDeviceState::toString(UPowerDeviceState::Enum status) {
+	switch (status) {
+	case UPowerDeviceState::Unknown: return "Unknown";
+	case UPowerDeviceState::Charging: return "Charging";
+	case UPowerDeviceState::Discharging: return "Discharging";
+	case UPowerDeviceState::Empty: return "Empty";
+	case UPowerDeviceState::FullyCharged: return "Fully Charged";
+	case UPowerDeviceState::PendingCharge: return "Pending Charge";
+	case UPowerDeviceState::PendingDischarge: return "Pending Discharge";
+	default: return "Invalid Status";
+	}
+}
+
+QString UPowerDeviceType::toString(UPowerDeviceType::Enum type) {
+	switch (type) {
+	case UPowerDeviceType::Unknown: return "Unknown";
+	case UPowerDeviceType::LinePower: return "Line Power";
+	case UPowerDeviceType::Battery: return "Battery";
+	case UPowerDeviceType::Ups: return "Ups";
+	case UPowerDeviceType::Monitor: return "Monitor";
+	case UPowerDeviceType::Mouse: return "Mouse";
+	case UPowerDeviceType::Keyboard: return "Keyboard";
+	case UPowerDeviceType::Pda: return "Pda";
+	case UPowerDeviceType::Phone: return "Phone";
+	case UPowerDeviceType::MediaPlayer: return "Media Player";
+	case UPowerDeviceType::Tablet: return "Tablet";
+	case UPowerDeviceType::Computer: return "Computer";
+	case UPowerDeviceType::GamingInput: return "Gaming Input";
+	case UPowerDeviceType::Pen: return "Pen";
+	case UPowerDeviceType::Touchpad: return "Touchpad";
+	case UPowerDeviceType::Modem: return "Modem";
+	case UPowerDeviceType::Network: return "Network";
+	case UPowerDeviceType::Headset: return "Headset";
+	case UPowerDeviceType::Speakers: return "Speakers";
+	case UPowerDeviceType::Headphones: return "Headphones";
+	case UPowerDeviceType::Video: return "Video";
+	case UPowerDeviceType::OtherAudio: return "Other Audio";
+	case UPowerDeviceType::RemoteControl: return "Remote Control";
+	case UPowerDeviceType::Printer: return "Printer";
+	case UPowerDeviceType::Scanner: return "Scanner";
+	case UPowerDeviceType::Camera: return "Camera";
+	case UPowerDeviceType::Wearable: return "Wearable";
+	case UPowerDeviceType::Toy: return "Toy";
+	case UPowerDeviceType::BluetoothGeneric: return "Bluetooth Generic";
+	default: return "Invalid Type";
+	}
+}
+
+UPowerDevice::UPowerDevice(QObject* parent): QObject(parent) {
+	this->bIsLaptopBattery.setBinding([this]() {
+		return this->bType == UPowerDeviceType::Battery && this->bPowerSupply;
+	});
+
+	this->bHealthSupported.setBinding([this]() { return this->bHealthPercentage != 0; });
+}
+
+void UPowerDevice::init(const QString& path) {
+	this->device =
+	    new DBusUPowerDevice("org.freedesktop.UPower", path, QDBusConnection::systemBus(), this);
+
+	if (!this->device->isValid()) {
+		qCWarning(logUPowerDevice) << "Cannot create UPowerDevice for" << path;
+		return;
+	}
+
+	QObject::connect(
+	    &this->deviceProperties,
+	    &DBusPropertyGroup::getAllFinished,
+	    this,
+	    &UPowerDevice::onGetAllFinished
+	);
+
+	this->deviceProperties.setInterface(this->device);
+	this->deviceProperties.updateAllViaGetAll();
+}
+
+bool UPowerDevice::isValid() const { return this->device && this->device->isValid(); }
+QString UPowerDevice::address() const { return this->device ? this->device->service() : QString(); }
+QString UPowerDevice::path() const { return this->device ? this->device->path() : QString(); }
+
+void UPowerDevice::onGetAllFinished() {
+	qCDebug(logUPowerDevice) << "UPowerDevice" << device->path() << "ready.";
+	this->bReady = true;
+}
+
+} // namespace qs::service::upower
+
+namespace qs::dbus {
+
+using namespace qs::service::upower;
+
+DBusResult<qreal> DBusDataTransform<PowerPercentage>::fromWire(qreal wire) {
+	return DBusResult(wire * 0.01);
+}
+
+DBusResult<UPowerDeviceState::Enum>
+DBusDataTransform<UPowerDeviceState::Enum>::fromWire(quint32 wire) {
+	if (wire >= UPowerDeviceState::Unknown && wire <= UPowerDeviceState::PendingDischarge) {
+		return DBusResult(static_cast<UPowerDeviceState::Enum>(wire));
+	}
+
+	return DBusResult<UPowerDeviceState::Enum>(
+	    QDBusError(QDBusError::InvalidArgs, QString("Invalid UPowerDeviceState: %1").arg(wire))
+	);
+}
+
+DBusResult<UPowerDeviceType::Enum> DBusDataTransform<UPowerDeviceType::Enum>::fromWire(quint32 wire
+) {
+	if (wire >= UPowerDeviceType::Unknown && wire <= UPowerDeviceType::BluetoothGeneric) {
+		return DBusResult(static_cast<UPowerDeviceType::Enum>(wire));
+	}
+
+	return DBusResult<UPowerDeviceType::Enum>(
+	    QDBusError(QDBusError::InvalidArgs, QString("Invalid UPowerDeviceType: %1").arg(wire))
+	);
+}
+
+} // namespace qs::dbus
diff --git a/src/services/upower/device.hpp b/src/services/upower/device.hpp
new file mode 100644
index 00000000..a4fbe836
--- /dev/null
+++ b/src/services/upower/device.hpp
@@ -0,0 +1,259 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/doc.hpp"
+#include "../../dbus/properties.hpp"
+#include "dbus_device.h"
+
+namespace qs::service::upower {
+
+///! Power state of a UPower device.
+/// See @@UPowerDevice.state.
+class UPowerDeviceState: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		Unknown = 0,
+		Charging = 1,
+		Discharging = 2,
+		Empty = 3,
+		FullyCharged = 4,
+		/// The device is waiting to be charged after it was plugged in.
+		PendingCharge = 5,
+		/// The device is waiting to be discharged after being unplugged.
+		PendingDischarge = 6,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(qs::service::upower::UPowerDeviceState::Enum status);
+};
+
+///! Type of a UPower device.
+/// See @@UPowerDevice.type.
+class UPowerDeviceType: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		Unknown = 0,
+		LinePower = 1,
+		Battery = 2,
+		Ups = 3,
+		Monitor = 4,
+		Mouse = 5,
+		Keyboard = 6,
+		Pda = 7,
+		Phone = 8,
+		MediaPlayer = 9,
+		Tablet = 10,
+		Computer = 11,
+		GamingInput = 12,
+		Pen = 13,
+		Touchpad = 14,
+		Modem = 15,
+		Network = 16,
+		Headset = 17,
+		Speakers = 18,
+		Headphones = 19,
+		Video = 20,
+		OtherAudio = 21,
+		RemoteControl = 22,
+		Printer = 23,
+		Scanner = 24,
+		Camera = 25,
+		Wearable = 26,
+		Toy = 27,
+		BluetoothGeneric = 28,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(qs::service::upower::UPowerDeviceType::Enum type);
+};
+
+struct PowerPercentage;
+
+} // namespace qs::service::upower
+
+namespace qs::dbus {
+
+template <>
+struct DBusDataTransform<qs::service::upower::UPowerDeviceState::Enum> {
+	using Wire = quint32;
+	using Data = qs::service::upower::UPowerDeviceState::Enum;
+	static DBusResult<Data> fromWire(Wire wire);
+};
+
+template <>
+struct DBusDataTransform<qs::service::upower::UPowerDeviceType::Enum> {
+	using Wire = quint32;
+	using Data = qs::service::upower::UPowerDeviceType::Enum;
+	static DBusResult<Data> fromWire(Wire wire);
+};
+
+template <>
+struct DBusDataTransform<qs::service::upower::PowerPercentage> {
+	using Wire = qreal;
+	using Data = qreal;
+	static DBusResult<Data> fromWire(Wire wire);
+};
+
+} // namespace qs::dbus
+
+namespace qs::service::upower {
+
+///! A device exposed through the UPower system service.
+class UPowerDevice: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// The type of device.
+	Q_PROPERTY(qs::service::upower::UPowerDeviceType::Enum type READ default NOTIFY typeChanged BINDABLE bindableType);
+	/// If the device is a power supply for your computer and can provide charge.
+	Q_PROPERTY(bool powerSupply READ default NOTIFY powerSupplyChanged BINDABLE bindablePowerSupply);
+	/// Current energy level of the device in watt-hours.
+	Q_PROPERTY(qreal energy READ default NOTIFY energyChanged BINDABLE bindableEnergy);
+	/// Maximum energy capacity of the device in watt-hours
+	Q_PROPERTY(qreal energyCapacity READ default NOTIFY energyCapacityChanged BINDABLE bindableEnergyCapacity);
+	/// Rate of energy change in watts (positive when charging, negative when discharging).
+	Q_PROPERTY(qreal changeRate READ default NOTIFY changeRateChanged BINDABLE bindableChangeRate);
+	/// Estimated time until the device is fully discharged, in seconds.
+	///
+	/// Will be set to `0` if charging.
+	Q_PROPERTY(qreal timeToEmpty READ default NOTIFY timeToEmptyChanged BINDABLE bindableTimeToEmpty);
+	/// Estimated time until the device is fully charged, in seconds.
+	///
+	/// Will be set to `0` if discharging.
+	Q_PROPERTY(qreal timeToFull READ default NOTIFY timeToFullChanged BINDABLE bindableTimeToFull);
+	/// Current charge level as a percentage.
+	///
+	/// This would be equivalent to @@energy / @@energyCapacity.
+	Q_PROPERTY(qreal percentage READ default NOTIFY percentageChanged BINDABLE bindablePercentage);
+	/// If the power source is present in the bay or slot, useful for hot-removable batteries.
+	///
+	/// If the device `type` is not `Battery`, then the property will be invalid.
+	Q_PROPERTY(bool isPresent READ default NOTIFY isPresentChanged BINDABLE bindableIsPresent);
+	/// Current state of the device.
+	Q_PROPERTY(qs::service::upower::UPowerDeviceState::Enum state READ default NOTIFY stateChanged BINDABLE bindableState);
+	/// Health of the device as a percentage of its original health.
+	Q_PROPERTY(qreal healthPercentage READ default NOTIFY healthPercentageChanged BINDABLE bindableHealthPercentage);
+	Q_PROPERTY(bool healthSupported READ default NOTIFY healthSupportedChanged BINDABLE bindableHealthSupported);
+	/// Name of the icon representing the current state of the device, or an empty string if not provided.
+	Q_PROPERTY(QString iconName READ default NOTIFY iconNameChanged BINDABLE bindableIconName);
+	/// If the device is a laptop battery or not. Use this to check if your device is a valid battery.
+	///
+	/// This will be equivalent to @@type == Battery && @@powerSupply == true.
+	Q_PROPERTY(bool isLaptopBattery READ default NOTIFY isLaptopBatteryChanged BINDABLE bindableIsLaptopBattery);
+	/// Native path of the device specific to your OS.
+	Q_PROPERTY(QString nativePath READ default NOTIFY nativePathChanged BINDABLE bindableNativePath);
+	/// Model name of the device. Unlikely to be useful for internal devices.
+	Q_PROPERTY(QString model READ default NOTIFY modelChanged BINDABLE bindableModel);
+	/// If device statistics have been queried for this device yet.
+  /// This will be true for all devices returned from @@UPower.devices, but not the default
+  /// device, which may be returned before it is ready to avoid returning null.
+	Q_PROPERTY(bool ready READ default NOTIFY readyChanged BINDABLE bindableReady);
+	// clang-format on
+	QML_ELEMENT;
+	QML_UNCREATABLE("UPowerDevices can only be acquired from UPower");
+
+public:
+	explicit UPowerDevice(QObject* parent = nullptr);
+
+	void init(const QString& path);
+
+	[[nodiscard]] bool isValid() const;
+	[[nodiscard]] QString address() const;
+	[[nodiscard]] QString path() const;
+
+	[[nodiscard]] QBindable<UPowerDeviceType::Enum> bindableType() const { return &this->bType; }
+	[[nodiscard]] QBindable<bool> bindablePowerSupply() const { return &this->bPowerSupply; }
+	[[nodiscard]] QBindable<qreal> bindableEnergy() const { return &this->bEnergy; }
+	[[nodiscard]] QBindable<qreal> bindableEnergyCapacity() const { return &this->bEnergyCapacity; }
+	[[nodiscard]] QBindable<qreal> bindableChangeRate() const { return &this->bChangeRate; }
+	[[nodiscard]] QBindable<qlonglong> bindableTimeToEmpty() const { return &this->bTimeToEmpty; }
+	[[nodiscard]] QBindable<qlonglong> bindableTimeToFull() const { return &this->bTimeToFull; }
+	[[nodiscard]] QBindable<qreal> bindablePercentage() const { return &this->bPercentage; }
+	[[nodiscard]] QBindable<bool> bindableIsPresent() const { return &this->bIsPresent; }
+	[[nodiscard]] QBindable<UPowerDeviceState::Enum> bindableState() const { return &this->bState; }
+	[[nodiscard]] QBindable<qreal> bindableHealthPercentage() const {
+		return &this->bHealthPercentage;
+	}
+	[[nodiscard]] QBindable<bool> bindableHealthSupported() const { return &this->bHealthSupported; }
+	[[nodiscard]] QBindable<QString> bindableIconName() const { return &this->bIconName; }
+	[[nodiscard]] QBindable<bool> bindableIsLaptopBattery() const { return &this->bIsLaptopBattery; }
+	[[nodiscard]] QBindable<QString> bindableNativePath() const { return &this->bNativePath; }
+	[[nodiscard]] QBindable<QString> bindableModel() const { return &this->bModel; }
+	[[nodiscard]] QBindable<bool> bindableReady() const { return &this->bReady; }
+
+signals:
+	QSDOC_HIDE void readyChanged();
+
+	void typeChanged();
+	void powerSupplyChanged();
+	void energyChanged();
+	void energyCapacityChanged();
+	void changeRateChanged();
+	void timeToEmptyChanged();
+	void timeToFullChanged();
+	void percentageChanged();
+	void isPresentChanged();
+	void stateChanged();
+	void healthPercentageChanged();
+	void healthSupportedChanged();
+	void iconNameChanged();
+	void isLaptopBatteryChanged();
+	void nativePathChanged();
+	void modelChanged();
+
+private slots:
+	void onGetAllFinished();
+
+private:
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, UPowerDeviceType::Enum, bType, &UPowerDevice::typeChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, bool, bPowerSupply, &UPowerDevice::powerSupplyChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, qreal, bEnergy, &UPowerDevice::energyChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, qreal, bEnergyCapacity, &UPowerDevice::energyCapacityChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, qreal, bChangeRate, &UPowerDevice::changeRateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, qlonglong, bTimeToEmpty, &UPowerDevice::timeToEmptyChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, qlonglong, bTimeToFull, &UPowerDevice::timeToFullChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, qreal, bPercentage, &UPowerDevice::percentageChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, bool, bIsPresent, &UPowerDevice::isPresentChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, UPowerDeviceState::Enum, bState, &UPowerDevice::stateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, qreal, bHealthPercentage, &UPowerDevice::healthPercentageChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, bool, bHealthSupported, &UPowerDevice::healthSupportedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, QString, bIconName, &UPowerDevice::iconNameChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, bool, bIsLaptopBattery, &UPowerDevice::isLaptopBatteryChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, QString, bNativePath, &UPowerDevice::nativePathChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, QString, bModel, &UPowerDevice::modelChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(UPowerDevice, bool, bReady, &UPowerDevice::readyChanged);
+
+	QS_DBUS_BINDABLE_PROPERTY_GROUP(UPowerDevice, deviceProperties);
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, pType, bType, deviceProperties, "Type");
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, pPowerSupply, bPowerSupply, deviceProperties, "PowerSupply");
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, pEnergy, bEnergy, deviceProperties, "Energy");
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, pEnergyCapacity, bEnergyCapacity, deviceProperties, "EnergyFull");
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, pChangeRate, bChangeRate, deviceProperties, "EnergyRate");
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, pTimeToEmpty, bTimeToEmpty, deviceProperties, "TimeToEmpty");
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, pTimeToFull, bTimeToFull, deviceProperties, "TimeToFull");
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, PowerPercentage, pPercentage, bPercentage, deviceProperties, "Percentage", true);
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, pIsPresent, bIsPresent, deviceProperties, "IsPresent");
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, pState, bState, deviceProperties, "State");
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, pHealthPercentage, bHealthPercentage, deviceProperties, "Capacity");
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, pIconName, bIconName, deviceProperties, "IconName");
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, pNativePath, bNativePath, deviceProperties, "NativePath");
+	QS_DBUS_PROPERTY_BINDING(UPowerDevice, pModel, bModel, deviceProperties, "Model");
+	// clang-format on
+
+	DBusUPowerDevice* device = nullptr;
+};
+
+} // namespace qs::service::upower
diff --git a/src/services/upower/module.md b/src/services/upower/module.md
new file mode 100644
index 00000000..e1d697fe
--- /dev/null
+++ b/src/services/upower/module.md
@@ -0,0 +1,8 @@
+name = "Quickshell.Services.UPower"
+description = "UPower Service"
+headers = [
+	"core.hpp",
+	"device.hpp",
+	"powerprofiles.hpp",
+]
+-----
diff --git a/src/services/upower/org.freedesktop.UPower.Device.xml b/src/services/upower/org.freedesktop.UPower.Device.xml
new file mode 100644
index 00000000..ef98a30a
--- /dev/null
+++ b/src/services/upower/org.freedesktop.UPower.Device.xml
@@ -0,0 +1,16 @@
+<node>
+	<interface name="org.freedesktop.UPower.Device">
+		<property name="Type" type="u" access="read"/>
+		<property name="PowerSupply" type="b" access="read"/>
+		<property name="Energy" type="d" access="read"/>
+		<property name="EnergyFull" type="d" access="read"/>
+		<property name="EnergyRate" type="d" access="read"/>
+		<property name="TimeToEmpty" type="x" access="read"/>
+		<property name="TimeToFull" type="x" access="read"/>
+		<property name="Percentage" type="d" access="read"/>
+		<property name="IsPresent" type="b" access="read"/>
+		<property name="State" type="u" access="read"/>
+		<property name="Capacity" type = "d" access="read"/>
+		<property name="IconName" type="s" access="read"/>
+	</interface>
+</node>
diff --git a/src/services/upower/org.freedesktop.UPower.xml b/src/services/upower/org.freedesktop.UPower.xml
new file mode 100644
index 00000000..5ea471f5
--- /dev/null
+++ b/src/services/upower/org.freedesktop.UPower.xml
@@ -0,0 +1,17 @@
+<node>
+	<interface name="org.freedesktop.UPower">
+		<method name="EnumerateDevices">
+			<arg direction="out" type="ao" name="devices"/>
+		</method>
+		<method name="GetDisplayDevice">
+			<arg direction="out" type="o" name="devices"/>
+		</method>
+
+		<signal name="DeviceAdded">
+			<arg direction="out" type="o" name="device"/>
+		</signal>
+		<signal name="DeviceRemoved">
+			<arg direction="out" type="o" name="device"/>
+		</signal>
+	</interface>
+</node>
diff --git a/src/services/upower/powerprofiles.cpp b/src/services/upower/powerprofiles.cpp
new file mode 100644
index 00000000..4c407989
--- /dev/null
+++ b/src/services/upower/powerprofiles.cpp
@@ -0,0 +1,220 @@
+#include "powerprofiles.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdbusconnection.h>
+#include <qdbuserror.h>
+#include <qdbusinterface.h>
+#include <qdbusmetatype.h>
+#include <qdebug.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qstringliteral.h>
+
+#include "../../core/logcat.hpp"
+#include "../../dbus/bus.hpp"
+#include "../../dbus/properties.hpp"
+
+namespace qs::service::upower {
+
+namespace {
+QS_LOGGING_CATEGORY(logPowerProfiles, "quickshell.service.powerprofiles", QtWarningMsg);
+}
+
+QString PowerProfile::toString(PowerProfile::Enum profile) {
+	switch (profile) {
+	case PowerProfile::PowerSaver: return QStringLiteral("PowerSaver");
+	case PowerProfile::Balanced: return QStringLiteral("Balanced");
+	case PowerProfile::Performance: return QStringLiteral("Performance");
+	default: return QStringLiteral("Invalid");
+	}
+}
+
+QString PerformanceDegradationReason::toString(PerformanceDegradationReason::Enum reason) {
+	switch (reason) {
+	case PerformanceDegradationReason::LapDetected: return QStringLiteral("LapDetected");
+	case PerformanceDegradationReason::HighTemperature: return QStringLiteral("HighTemperature");
+	default: return QStringLiteral("Invalid");
+	}
+}
+
+bool PowerProfileHold::operator==(const PowerProfileHold& other) const {
+	return other.profile == this->profile && other.applicationId == this->applicationId
+	    && other.reason == this->reason;
+}
+
+QDebug& operator<<(QDebug& debug, const PowerProfileHold& hold) {
+	auto saver = QDebugStateSaver(debug);
+
+	debug.nospace();
+	debug << "PowerProfileHold(profile=" << hold.profile << ", applicationId=" << hold.applicationId
+	      << ", reason=" << hold.reason << ')';
+
+	return debug;
+}
+
+PowerProfiles::PowerProfiles() {
+	qDBusRegisterMetaType<QList<QVariantMap>>();
+
+	this->bHasPerformanceProfile.setBinding([this]() {
+		return this->bProfiles.value().contains(PowerProfile::Performance);
+	});
+
+	qCDebug(logPowerProfiles) << "Starting PowerProfiles Service.";
+
+	auto bus = QDBusConnection::systemBus();
+
+	if (!bus.isConnected()) {
+		qCWarning(logPowerProfiles
+		) << "Could not connect to DBus. PowerProfiles services will not work.";
+	}
+
+	this->service = new QDBusInterface(
+	    "org.freedesktop.UPower.PowerProfiles",
+	    "/org/freedesktop/UPower/PowerProfiles",
+	    "org.freedesktop.UPower.PowerProfiles",
+	    bus,
+	    this
+	);
+
+	if (!this->service->isValid()) {
+		qCDebug(logPowerProfiles
+		) << "PowerProfilesDaemon is not currently running, attempting to start it.";
+
+		dbus::tryLaunchService(this, bus, "org.freedesktop.UPower.PowerProfiles", [this](bool success) {
+			if (success) {
+				qCDebug(logPowerProfiles) << "Successfully launched PowerProfiles service.";
+				this->init();
+			} else {
+				qCWarning(logPowerProfiles)
+				    << "Could not start PowerProfilesDaemon. The PowerProfiles service will not work.";
+			}
+		});
+	} else {
+		this->init();
+	}
+}
+
+void PowerProfiles::init() {
+	this->properties.setInterface(this->service);
+	this->properties.updateAllViaGetAll();
+}
+
+void PowerProfiles::setProfile(PowerProfile::Enum profile) {
+	if (!this->properties.isConnected()) {
+		qCCritical(logPowerProfiles
+		) << "Cannot set power profile: power-profiles-daemon not accessible or not running";
+		return;
+	}
+
+	if (profile == PowerProfile::Performance && !this->bHasPerformanceProfile) {
+		qCCritical(logPowerProfiles
+		) << "Cannot request performance profile as it is not present for this device.";
+		return;
+	} else if (profile < PowerProfile::PowerSaver || profile > PowerProfile::Performance) {
+		qCCritical(logPowerProfiles) << "Tried to request invalid power profile" << profile;
+		return;
+	}
+
+	this->bProfile = profile;
+	this->pProfile.write();
+}
+
+PowerProfiles* PowerProfiles::instance() {
+	static auto* instance = new PowerProfiles(); // NOLINT
+	return instance;
+}
+
+PowerProfilesQml::PowerProfilesQml(QObject* parent): QObject(parent) {
+	auto* instance = PowerProfiles::instance();
+
+	this->bProfile.setBinding([instance]() { return instance->bProfile.value(); });
+
+	this->bHasPerformanceProfile.setBinding([instance]() {
+		return instance->bHasPerformanceProfile.value();
+	});
+
+	this->bDegradationReason.setBinding([instance]() { return instance->bDegradationReason.value(); }
+	);
+
+	this->bHolds.setBinding([instance]() { return instance->bHolds.value(); });
+}
+
+} // namespace qs::service::upower
+
+namespace qs::dbus {
+
+using namespace qs::service::upower;
+
+DBusResult<PowerProfile::Enum> DBusDataTransform<PowerProfile::Enum>::fromWire(const Wire& wire) {
+	if (wire == QStringLiteral("power-saver")) {
+		return PowerProfile::PowerSaver;
+	} else if (wire == QStringLiteral("balanced")) {
+		return PowerProfile::Balanced;
+	} else if (wire == QStringLiteral("performance")) {
+		return PowerProfile::Performance;
+	} else {
+		return QDBusError(QDBusError::InvalidArgs, QString("Invalid PowerProfile: %1").arg(wire));
+	}
+}
+
+QString DBusDataTransform<PowerProfile::Enum>::toWire(Data data) {
+	switch (data) {
+	case PowerProfile::PowerSaver: return QStringLiteral("power-saver");
+	case PowerProfile::Balanced: return QStringLiteral("balanced");
+	case PowerProfile::Performance: return QStringLiteral("performance");
+	}
+}
+
+DBusResult<QList<PowerProfile::Enum>>
+DBusDataTransform<QList<PowerProfile::Enum>>::fromWire(const Wire& wire) {
+	QList<PowerProfile::Enum> profiles;
+
+	for (const auto& entry: wire) {
+		auto profile =
+		    DBusDataTransform<PowerProfile::Enum>::fromWire(entry.value("Profile").value<QString>());
+
+		if (!profile.isValid()) return profile.error;
+		profiles.append(profile.value);
+	}
+
+	return profiles;
+}
+
+DBusResult<PerformanceDegradationReason::Enum>
+DBusDataTransform<PerformanceDegradationReason::Enum>::fromWire(const Wire& wire) {
+	if (wire.isEmpty()) {
+		return PerformanceDegradationReason::None;
+	} else if (wire == QStringLiteral("lap-detected")) {
+		return PerformanceDegradationReason::LapDetected;
+	} else if (wire == QStringLiteral("high-operating-temperature")) {
+		return PerformanceDegradationReason::HighTemperature;
+	} else {
+		return QDBusError(
+		    QDBusError::InvalidArgs,
+		    QString("Invalid PerformanceDegradationReason: %1").arg(wire)
+		);
+	}
+}
+
+DBusResult<QList<PowerProfileHold>>
+DBusDataTransform<QList<PowerProfileHold>>::fromWire(const Wire& wire) {
+	QList<PowerProfileHold> holds;
+
+	for (const auto& entry: wire) {
+		auto profile =
+		    DBusDataTransform<PowerProfile::Enum>::fromWire(entry.value("Profile").value<QString>());
+
+		if (!profile.isValid()) return profile.error;
+
+		auto applicationId = entry.value("ApplicationId").value<QString>();
+		auto reason = entry.value("Reason").value<QString>();
+
+		holds.append(PowerProfileHold(profile.value, applicationId, reason));
+	}
+
+	return holds;
+}
+
+} // namespace qs::dbus
diff --git a/src/services/upower/powerprofiles.hpp b/src/services/upower/powerprofiles.hpp
new file mode 100644
index 00000000..b7340328
--- /dev/null
+++ b/src/services/upower/powerprofiles.hpp
@@ -0,0 +1,237 @@
+#pragma once
+
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qdbusinterface.h>
+#include <qdebug.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../dbus/properties.hpp"
+
+namespace qs::service::upower {
+
+///! Power profile exposed by the PowerProfiles service.
+/// See @@PowerProfiles.
+class PowerProfile: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		/// This profile will limit system performance in order to save power.
+		PowerSaver = 0,
+		/// This profile is the default, and will attempt to strike a balance
+		/// between performance and power consumption.
+		Balanced = 1,
+		/// This profile will maximize performance at the cost of power consumption.
+		Performance = 2,
+	};
+	Q_ENUM(Enum);
+
+	Q_INVOKABLE static QString toString(qs::service::upower::PowerProfile::Enum profile);
+};
+
+///! Reason for performance degradation exposed by the PowerProfiles service.
+/// See @@PowerProfiles.degradationReason for more information.
+class PerformanceDegradationReason: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		/// Performance has not been degraded in a way power-profiles-daemon can detect.
+		None = 0,
+		/// Performance has been reduced due to the computer's lap detection function,
+		/// which attempts to keep the computer from getting too hot while on your lap.
+		LapDetected = 1,
+		/// Performance has been reduced due to high system temperatures.
+		HighTemperature = 2,
+	};
+	Q_ENUM(Enum);
+
+	// clang-format off
+	Q_INVOKABLE static QString toString(qs::service::upower::PerformanceDegradationReason::Enum reason);
+	// clang-format on
+};
+
+class PowerProfileHold;
+
+} // namespace qs::service::upower
+
+namespace qs::dbus {
+
+template <>
+struct DBusDataTransform<qs::service::upower::PowerProfile::Enum> {
+	using Wire = QString;
+	using Data = qs::service::upower::PowerProfile::Enum;
+	static DBusResult<Data> fromWire(const Wire& wire);
+	static Wire toWire(Data data);
+};
+
+template <>
+struct DBusDataTransform<QList<qs::service::upower::PowerProfile::Enum>> {
+	using Wire = QList<QVariantMap>;
+	using Data = QList<qs::service::upower::PowerProfile::Enum>;
+	static DBusResult<Data> fromWire(const Wire& wire);
+};
+
+template <>
+struct DBusDataTransform<qs::service::upower::PerformanceDegradationReason::Enum> {
+	using Wire = QString;
+	using Data = qs::service::upower::PerformanceDegradationReason::Enum;
+	static DBusResult<Data> fromWire(const Wire& wire);
+};
+
+template <>
+struct DBusDataTransform<QList<qs::service::upower::PowerProfileHold>> {
+	using Wire = QList<QVariantMap>;
+	using Data = QList<qs::service::upower::PowerProfileHold>;
+	static DBusResult<Data> fromWire(const Wire& wire);
+};
+
+} // namespace qs::dbus
+
+namespace qs::service::upower {
+
+// docgen can't hit gadgets yet
+class PowerProfileHold {
+	Q_GADGET;
+	QML_VALUE_TYPE(powerProfileHold);
+	Q_PROPERTY(qs::service::upower::PowerProfile::Enum profile MEMBER profile CONSTANT);
+	Q_PROPERTY(QString applicationId MEMBER applicationId CONSTANT);
+	Q_PROPERTY(QString reason MEMBER reason CONSTANT);
+
+public:
+	explicit PowerProfileHold() = default;
+	explicit PowerProfileHold(PowerProfile::Enum profile, QString applicationId, QString reason)
+	    : profile(profile)
+	    , applicationId(std::move(applicationId))
+	    , reason(std::move(reason)) {}
+
+	PowerProfile::Enum profile = PowerProfile::Balanced;
+	QString applicationId;
+	QString reason;
+
+	[[nodiscard]] bool operator==(const PowerProfileHold& other) const;
+};
+
+QDebug& operator<<(QDebug& debug, const PowerProfileHold& hold);
+
+class PowerProfiles: public QObject {
+	Q_OBJECT;
+
+public:
+	void setProfile(PowerProfile::Enum profile);
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(PowerProfiles, PowerProfile::Enum, bProfile, PowerProfile::Balanced);
+	Q_OBJECT_BINDABLE_PROPERTY(PowerProfiles, bool, bHasPerformanceProfile);
+	Q_OBJECT_BINDABLE_PROPERTY(PowerProfiles, PerformanceDegradationReason::Enum, bDegradationReason);
+	Q_OBJECT_BINDABLE_PROPERTY(PowerProfiles, QList<PowerProfileHold>, bHolds);
+	// clang-format on
+
+	static PowerProfiles* instance();
+
+private:
+	explicit PowerProfiles();
+	void init();
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(PowerProfiles, QList<PowerProfile::Enum>, bProfiles);
+
+	QS_DBUS_BINDABLE_PROPERTY_GROUP(PowerProfiles, properties);
+	QS_DBUS_PROPERTY_BINDING(PowerProfiles, pProfile, bProfile, properties, "ActiveProfile");
+	QS_DBUS_PROPERTY_BINDING(PowerProfiles, pProfiles, bProfiles, properties, "Profiles");
+	QS_DBUS_PROPERTY_BINDING(PowerProfiles, pPerformanceDegraded, bDegradationReason, properties, "PerformanceDegraded");
+	QS_DBUS_PROPERTY_BINDING(PowerProfiles, pHolds, bHolds, properties, "ActiveProfileHolds");
+	// clang-format on
+
+	QDBusInterface* service = nullptr;
+};
+
+///! Provides access to the Power Profiles service.
+/// An interface to the UPower [power profiles daemon], which can be
+/// used to view and manage power profiles.
+///
+/// > [!NOTE] The power profiles daemon must be installed to use this service.
+/// > Installing UPower does not necessarily install the power profiles daemon.
+///
+/// [power profiles daemon]: https://gitlab.freedesktop.org/upower/power-profiles-daemon
+class PowerProfilesQml: public QObject {
+	Q_OBJECT;
+	QML_NAMED_ELEMENT(PowerProfiles);
+	QML_SINGLETON;
+	// clang-format off
+	/// The current power profile.
+	///
+	/// This property may be set to change the system's power profile, however
+	/// it cannot be set to `Performance` unless @@hasPerformanceProfile is true.
+	Q_PROPERTY(qs::service::upower::PowerProfile::Enum profile READ default WRITE setProfile NOTIFY profileChanged BINDABLE bindableProfile);
+	/// If the system has a performance profile.
+	///
+	/// If this property is false, your system does not have a performance
+	/// profile known to power-profiles-daemon.
+	Q_PROPERTY(bool hasPerformanceProfile READ default NOTIFY hasPerformanceProfileChanged BINDABLE bindableHasPerformanceProfile);
+	/// If power-profiles-daemon detects degraded system performance, the reason
+	/// for the degradation will be present here.
+	Q_PROPERTY(qs::service::upower::PerformanceDegradationReason::Enum degradationReason READ default NOTIFY degradationReasonChanged BINDABLE bindableDegradationReason);
+	/// Power profile holds created by other applications.
+	///
+	/// This property returns a `powerProfileHold` object, which has the following properties.
+	/// - `profile` - The @@PowerProfile held by the application.
+	/// - `applicationId` - A string identifying the application
+	/// - `reason` - The reason the application has given for holding the profile.
+	///
+	/// Applications may "hold" a power profile in place for their lifetime, such
+	/// as a game holding Performance mode or a system daemon holding Power Saver mode
+	/// when reaching a battery threshold. If the user selects a different profile explicitly
+	/// (e.g. by setting @@profile$) all holds will be removed.
+	///
+	/// Multiple applications may hold a power profile, however if multiple applications request
+	/// profiles than `PowerSaver` will win over `Performance`. Only `Performance` and `PowerSaver`
+	/// profiles may be held.
+	Q_PROPERTY(QList<qs::service::upower::PowerProfileHold> holds READ default NOTIFY holdsChanged BINDABLE bindableHolds);
+	// clang-format on
+
+signals:
+	void profileChanged();
+	void hasPerformanceProfileChanged();
+	void degradationReasonChanged();
+	void holdsChanged();
+
+public:
+	explicit PowerProfilesQml(QObject* parent = nullptr);
+
+	[[nodiscard]] QBindable<PowerProfile::Enum> bindableProfile() const { return &this->bProfile; }
+
+	static void setProfile(PowerProfile::Enum profile) {
+		PowerProfiles::instance()->setProfile(profile);
+	}
+
+	[[nodiscard]] QBindable<bool> bindableHasPerformanceProfile() const {
+		return &this->bHasPerformanceProfile;
+	}
+
+	[[nodiscard]] QBindable<PerformanceDegradationReason::Enum> bindableDegradationReason() const {
+		return &this->bDegradationReason;
+	}
+
+	[[nodiscard]] QBindable<QList<PowerProfileHold>> bindableHolds() const { return &this->bHolds; }
+
+private:
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(PowerProfilesQml, PowerProfile::Enum, bProfile, &PowerProfilesQml::profileChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(PowerProfilesQml, bool, bHasPerformanceProfile, &PowerProfilesQml::hasPerformanceProfileChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(PowerProfilesQml, PerformanceDegradationReason::Enum, bDegradationReason, &PowerProfilesQml::degradationReasonChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(PowerProfilesQml, QList<PowerProfileHold>, bHolds, &PowerProfilesQml::holdsChanged);
+	// clang-format on
+};
+
+} // namespace qs::service::upower
diff --git a/src/ui/CMakeLists.txt b/src/ui/CMakeLists.txt
new file mode 100644
index 00000000..4043fed1
--- /dev/null
+++ b/src/ui/CMakeLists.txt
@@ -0,0 +1,18 @@
+qt_add_library(quickshell-ui STATIC
+	reload_popup.cpp
+)
+
+# do not install this module
+qt_add_qml_module(quickshell-ui
+	URI Quickshell._InternalUi
+	VERSION 0.1
+	DEPENDENCIES QtQuick
+	QML_FILES
+		Tooltip.qml
+		ReloadPopup.qml
+)
+
+qs_module_pch(quickshell-ui SET large)
+
+target_link_libraries(quickshell-ui PRIVATE Qt::Quick)
+target_link_libraries(quickshell PRIVATE quickshell-uiplugin)
diff --git a/src/ui/ReloadPopup.qml b/src/ui/ReloadPopup.qml
new file mode 100644
index 00000000..8ed749b5
--- /dev/null
+++ b/src/ui/ReloadPopup.qml
@@ -0,0 +1,256 @@
+pragma ComponentBehavior: Bound
+
+import QtQuick
+import QtQuick.Layouts
+import Quickshell
+import Quickshell.Widgets
+
+PanelWindow {
+	id: root
+	required property ReloadPopupInfo reloadInfo
+	readonly property string instanceId: root.reloadInfo.instanceId
+	readonly property bool failed: root.reloadInfo.failed
+	readonly property string errorString: root.reloadInfo.errorString
+
+	anchors { left: true; top: true }
+	margins { left: 25; top: 25 }
+
+	implicitWidth: wrapper.implicitWidth
+	implicitHeight: wrapper.implicitHeight
+
+	color: "transparent"
+
+	focusable: failText.focus
+
+	// Composite before changing opacity
+	SequentialAnimation on contentItem.opacity {
+		id: fadeOutAnim
+		NumberAnimation {
+			// avoids 0 which closes the popup
+			from: 0.0001; to: 1
+			duration: 250
+			easing.type: Easing.OutQuad
+		}
+		PauseAnimation { duration: root.failed ? 2000 : 500 }
+		NumberAnimation {
+			to: 0
+			duration: root.failed ? 3000 : 800
+			easing.type: Easing.InQuad
+		}
+	}
+
+	Behavior on contentItem.opacity {
+		enabled: !fadeOutAnim.running
+
+		NumberAnimation {
+			duration: 250
+			easing.type: Easing.OutQuad
+		}
+	}
+
+	contentItem.onOpacityChanged: {
+		if (contentItem.opacity == 0) root.reloadInfo.closed()
+	}
+
+	component PopupText: Text {
+		color: palette.active.text
+	}
+
+	component TopButton: WrapperMouseArea {
+		id: buttonMouse
+		required property string icon
+		required property string fallbackText
+		property bool red: false
+
+		hoverEnabled: true
+
+		WrapperRectangle {
+			radius: 5
+
+			color: {
+				if (buttonMouse.red) {
+					const baseColor = "#c04040";
+					if (buttonMouse.pressed) return Qt.tint(palette.active.button, Qt.alpha(baseColor, 0.8));
+					if (buttonMouse.containsMouse) return baseColor;
+				} else {
+					if (buttonMouse.pressed) return Qt.tint(palette.active.button, Qt.alpha(palette.active.accent, 0.3));
+					if (buttonMouse.containsMouse) return Qt.tint(palette.active.button, Qt.alpha(palette.active.accent, 0.5));
+				}
+
+				return palette.active.button;
+			}
+
+			border.color: {
+				if (buttonMouse.red) {
+					const baseColor = "#c04040";
+					if (buttonMouse.pressed) return Qt.tint(palette.active.light, Qt.alpha(baseColor, 0.8));
+					if (buttonMouse.containsMouse) return baseColor;
+				} else {
+					if (buttonMouse.pressed) return Qt.tint(palette.active.light, Qt.alpha(palette.active.accent, 0.7));
+					if (buttonMouse.containsMouse) return palette.active.accent;
+				}
+
+				return palette.active.light;
+			}
+
+			Behavior on color { ColorAnimation { duration: 100 } }
+			Behavior on border.color { ColorAnimation { duration: 100 } }
+
+			IconImage {
+				id: image
+				source: Quickshell.iconPath(buttonMouse.icon, true)
+				implicitSize: 22
+				visible: source != ""
+			}
+
+			Text {
+				id: fallback
+				text: buttonMouse.fallbackText
+				color: buttonMouse.red ? "white" : palette.active.buttonText
+			}
+
+			child: image.visible ? image : fallback
+		}
+	}
+
+	WrapperRectangle {
+		id: wrapper
+		anchors.fill: parent
+		color: palette.active.window
+		border.color: root.failed ? "#b53030" : palette.active.accent
+		border.width: 1
+
+		radius: 10
+		margin: 10
+
+		HoverHandler {
+			onHoveredChanged: {
+				if (hovered && fadeOutAnim.running) {
+					fadeOutAnim.stop();
+					root.contentItem.opacity = 1;
+				}
+			}
+		}
+
+		ColumnLayout {
+			RowLayout {
+				PopupText {
+					font.pixelSize: 20
+					fontSizeMode: Text.VerticalFit
+					text: `Quickshell: ${root.failed ? "Config reload failed" : "Config reloaded"}`
+				}
+
+				Item { Layout.fillWidth: true }
+
+				TopButton {
+					id: copyButton
+					visible: root.failed
+					icon: "edit-copy"
+					fallbackText: "Copy"
+					onClicked: {
+						Quickshell.clipboardText = root.errorString;
+						copyTooltip.showAction();
+					}
+				}
+
+				Tooltip {
+					id: copyTooltip
+					anchorItem: copyButton
+					show: copyButton.containsMouse
+					text: "Copy error message"
+					actionText: "Copied to clipboard"
+				}
+
+				TopButton {
+					icon: "window-close"
+					fallbackText: "Close"
+					red: true
+					onClicked: {
+						fadeOutAnim.stop()
+						root.contentItem.opacity = 0
+					}
+				}
+			}
+
+			WrapperRectangle {
+				visible: root.failed
+				color: palette.active.base
+				margin: 10
+				radius: 5
+
+				TextEdit {
+					id: failText
+					text: root.errorString
+					color: palette.active.text
+					selectionColor: palette.active.highlight
+					selectedTextColor: palette.active.highlightedText
+					readOnly: true
+					font.family: "monospace"
+				}
+			}
+
+			RowLayout {
+				PopupText { text: "Run" }
+
+				WrapperMouseArea {
+					id: logButton
+
+					Layout.topMargin: -logWrapper.margin
+					Layout.bottomMargin: -logWrapper.margin
+
+					hoverEnabled: true
+
+					onPressed: {
+						Quickshell.clipboardText = logText.text;
+						logCopyTooltip.showAction();
+					}
+
+					WrapperRectangle {
+						id: logWrapper
+						margin: 2
+						radius: 5
+
+						color: {
+							if (logButton.pressed) return Qt.tint(palette.active.base, Qt.alpha(palette.active.accent, 0.1));
+							if (logButton.containsMouse) return Qt.tint(palette.active.base, Qt.alpha(palette.active.accent, 0.2));
+							return palette.active.base;
+						}
+
+						border.color: {
+							if (logButton.pressed) return Qt.tint(palette.active.button, Qt.alpha(palette.active.accent, 0.3));
+							if (logButton.containsMouse) return Qt.tint(palette.active.button, Qt.alpha(palette.active.accent, 0.5));
+							return palette.active.button;
+						}
+
+						Behavior on color { ColorAnimation { duration: 100 } }
+						Behavior on border.color { ColorAnimation { duration: 100 } }
+
+						RowLayout {
+							PopupText {
+								id: logText
+								text: `qs log -i ${root.instanceId}`
+							}
+
+							IconImage {
+								Layout.fillHeight: true
+								implicitWidth: height
+								source: Quickshell.iconPath("edit-copy", true)
+								visible: source != ""
+							}
+						}
+					}
+
+					Tooltip {
+						id: logCopyTooltip
+						anchorItem: logWrapper
+						show: logButton.containsMouse
+						text: "Copy command"
+						actionText: "Copied to clipboard"
+					}
+				}
+
+				PopupText { text: "to view the log." }
+			}
+		}
+	}
+}
diff --git a/src/ui/Tooltip.qml b/src/ui/Tooltip.qml
new file mode 100644
index 00000000..66b4edd4
--- /dev/null
+++ b/src/ui/Tooltip.qml
@@ -0,0 +1,82 @@
+import QtQuick
+import Quickshell
+import Quickshell.Widgets
+
+PopupWindow {
+	id: popup
+	required property Item anchorItem
+	required property string text
+	property string actionText
+	property bool show: false
+
+	function showAction() {
+		mShowAction = true;
+		showInternal = true;
+		hangTimer.restart();
+	}
+
+	// We should be using a bottom center anchor but support for them is bad compositor side.
+	anchor {
+		window: anchorItem.QsWindow.window
+		adjustment: PopupAdjustment.None
+		gravity: Edges.Bottom | Edges.Right
+
+		onAnchoring: {
+			const pos = anchorItem.QsWindow.contentItem.mapFromItem(
+				anchorItem,
+				anchorItem.width / 2 - popup.width / 2,
+				anchorItem.height + 5
+			);
+
+			anchor.rect.x = pos.x;
+			anchor.rect.y = pos.y;
+		}
+	}
+
+	property bool showInternal: false
+	property bool mShowAction: false
+	property real opacity: showInternal ? 1 : 0
+
+	onShowChanged: hangTimer.restart()
+
+	Timer {
+		id: hangTimer
+		interval: 400
+		onTriggered: popup.showInternal = popup.show
+	}
+
+	Behavior on opacity {
+		NumberAnimation {
+			duration: 200
+			easing.type: popup.showInternal ? Easing.InQuart : Easing.OutQuart
+		}
+	}
+
+	color: "transparent"
+	visible: opacity != 0
+	onVisibleChanged: if (!visible) mShowAction = false
+
+	implicitWidth: content.implicitWidth
+	implicitHeight: content.implicitHeight
+
+	WrapperRectangle {
+		id: content
+		opacity: popup.opacity
+		color: palette.active.toolTipBase
+		border.color: palette.active.light
+		margin: 5
+		radius: 5
+
+		transform: Scale {
+			origin.x: content.width / 2
+			origin.y: 0
+			xScale: 0.6 + popup.opacity * 0.4
+			yScale: xScale
+		}
+
+		Text {
+			text: popup.mShowAction ? popup.actionText : popup.text
+			color: palette.active.toolTipText
+		}
+	}
+}
diff --git a/src/ui/reload_popup.cpp b/src/ui/reload_popup.cpp
new file mode 100644
index 00000000..8e58dc9d
--- /dev/null
+++ b/src/ui/reload_popup.cpp
@@ -0,0 +1,58 @@
+#include "reload_popup.hpp"
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qlogging.h>
+#include <qobject.h>
+#include <qqmlcomponent.h>
+#include <qtenvironmentvariables.h>
+#include <qtimer.h>
+
+#include "../core/generation.hpp"
+
+namespace qs::ui {
+
+ReloadPopup::ReloadPopup(QString instanceId, bool failed, QString errorString)
+    : generation(new EngineGeneration())
+    , instanceId(std::move(instanceId))
+    , failed(failed)
+    , errorString(std::move(errorString)) {
+	auto component = QQmlComponent(
+	    this->generation->engine,
+	    "qrc:/qt/qml/Quickshell/_InternalUi/ReloadPopup.qml",
+	    this
+	);
+
+	this->popup = component.createWithInitialProperties({{"reloadInfo", QVariant::fromValue(this)}});
+
+	if (!popup) {
+		qCritical() << "Failed to open reload popup:" << component.errorString();
+	}
+
+	this->generation->onReload(nullptr);
+}
+
+void ReloadPopup::closed() {
+	if (ReloadPopup::activePopup == this) ReloadPopup::activePopup = nullptr;
+
+	if (!this->deleting) {
+		this->deleting = true;
+
+		QTimer::singleShot(0, [this]() {
+			if (this->popup) this->popup->deleteLater();
+			this->generation->destroy();
+			this->deleteLater();
+		});
+	}
+}
+
+void ReloadPopup::spawnPopup(QString instanceId, bool failed, QString errorString) {
+	if (qEnvironmentVariableIsSet("QS_NO_RELOAD_POPUP")) return;
+
+	if (ReloadPopup::activePopup) ReloadPopup::activePopup->closed();
+	ReloadPopup::activePopup = new ReloadPopup(std::move(instanceId), failed, std::move(errorString));
+}
+
+ReloadPopup* ReloadPopup::activePopup = nullptr;
+
+} // namespace qs::ui
diff --git a/src/ui/reload_popup.hpp b/src/ui/reload_popup.hpp
new file mode 100644
index 00000000..78ab55ac
--- /dev/null
+++ b/src/ui/reload_popup.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qqmlengine.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+
+#include "../core/generation.hpp"
+
+namespace qs::ui {
+
+class ReloadPopup: public QObject {
+	Q_OBJECT;
+	QML_NAMED_ELEMENT(ReloadPopupInfo);
+	QML_UNCREATABLE("")
+	Q_PROPERTY(QString instanceId MEMBER instanceId CONSTANT);
+	Q_PROPERTY(bool failed MEMBER failed CONSTANT);
+	Q_PROPERTY(QString errorString MEMBER errorString CONSTANT);
+
+public:
+	Q_INVOKABLE void closed();
+
+	static void spawnPopup(QString instanceId, bool failed, QString errorString);
+
+private:
+	ReloadPopup(QString instanceId, bool failed, QString errorString);
+
+	EngineGeneration* generation;
+	QObject* popup = nullptr;
+	QString instanceId;
+	bool failed = false;
+	bool deleting = false;
+	QString errorString;
+
+	static ReloadPopup* activePopup;
+};
+
+} // namespace qs::ui
diff --git a/src/wayland/CMakeLists.txt b/src/wayland/CMakeLists.txt
index 3300a5fd..1d6543e4 100644
--- a/src/wayland/CMakeLists.txt
+++ b/src/wayland/CMakeLists.txt
@@ -1,25 +1,17 @@
 find_package(PkgConfig REQUIRED)
+find_package(WaylandScanner REQUIRED)
 pkg_check_modules(wayland REQUIRED IMPORTED_TARGET wayland-client wayland-protocols)
 
-find_package(Qt6 REQUIRED COMPONENTS WaylandClient)
-
 # wayland protocols
 
-if (DEFINED ENV{QTWAYLANDSCANNER})
-	set(qtwaylandscanner $ENV{QTWAYLANDSCANNER})
-else()
-	find_program(qtwaylandscanner NAMES qtwaylandscanner)
+if(NOT TARGET Wayland::Scanner)
+	message(FATAL_ERROR "Wayland::Scanner target not found. You might be missing the WaylandScanner CMake package.")
 endif()
 
-if (qtwaylandscanner STREQUAL "qtwaylandscanner-NOTFOUND")
-	message(FATAL_ERROR "qtwaylandscanner not found. Set the QTWAYLANDSCANNER environment variable to specify its path explicity.")
+if(NOT TARGET Qt6::qtwaylandscanner)
+	message(FATAL_ERROR "qtwaylandscanner executable not found. Most likely there is an issue with your Qt installation.")
 endif()
 
-message(STATUS "Found qtwaylandscanner at ${qtwaylandscanner}")
-
-find_program(waylandscanner NAMES wayland-scanner)
-message(STATUS "Found wayland-scanner at ${waylandscanner}")
-
 execute_process(
 	COMMAND pkg-config --variable=pkgdatadir wayland-protocols
 	OUTPUT_VARIABLE WAYLAND_PROTOCOLS
@@ -28,33 +20,77 @@ execute_process(
 
 message(STATUS "Found wayland-protocols at ${WAYLAND_PROTOCOLS_DIR}")
 
-function (wl_proto target name path)
+qs_add_pchset(wayland-protocol
+	DEPENDENCIES Qt::Core Qt::WaylandClient Qt::WaylandClientPrivate
+	HEADERS
+		<wayland-client.h>
+		<qbytearray.h>
+		<qstring.h>
+)
+
+function (wl_proto target name dir)
 	set(PROTO_BUILD_PATH ${CMAKE_CURRENT_BINARY_DIR}/wl-proto/${name})
 	make_directory(${PROTO_BUILD_PATH})
 
-	execute_process(COMMAND ${waylandscanner} client-header ${path} ${PROTO_BUILD_PATH}/wayland-${name}-client-protocol.h)
-	execute_process(COMMAND ${waylandscanner} private-code ${path} ${PROTO_BUILD_PATH}/wayland-${name}.c)
-	execute_process(COMMAND ${qtwaylandscanner} client-header ${path} OUTPUT_FILE ${PROTO_BUILD_PATH}/qwayland-${name}.h)
-	execute_process(COMMAND ${qtwaylandscanner} client-code ${path} OUTPUT_FILE ${PROTO_BUILD_PATH}/qwayland-${name}.cpp)
+	set(WS_CLIENT_HEADER "${PROTO_BUILD_PATH}/wayland-${name}-client-protocol.h")
+	set(WS_CLIENT_CODE "${PROTO_BUILD_PATH}/wayland-${name}.c")
+	set(QWS_CLIENT_HEADER "${PROTO_BUILD_PATH}/qwayland-${name}.h")
+	set(QWS_CLIENT_CODE "${PROTO_BUILD_PATH}/qwayland-${name}.cpp")
+	set(PATH "${dir}/${name}.xml")
 
-	target_sources(${target} PRIVATE ${PROTO_BUILD_PATH}/wayland-${name}.c)
-	target_sources(${target} PRIVATE ${PROTO_BUILD_PATH}/qwayland-${name}.cpp)
-	target_include_directories(${target} PRIVATE ${PROTO_BUILD_PATH})
+	add_custom_command(
+		OUTPUT "${WS_CLIENT_HEADER}"
+		COMMAND Wayland::Scanner client-header "${PATH}" "${WS_CLIENT_HEADER}"
+		DEPENDS Wayland::Scanner "${PATH}"
+	)
+
+	add_custom_command(
+		OUTPUT "${WS_CLIENT_CODE}"
+		COMMAND Wayland::Scanner private-code "${PATH}" "${WS_CLIENT_CODE}"
+		DEPENDS Wayland::Scanner "${PATH}"
+	)
+
+	add_custom_command(
+		OUTPUT "${QWS_CLIENT_HEADER}"
+		COMMAND Qt6::qtwaylandscanner client-header "${PATH}" > "${QWS_CLIENT_HEADER}"
+		DEPENDS Qt6::qtwaylandscanner "${PATH}"
+	)
+
+	add_custom_command(
+		OUTPUT "${QWS_CLIENT_CODE}"
+		COMMAND Qt6::qtwaylandscanner client-code "${PATH}" > "${QWS_CLIENT_CODE}"
+		DEPENDS Qt6::qtwaylandscanner "${PATH}"
+	)
+
+	add_library(wl-proto-${name}-wl STATIC ${WS_CLIENT_HEADER} ${WS_CLIENT_CODE})
+	add_library(${target} STATIC ${QWS_CLIENT_HEADER} ${QWS_CLIENT_CODE})
+
+	target_include_directories(${target} INTERFACE ${PROTO_BUILD_PATH})
+	target_link_libraries(${target} wl-proto-${name}-wl Qt6::WaylandClient Qt6::WaylandClientPrivate)
+	qs_pch(${target} SET wayland-protocol)
 endfunction()
 
 # -----
 
-qt_add_library(quickshell-wayland STATIC)
-qt_add_qml_module(quickshell-wayland URI Quickshell.Wayland VERSION 0.1)
+qt_add_library(quickshell-wayland STATIC
+	platformmenu.cpp
+	popupanchor.cpp
+	xdgshell.cpp
+	util.cpp
+	output_tracking.cpp
+)
 
 # required to make sure the constructor is linked
 add_library(quickshell-wayland-init OBJECT init.cpp)
 
+set(WAYLAND_MODULES)
+
 if (WAYLAND_WLR_LAYERSHELL)
-	target_sources(quickshell-wayland PRIVATE wlr_layershell.cpp)
 	add_subdirectory(wlr_layershell)
 	target_compile_definitions(quickshell-wayland PRIVATE QS_WAYLAND_WLR_LAYERSHELL)
 	target_compile_definitions(quickshell-wayland-init PRIVATE QS_WAYLAND_WLR_LAYERSHELL)
+
+	list(APPEND WAYLAND_MODULES Quickshell.Wayland._WlrLayerShell)
 endif()
 
 if (WAYLAND_SESSION_LOCK)
@@ -62,7 +98,40 @@ if (WAYLAND_SESSION_LOCK)
 	add_subdirectory(session_lock)
 endif()
 
-target_link_libraries(quickshell-wayland PRIVATE ${QT_DEPS})
-target_link_libraries(quickshell-wayland-init PRIVATE ${QT_DEPS})
+if (WAYLAND_TOPLEVEL_MANAGEMENT)
+	add_subdirectory(toplevel_management)
+	list(APPEND WAYLAND_MODULES Quickshell.Wayland._ToplevelManagement)
+endif()
+
+if (SCREENCOPY)
+	add_subdirectory(buffer)
+	add_subdirectory(screencopy)
+	list(APPEND WAYLAND_MODULES Quickshell.Wayland._Screencopy)
+endif()
+
+
+if (HYPRLAND)
+	add_subdirectory(hyprland)
+endif()
+
+# widgets for qmenu
+target_link_libraries(quickshell-wayland PRIVATE
+	Qt::Quick Qt::Widgets Qt::WaylandClient Qt::WaylandClientPrivate
+)
+
+target_link_libraries(quickshell-wayland-init PRIVATE Qt::Quick)
+
+qt_add_qml_module(quickshell-wayland
+	URI Quickshell.Wayland
+	VERSION 0.1
+	DEPENDENCIES QtQuick
+	IMPORTS ${WAYLAND_MODULES}
+)
+
+qs_add_module_deps_light(quickshell-wayland Quickshell)
+
+install_qml_module(quickshell-wayland)
+
+qs_module_pch(quickshell-wayland SET large)
 
 target_link_libraries(quickshell PRIVATE quickshell-waylandplugin quickshell-wayland-init)
diff --git a/src/wayland/buffer/CMakeLists.txt b/src/wayland/buffer/CMakeLists.txt
new file mode 100644
index 00000000..f80c53a3
--- /dev/null
+++ b/src/wayland/buffer/CMakeLists.txt
@@ -0,0 +1,18 @@
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(dmabuf-deps REQUIRED IMPORTED_TARGET libdrm gbm egl)
+
+qt_add_library(quickshell-wayland-buffer STATIC
+	manager.cpp
+	dmabuf.cpp
+	shm.cpp
+)
+
+wl_proto(wlp-linux-dmabuf linux-dmabuf-v1 "${WAYLAND_PROTOCOLS}/stable/linux-dmabuf")
+
+target_link_libraries(quickshell-wayland-buffer PRIVATE
+	Qt::Quick Qt::WaylandClient Qt::WaylandClientPrivate wayland-client
+	PkgConfig::dmabuf-deps
+	wlp-linux-dmabuf
+)
+
+qs_pch(quickshell-wayland-buffer SET large)
diff --git a/src/wayland/buffer/dmabuf.cpp b/src/wayland/buffer/dmabuf.cpp
new file mode 100644
index 00000000..45933896
--- /dev/null
+++ b/src/wayland/buffer/dmabuf.cpp
@@ -0,0 +1,676 @@
+#include "dmabuf.hpp"
+#include <algorithm>
+#include <array>
+#include <csignal>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GL/gl.h>
+#include <GLES3/gl32.h>
+#include <fcntl.h>
+#include <gbm.h>
+#include <libdrm/drm_fourcc.h>
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qlist.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qopenglcontext.h>
+#include <qopenglcontext_platform.h>
+#include <qpair.h>
+#include <qquickwindow.h>
+#include <qscopedpointer.h>
+#include <qsgtexture_platform.h>
+#include <qwayland-linux-dmabuf-v1.h>
+#include <qwaylandclientextension.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <wayland-client-protocol.h>
+#include <wayland-linux-dmabuf-v1-client-protocol.h>
+#include <wayland-util.h>
+#include <xf86drm.h>
+
+#include "../../core/logcat.hpp"
+#include "../../core/stacklist.hpp"
+#include "manager.hpp"
+#include "manager_p.hpp"
+
+namespace qs::wayland::buffer::dmabuf {
+
+namespace {
+
+QS_LOGGING_CATEGORY(logDmabuf, "quickshell.wayland.buffer.dmabuf", QtWarningMsg);
+
+LinuxDmabufManager* MANAGER = nullptr; // NOLINT
+
+} // namespace
+
+QDebug& operator<<(QDebug& debug, const FourCCStr& fourcc) {
+	debug << fourcc.cStr();
+	return debug;
+}
+
+QDebug& operator<<(QDebug& debug, const FourCCModStr& fourcc) {
+	debug << fourcc.cStr();
+	return debug;
+}
+
+QDebug& operator<<(QDebug& debug, const WlDmaBuffer* buffer) {
+	auto saver = QDebugStateSaver(debug);
+	debug.nospace();
+
+	if (buffer) {
+		debug << "WlDmaBuffer(" << static_cast<const void*>(buffer) << ", size=" << buffer->width << 'x'
+		      << buffer->height << ", format=" << FourCCStr(buffer->format) << ", modifier=`"
+		      << FourCCModStr(buffer->modifier) << "`)";
+	} else {
+		debug << "WlDmaBuffer(0x0)";
+	}
+
+	return debug;
+}
+
+GbmDeviceHandle::~GbmDeviceHandle() {
+	if (device) {
+		MANAGER->unrefGbmDevice(this->device);
+	}
+}
+
+// This will definitely backfire later
+void LinuxDmabufFormatSelection::ensureSorted() {
+	if (this->sorted) return;
+	auto beginIter = this->formats.begin();
+
+	auto xrgbIter = std::ranges::find_if(this->formats, [](const auto& format) {
+		return format.first == DRM_FORMAT_XRGB8888;
+	});
+
+	if (xrgbIter != this->formats.end()) {
+		std::swap(*beginIter, *xrgbIter);
+		++beginIter;
+	}
+
+	auto argbIter = std::ranges::find_if(this->formats, [](const auto& format) {
+		return format.first == DRM_FORMAT_ARGB8888;
+	});
+
+	if (argbIter != this->formats.end()) std::swap(*beginIter, *argbIter);
+
+	this->sorted = true;
+}
+
+LinuxDmabufFeedback::LinuxDmabufFeedback(::zwp_linux_dmabuf_feedback_v1* feedback)
+    : zwp_linux_dmabuf_feedback_v1(feedback) {}
+
+LinuxDmabufFeedback::~LinuxDmabufFeedback() { this->destroy(); }
+
+void LinuxDmabufFeedback::zwp_linux_dmabuf_feedback_v1_format_table(int32_t fd, uint32_t size) {
+	this->formatTableSize = size;
+
+	this->formatTable = mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fd, 0);
+
+	if (this->formatTable == MAP_FAILED) {
+		this->formatTable = nullptr;
+		qCFatal(logDmabuf) << "Failed to mmap format table.";
+	}
+
+	qCDebug(logDmabuf) << "Got format table";
+}
+
+void LinuxDmabufFeedback::zwp_linux_dmabuf_feedback_v1_main_device(wl_array* device) {
+	if (device->size != sizeof(dev_t)) {
+		qCFatal(logDmabuf) << "The size of dev_t used by the compositor and quickshell is mismatched. "
+		                      "Try recompiling both.";
+	}
+
+	this->mainDevice = *reinterpret_cast<dev_t*>(device->data);
+	qCDebug(logDmabuf) << "Got main device id" << this->mainDevice;
+}
+
+void LinuxDmabufFeedback::zwp_linux_dmabuf_feedback_v1_tranche_target_device(wl_array* device) {
+	if (device->size != sizeof(dev_t)) {
+		qCFatal(logDmabuf) << "The size of dev_t used by the compositor and quickshell is mismatched. "
+		                      "Try recompiling both.";
+	}
+
+	auto& tranche = this->tranches.emplaceBack();
+	tranche.device = *reinterpret_cast<dev_t*>(device->data);
+	qCDebug(logDmabuf) << "Got target device id" << this->mainDevice;
+}
+
+void LinuxDmabufFeedback::zwp_linux_dmabuf_feedback_v1_tranche_flags(uint32_t flags) {
+	this->tranches.back().flags = flags;
+	qCDebug(logDmabuf) << "Got target device flags" << flags;
+}
+
+void LinuxDmabufFeedback::zwp_linux_dmabuf_feedback_v1_tranche_formats(wl_array* indices) {
+	struct FormatTableEntry {
+		uint32_t format;
+		uint32_t padding;
+		uint64_t modifier;
+	};
+
+	static_assert(sizeof(FormatTableEntry) == 16, "Format table entry was not packed to 16 bytes.");
+
+	if (this->formatTable == nullptr) {
+		qCFatal(logDmabuf) << "Received tranche formats before format table.";
+	}
+
+	auto& tranche = this->tranches.back();
+
+	auto* table = reinterpret_cast<FormatTableEntry*>(this->formatTable);
+	auto* indexTable = reinterpret_cast<uint16_t*>(indices->data);
+	auto indexTableLength = indices->size / sizeof(uint16_t);
+
+	uint32_t lastFormat = 0;
+	LinuxDmabufModifiers* modifiers = nullptr;
+
+	for (uint16_t ti = 0; ti != indexTableLength; ++ti) {
+		auto i = indexTable[ti];      // NOLINT
+		const auto& entry = table[i]; // NOLINT
+
+		// Compositors usually send a single format's modifiers as a block.
+		if (!modifiers || entry.format != lastFormat) {
+			lastFormat = entry.format;
+
+			auto modifiersIter = std::ranges::find_if(tranche.formats.formats, [&](const auto& pair) {
+				return pair.first == entry.format;
+			});
+
+			if (modifiersIter == tranche.formats.formats.end()) {
+				tranche.formats.formats.push(qMakePair(entry.format, LinuxDmabufModifiers()));
+				modifiers = &(--tranche.formats.formats.end())->second;
+			} else {
+				modifiers = &modifiersIter->second;
+			}
+		}
+
+		if (entry.modifier == DRM_FORMAT_MOD_INVALID) {
+			modifiers->implicit = true;
+		} else {
+			modifiers->modifiers.push(entry.modifier);
+		}
+	}
+}
+
+void LinuxDmabufFeedback::zwp_linux_dmabuf_feedback_v1_tranche_done() {
+	qCDebug(logDmabuf) << "Got tranche end.";
+}
+
+void LinuxDmabufFeedback::zwp_linux_dmabuf_feedback_v1_done() {
+	qCDebug(logDmabuf) << "Got feedback done.";
+
+	if (this->formatTable) {
+		munmap(this->formatTable, this->formatTableSize);
+		this->formatTable = nullptr;
+	}
+
+	if (logDmabuf().isDebugEnabled()) {
+		qCDebug(logDmabuf) << "Dmabuf tranches:";
+
+		for (auto& tranche: this->tranches) {
+			qCDebug(logDmabuf) << "  Tranche on device" << tranche.device;
+
+			// will be sorted on first use otherwise
+			tranche.formats.ensureSorted();
+
+			for (auto& [format, modifiers]: tranche.formats.formats) {
+				qCDebug(logDmabuf) << "    Format" << FourCCStr(format);
+
+				if (modifiers.implicit) {
+					qCDebug(logDmabuf) << "      Implicit Modifier";
+				}
+
+				for (const auto& modifier: modifiers.modifiers) {
+					qCDebug(logDmabuf) << "      Explicit Modifier" << FourCCModStr(modifier);
+				}
+			}
+		}
+	}
+
+	// Copy tranches to the manager. If the compositor ever updates
+	// our tranches, we'll start from a clean slate.
+	MANAGER->tranches = this->tranches;
+	this->tranches.clear();
+
+	MANAGER->feedbackDone();
+}
+
+LinuxDmabufManager::LinuxDmabufManager(WlBufferManagerPrivate* manager)
+    : QWaylandClientExtensionTemplate(5)
+    , manager(manager) {
+	MANAGER = this;
+	this->initialize();
+
+	if (this->isActive()) {
+		qCDebug(logDmabuf) << "Requesting default dmabuf feedback...";
+		new LinuxDmabufFeedback(this->get_default_feedback());
+	}
+}
+
+void LinuxDmabufManager::feedbackDone() { this->manager->dmabufReady(); }
+
+GbmDeviceHandle LinuxDmabufManager::getGbmDevice(dev_t handle) {
+	struct DrmFree {
+		static void cleanup(drmDevice* d) { drmFreeDevice(&d); }
+	};
+
+	std::string renderNodeStorage;
+	std::string* renderNode = nullptr;
+
+	auto sharedDevice = std::ranges::find_if(this->gbmDevices, [&](const SharedGbmDevice& d) {
+		return d.handle == handle;
+	});
+
+	if (sharedDevice != this->gbmDevices.end()) {
+		renderNode = &sharedDevice->renderNode;
+	} else {
+		drmDevice* drmDevPtr = nullptr;
+		if (auto error = drmGetDeviceFromDevId(handle, 0, &drmDevPtr); error != 0) {
+			qCWarning(logDmabuf) << "Failed to get drm device information from handle:"
+			                     << qt_error_string(error);
+			return nullptr;
+		}
+
+		auto drmDev = QScopedPointer<drmDevice, DrmFree>(drmDevPtr);
+
+		if (!(drmDev->available_nodes & (1 << DRM_NODE_RENDER))) {
+			qCDebug(logDmabuf) << "Cannot create GBM device: DRM device does not have render node.";
+			return nullptr;
+		}
+
+		renderNodeStorage = drmDev->nodes[DRM_NODE_RENDER]; // NOLINT
+		renderNode = &renderNodeStorage;
+		sharedDevice = std::ranges::find_if(this->gbmDevices, [&](const SharedGbmDevice& d) {
+			return d.renderNode == renderNodeStorage;
+		});
+	}
+
+	if (sharedDevice != this->gbmDevices.end()) {
+		qCDebug(logDmabuf) << "Used existing GBM device on render node" << *renderNode;
+		++sharedDevice->refcount;
+		return sharedDevice->device;
+	} else {
+		auto fd = open(renderNode->c_str(), O_RDWR | O_CLOEXEC);
+		if (fd < 0) {
+			qCDebug(logDmabuf) << "Could not open render node" << *renderNode << ":"
+			                   << qt_error_string(fd);
+			return nullptr;
+		}
+
+		auto* device = gbm_create_device(fd);
+
+		if (!device) {
+			qCDebug(logDmabuf) << "Failed to create GBM device from render node" << *renderNode;
+			close(fd);
+			return nullptr;
+		}
+
+		qCDebug(logDmabuf) << "Created GBM device on render node" << *renderNode;
+
+		this->gbmDevices.push_back({
+		    .handle = handle,
+		    .renderNode = std::move(renderNodeStorage),
+		    .device = device,
+		    .refcount = 1,
+		});
+
+		return device;
+	}
+}
+
+void LinuxDmabufManager::unrefGbmDevice(gbm_device* device) {
+	auto iter = std::ranges::find_if(this->gbmDevices, [device](const SharedGbmDevice& d) {
+		return d.device == device;
+	});
+	if (iter == this->gbmDevices.end()) return;
+
+	qCDebug(logDmabuf) << "Lost reference to GBM device" << device;
+
+	if (--iter->refcount == 0) {
+		auto fd = gbm_device_get_fd(iter->device);
+		gbm_device_destroy(iter->device);
+		close(fd);
+
+		this->gbmDevices.erase(iter);
+		qCDebug(logDmabuf) << "Destroyed GBM device" << device;
+	}
+}
+
+GbmDeviceHandle LinuxDmabufManager::dupHandle(const GbmDeviceHandle& handle) {
+	if (!handle) return GbmDeviceHandle();
+
+	auto iter = std::ranges::find_if(this->gbmDevices, [&handle](const SharedGbmDevice& d) {
+		return d.device == *handle;
+	});
+	if (iter == this->gbmDevices.end()) return GbmDeviceHandle();
+
+	qCDebug(logDmabuf) << "Duplicated GBM device handle" << *handle;
+	++iter->refcount;
+	return GbmDeviceHandle(*handle);
+}
+
+WlBuffer* LinuxDmabufManager::createDmabuf(const WlBufferRequest& request) {
+	for (auto& tranche: this->tranches) {
+		if (request.dmabuf.device != 0 && tranche.device != request.dmabuf.device) {
+			continue;
+		}
+
+		LinuxDmabufFormatSelection formats;
+		for (const auto& format: request.dmabuf.formats) {
+			if (!format.modifiers.isEmpty()) {
+				formats.formats.push(
+				    qMakePair(format.format, LinuxDmabufModifiers {.modifiers = format.modifiers})
+				);
+			} else {
+				for (const auto& trancheFormat: tranche.formats.formats) {
+					if (trancheFormat.first == format.format) {
+						formats.formats.push(trancheFormat);
+					}
+				}
+			}
+		}
+
+		if (formats.formats.isEmpty()) continue;
+		formats.ensureSorted();
+
+		auto gbmDevice = this->getGbmDevice(tranche.device);
+
+		if (!gbmDevice) {
+			qCWarning(logDmabuf) << "Hit unusable tranche device while trying to create dmabuf.";
+			continue;
+		}
+
+		for (const auto& [format, modifiers]: formats.formats) {
+			if (auto* buf =
+			        this->createDmabuf(gbmDevice, format, modifiers, request.width, request.height))
+			{
+				return buf;
+			}
+		}
+	}
+
+	qCWarning(logDmabuf) << "Unable to create dmabuf for request: No matching formats.";
+	return nullptr;
+}
+
+WlBuffer* LinuxDmabufManager::createDmabuf(
+    GbmDeviceHandle& device,
+    uint32_t format,
+    const LinuxDmabufModifiers& modifiers,
+    uint32_t width,
+    uint32_t height
+) {
+	auto buffer = std::unique_ptr<WlDmaBuffer>(new WlDmaBuffer());
+	auto& bo = buffer->bo;
+
+	const uint32_t flags = GBM_BO_USE_RENDERING;
+
+	if (modifiers.modifiers.isEmpty()) {
+		if (!modifiers.implicit) {
+			qCritical(logDmabuf
+			) << "Failed to create gbm_bo: format supports no implicit OR explicit modifiers.";
+			return nullptr;
+		}
+
+		qCDebug(logDmabuf) << "Creating gbm_bo without modifiers...";
+		bo = gbm_bo_create(*device, width, height, format, flags);
+	} else {
+		qCDebug(logDmabuf) << "Creating gbm_bo with modifiers...";
+
+		STACKLIST_VLA_VIEW(uint64_t, modifiers.modifiers, modifiersData);
+
+		bo = gbm_bo_create_with_modifiers2(
+		    *device,
+		    width,
+		    height,
+		    format,
+		    modifiersData,
+		    modifiers.modifiers.length(),
+		    flags
+		);
+	}
+
+	if (!bo) {
+		qCritical(logDmabuf) << "Failed to create gbm_bo.";
+		return nullptr;
+	}
+
+	buffer->planeCount = gbm_bo_get_plane_count(bo);
+	buffer->planes = new WlDmaBuffer::Plane[buffer->planeCount]();
+	buffer->modifier = gbm_bo_get_modifier(bo);
+
+	auto params = QtWayland::zwp_linux_buffer_params_v1(this->create_params());
+
+	for (auto i = 0; i < buffer->planeCount; ++i) {
+		auto& plane = buffer->planes[i]; // NOLINT
+		plane.fd = gbm_bo_get_fd_for_plane(bo, i);
+
+		if (plane.fd < 0) {
+			qCritical(logDmabuf) << "Failed to get gbm_bo fd for plane" << i << qt_error_string(plane.fd);
+			params.destroy();
+			gbm_bo_destroy(bo);
+			return nullptr;
+		}
+
+		plane.stride = gbm_bo_get_stride_for_plane(bo, i);
+		plane.offset = gbm_bo_get_offset(bo, i);
+
+		params.add(
+		    plane.fd,
+		    i,
+		    plane.offset,
+		    plane.stride,
+		    buffer->modifier >> 32,
+		    buffer->modifier & 0xffffffff
+		);
+	}
+
+	buffer->mBuffer =
+	    params.create_immed(static_cast<int32_t>(width), static_cast<int32_t>(height), format, 0);
+	params.destroy();
+
+	buffer->device = this->dupHandle(device);
+	buffer->width = width;
+	buffer->height = height;
+	buffer->format = format;
+
+	qCDebug(logDmabuf) << "Created dmabuf" << buffer.get();
+	return buffer.release();
+}
+
+WlDmaBuffer::WlDmaBuffer(WlDmaBuffer&& other) noexcept
+    : device(std::move(other.device))
+    , bo(other.bo)
+    , mBuffer(other.mBuffer)
+    , planes(other.planes) {
+	other.mBuffer = nullptr;
+	other.bo = nullptr;
+	other.planeCount = 0;
+}
+
+WlDmaBuffer& WlDmaBuffer::operator=(WlDmaBuffer&& other) noexcept {
+	this->~WlDmaBuffer();
+	new (this) WlDmaBuffer(std::move(other));
+	return *this;
+}
+
+WlDmaBuffer::~WlDmaBuffer() {
+	if (this->mBuffer) {
+		wl_buffer_destroy(this->mBuffer);
+	}
+
+	if (this->bo) {
+		gbm_bo_destroy(this->bo);
+		qCDebug(logDmabuf) << "Destroyed" << this << "freeing bo" << this->bo;
+	}
+
+	for (auto i = 0; i < this->planeCount; ++i) {
+		const auto& plane = this->planes[i]; // NOLINT
+		if (plane.fd) close(plane.fd);
+	}
+
+	delete[] this->planes;
+}
+
+bool WlDmaBuffer::isCompatible(const WlBufferRequest& request) const {
+	if (request.width != this->width || request.height != this->height) return false;
+
+	auto matchingFormat = std::ranges::find_if(request.dmabuf.formats, [&](const auto& format) {
+		return format.format == this->format
+		    && (format.modifiers.isEmpty()
+		        || std::ranges::find(format.modifiers, this->modifier) != format.modifiers.end());
+	});
+
+	return matchingFormat != request.dmabuf.formats.end();
+}
+
+WlBufferQSGTexture* WlDmaBuffer::createQsgTexture(QQuickWindow* window) const {
+	static auto* glEGLImageTargetTexture2DOES = []() {
+		auto* fn = reinterpret_cast<PFNGLEGLIMAGETARGETTEXTURE2DOESPROC>(
+		    eglGetProcAddress("glEGLImageTargetTexture2DOES")
+		);
+
+		if (!fn) {
+			qCFatal(logDmabuf) << "Failed to create QSG texture from WlDmaBuffer: "
+			                      "glEGLImageTargetTexture2DOES is missing.";
+		}
+
+		return fn;
+	}();
+
+	auto* context = QOpenGLContext::currentContext();
+	if (!context) {
+		qCFatal(logDmabuf) << "Failed to create QSG texture from WlDmaBuffer: No GL context.";
+	}
+
+	auto* qEglContext = context->nativeInterface<QNativeInterface::QEGLContext>();
+	if (!qEglContext) {
+		qCFatal(logDmabuf) << "Failed to create QSG texture from WlDmaBuffer: No EGL context.";
+	}
+
+	auto* display = qEglContext->display();
+
+	// Ref https://github.com/hyprwm/hyprlock/blob/da1d076d849fc0f298c1d287bddd04802bf7d0f9/src/renderer/Screencopy.cpp#L194
+	struct AttribNameSet {
+		EGLAttrib fd;
+		EGLAttrib offset;
+		EGLAttrib pitch;
+		EGLAttrib modlo;
+		EGLAttrib modhi;
+	};
+
+	static auto attribNames = std::array<AttribNameSet, 4> {
+	    AttribNameSet {
+	        .fd = EGL_DMA_BUF_PLANE0_FD_EXT,
+	        .offset = EGL_DMA_BUF_PLANE0_OFFSET_EXT,
+	        .pitch = EGL_DMA_BUF_PLANE0_PITCH_EXT,
+	        .modlo = EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT,
+	        .modhi = EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT
+	    },
+	    AttribNameSet {
+	        .fd = EGL_DMA_BUF_PLANE1_FD_EXT,
+	        .offset = EGL_DMA_BUF_PLANE1_OFFSET_EXT,
+	        .pitch = EGL_DMA_BUF_PLANE1_PITCH_EXT,
+	        .modlo = EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT,
+	        .modhi = EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT
+	    },
+	    AttribNameSet {
+	        .fd = EGL_DMA_BUF_PLANE2_FD_EXT,
+	        .offset = EGL_DMA_BUF_PLANE2_OFFSET_EXT,
+	        .pitch = EGL_DMA_BUF_PLANE2_PITCH_EXT,
+	        .modlo = EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT,
+	        .modhi = EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT
+	    },
+	    AttribNameSet {
+	        .fd = EGL_DMA_BUF_PLANE3_FD_EXT,
+	        .offset = EGL_DMA_BUF_PLANE3_OFFSET_EXT,
+	        .pitch = EGL_DMA_BUF_PLANE3_PITCH_EXT,
+	        .modlo = EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT,
+	        .modhi = EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT
+	    }
+	};
+
+	// clang-format off
+	auto attribs = std::vector<EGLAttrib> {
+		EGL_WIDTH, this->width,
+		EGL_HEIGHT, this->height,
+		EGL_LINUX_DRM_FOURCC_EXT, this->format,
+	};
+	// clang-format on
+
+	if (this->planeCount > 4) {
+		qFatal(logDmabuf) << "Could not create EGL attrib array with more than 4 planes. Count:"
+		                  << this->planeCount;
+	}
+
+	for (auto i = 0; i != this->planeCount; i++) {
+		const auto& names = attribNames[i];
+		const auto& plane = this->planes[i]; // NOLINT
+
+		// clang-format off
+		attribs.insert(attribs.end(), {
+		    names.fd, plane.fd,
+		    names.offset, plane.offset,
+		    names.pitch, plane.stride,
+		});
+		// clang-format on
+
+		// clang-format off
+		if (this->modifier != DRM_FORMAT_MOD_INVALID) {
+			attribs.insert(attribs.end(), {
+			    names.modlo, static_cast<EGLAttrib>(this->modifier & 0xFFFFFFFF),
+			    names.modhi, static_cast<EGLAttrib>(this->modifier >> 32),
+			});
+		}
+		// clang-format on
+	}
+
+	attribs.emplace_back(EGL_NONE);
+
+	auto* eglImage =
+	    eglCreateImage(display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, nullptr, attribs.data());
+
+	if (eglImage == EGL_NO_IMAGE) {
+		qFatal() << "Failed to create egl image" << eglGetError();
+		return nullptr;
+	}
+
+	window->beginExternalCommands();
+	GLuint glTexture = 0;
+	glGenTextures(1, &glTexture);
+
+	glBindTexture(GL_TEXTURE_2D, glTexture);
+	glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, eglImage);
+	glBindTexture(GL_TEXTURE_2D, 0);
+	window->endExternalCommands();
+
+	auto* qsgTexture = QNativeInterface::QSGOpenGLTexture::fromNative(
+	    glTexture,
+	    window,
+	    QSize(static_cast<int>(this->width), static_cast<int>(this->height))
+	);
+
+	auto* tex = new WlDmaBufferQSGTexture(eglImage, glTexture, qsgTexture);
+	qCDebug(logDmabuf) << "Created WlDmaBufferQSGTexture" << tex << "from" << this;
+	return tex;
+}
+
+WlDmaBufferQSGTexture::~WlDmaBufferQSGTexture() {
+	auto* context = QOpenGLContext::currentContext();
+	auto* display = context->nativeInterface<QNativeInterface::QEGLContext>()->display();
+
+	if (this->glTexture) glDeleteTextures(1, &this->glTexture);
+	if (this->eglImage) eglDestroyImage(display, this->eglImage);
+	delete this->qsgTexture;
+
+	qCDebug(logDmabuf) << "WlDmaBufferQSGTexture" << this << "destroyed.";
+}
+
+} // namespace qs::wayland::buffer::dmabuf
diff --git a/src/wayland/buffer/dmabuf.hpp b/src/wayland/buffer/dmabuf.hpp
new file mode 100644
index 00000000..a05e82a1
--- /dev/null
+++ b/src/wayland/buffer/dmabuf.hpp
@@ -0,0 +1,235 @@
+#pragma once
+
+#include <cstdint>
+
+#include <EGL/egl.h>
+#include <gbm.h>
+#include <qcontainerfwd.h>
+#include <qhash.h>
+#include <qlist.h>
+#include <qquickwindow.h>
+#include <qsgtexture.h>
+#include <qsize.h>
+#include <qtclasshelpermacros.h>
+#include <qtypes.h>
+#include <qwayland-linux-dmabuf-v1.h>
+#include <qwaylandclientextension.h>
+#include <sys/types.h>
+#include <wayland-linux-dmabuf-v1-client-protocol.h>
+#include <wayland-util.h>
+#include <xf86drm.h>
+
+#include "manager.hpp"
+#include "qsg.hpp"
+
+namespace qs::wayland::buffer {
+class WlBufferManagerPrivate;
+}
+
+namespace qs::wayland::buffer::dmabuf {
+
+class LinuxDmabufManager;
+class FourCCStr {
+public:
+	explicit FourCCStr(uint32_t code)
+	    : chars(
+	          {static_cast<char>(code >> 0 & 0xff),
+	           static_cast<char>(code >> 8 & 0xff),
+	           static_cast<char>(code >> 16 & 0xff),
+	           static_cast<char>(code >> 24 & 0xff),
+	           '\0'}
+	      ) {
+		for (auto i = 3; i != 0; i--) {
+			if (chars[i] == ' ') chars[i] = '\0';
+			else break;
+		}
+	}
+
+	[[nodiscard]] const char* cStr() const { return this->chars.data(); }
+
+private:
+	std::array<char, 5> chars {};
+};
+
+class FourCCModStr {
+public:
+	explicit FourCCModStr(uint64_t code): drmStr(drmGetFormatModifierName(code)) {}
+	~FourCCModStr() {
+		if (this->drmStr) drmFree(this->drmStr);
+	}
+
+	Q_DISABLE_COPY_MOVE(FourCCModStr);
+
+	[[nodiscard]] const char* cStr() const { return this->drmStr; }
+
+private:
+	char* drmStr;
+};
+
+QDebug& operator<<(QDebug& debug, const FourCCStr& fourcc);
+QDebug& operator<<(QDebug& debug, const FourCCModStr& fourcc);
+
+class GbmDeviceHandle {
+public:
+	GbmDeviceHandle() = default;
+	GbmDeviceHandle(gbm_device* device): device(device) {}
+
+	GbmDeviceHandle(GbmDeviceHandle&& other) noexcept: device(other.device) {
+		other.device = nullptr;
+	}
+
+	~GbmDeviceHandle();
+	Q_DISABLE_COPY(GbmDeviceHandle);
+
+	GbmDeviceHandle& operator=(GbmDeviceHandle&& other) noexcept {
+		this->device = other.device;
+		other.device = nullptr;
+		return *this;
+	}
+
+	[[nodiscard]] gbm_device* operator*() const { return this->device; }
+	[[nodiscard]] operator bool() const { return this->device; }
+
+private:
+	gbm_device* device = nullptr;
+};
+
+class WlDmaBufferQSGTexture: public WlBufferQSGTexture {
+public:
+	~WlDmaBufferQSGTexture() override;
+	Q_DISABLE_COPY_MOVE(WlDmaBufferQSGTexture);
+
+	[[nodiscard]] QSGTexture* texture() const override { return this->qsgTexture; }
+
+private:
+	WlDmaBufferQSGTexture(EGLImage eglImage, GLuint glTexture, QSGTexture* qsgTexture)
+	    : eglImage(eglImage)
+	    , glTexture(glTexture)
+	    , qsgTexture(qsgTexture) {}
+
+	EGLImage eglImage;
+	GLuint glTexture;
+	QSGTexture* qsgTexture;
+
+	friend class WlDmaBuffer;
+};
+
+class WlDmaBuffer: public WlBuffer {
+public:
+	~WlDmaBuffer() override;
+	Q_DISABLE_COPY(WlDmaBuffer);
+	WlDmaBuffer(WlDmaBuffer&& other) noexcept;
+	WlDmaBuffer& operator=(WlDmaBuffer&& other) noexcept;
+
+	[[nodiscard]] wl_buffer* buffer() const override { return this->mBuffer; }
+
+	[[nodiscard]] QSize size() const override {
+		return QSize(static_cast<int>(this->width), static_cast<int>(this->height));
+	}
+
+	[[nodiscard]] bool isCompatible(const WlBufferRequest& request) const override;
+	[[nodiscard]] WlBufferQSGTexture* createQsgTexture(QQuickWindow* window) const override;
+
+private:
+	WlDmaBuffer() noexcept = default;
+
+	struct Plane {
+		int fd = 0;
+		uint32_t offset = 0;
+		uint32_t stride = 0;
+	};
+
+	GbmDeviceHandle device;
+	gbm_bo* bo = nullptr;
+	wl_buffer* mBuffer = nullptr;
+	int planeCount = 0;
+	Plane* planes = nullptr;
+	uint32_t format = 0;
+	uint64_t modifier = 0;
+	uint32_t width = 0;
+	uint32_t height = 0;
+
+	friend class LinuxDmabufManager;
+	friend QDebug& operator<<(QDebug& debug, const WlDmaBuffer* buffer);
+};
+
+QDebug& operator<<(QDebug& debug, const WlDmaBuffer* buffer);
+
+struct LinuxDmabufModifiers {
+	StackList<uint64_t, 10> modifiers;
+	bool implicit = false;
+};
+
+struct LinuxDmabufFormatSelection {
+	bool sorted = false;
+	StackList<QPair<uint32_t, LinuxDmabufModifiers>, 2> formats;
+	void ensureSorted();
+};
+
+struct LinuxDmabufTranche {
+	dev_t device = 0;
+	uint32_t flags = 0;
+	LinuxDmabufFormatSelection formats;
+};
+
+class LinuxDmabufFeedback: public QtWayland::zwp_linux_dmabuf_feedback_v1 {
+public:
+	explicit LinuxDmabufFeedback(::zwp_linux_dmabuf_feedback_v1* feedback);
+	~LinuxDmabufFeedback() override;
+	Q_DISABLE_COPY_MOVE(LinuxDmabufFeedback);
+
+protected:
+	void zwp_linux_dmabuf_feedback_v1_main_device(wl_array* device) override;
+	void zwp_linux_dmabuf_feedback_v1_format_table(int32_t fd, uint32_t size) override;
+	void zwp_linux_dmabuf_feedback_v1_tranche_target_device(wl_array* device) override;
+	void zwp_linux_dmabuf_feedback_v1_tranche_flags(uint32_t flags) override;
+	void zwp_linux_dmabuf_feedback_v1_tranche_formats(wl_array* indices) override;
+	void zwp_linux_dmabuf_feedback_v1_tranche_done() override;
+	void zwp_linux_dmabuf_feedback_v1_done() override;
+
+private:
+	dev_t mainDevice = 0;
+	QList<LinuxDmabufTranche> tranches;
+	void* formatTable = nullptr;
+	uint32_t formatTableSize = 0;
+};
+
+class LinuxDmabufManager
+    : public QWaylandClientExtensionTemplate<LinuxDmabufManager>
+    , public QtWayland::zwp_linux_dmabuf_v1 {
+public:
+	explicit LinuxDmabufManager(WlBufferManagerPrivate* manager);
+
+	[[nodiscard]] WlBuffer* createDmabuf(const WlBufferRequest& request);
+
+	[[nodiscard]] WlBuffer* createDmabuf(
+	    GbmDeviceHandle& device,
+	    uint32_t format,
+	    const LinuxDmabufModifiers& modifiers,
+	    uint32_t width,
+	    uint32_t height
+	);
+
+private:
+	struct SharedGbmDevice {
+		dev_t handle = 0;
+		std::string renderNode;
+		gbm_device* device = nullptr;
+		qsizetype refcount = 0;
+	};
+
+	void feedbackDone();
+
+	GbmDeviceHandle getGbmDevice(dev_t handle);
+	void unrefGbmDevice(gbm_device* device);
+	GbmDeviceHandle dupHandle(const GbmDeviceHandle& handle);
+
+	QList<LinuxDmabufTranche> tranches;
+	QList<SharedGbmDevice> gbmDevices;
+	WlBufferManagerPrivate* manager;
+
+	friend class LinuxDmabufFeedback;
+	friend class GbmDeviceHandle;
+};
+
+} // namespace qs::wayland::buffer::dmabuf
diff --git a/src/wayland/buffer/manager.cpp b/src/wayland/buffer/manager.cpp
new file mode 100644
index 00000000..713752ab
--- /dev/null
+++ b/src/wayland/buffer/manager.cpp
@@ -0,0 +1,146 @@
+#include "manager.hpp"
+
+#include <qdebug.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qmatrix4x4.h>
+#include <qnamespace.h>
+#include <qquickwindow.h>
+#include <qtenvironmentvariables.h>
+#include <qtmetamacros.h>
+#include <qvectornd.h>
+
+#include "../../core/logcat.hpp"
+#include "dmabuf.hpp"
+#include "manager_p.hpp"
+#include "qsg.hpp"
+#include "shm.hpp"
+
+namespace qs::wayland::buffer {
+
+namespace {
+QS_LOGGING_CATEGORY(logBuffer, "quickshell.wayland.buffer", QtWarningMsg);
+}
+
+void WlBufferRequest::reset() { *this = WlBufferRequest(); }
+
+WlBuffer* WlBufferSwapchain::createBackbuffer(const WlBufferRequest& request, bool* newBuffer) {
+	auto& buffer = this->presentSecondBuffer ? this->buffer1 : this->buffer2;
+
+	if (!buffer || !buffer->isCompatible(request)) {
+		buffer.reset(WlBufferManager::instance()->createBuffer(request));
+		if (newBuffer) *newBuffer = true;
+	}
+
+	return buffer.get();
+}
+
+WlBufferManager::WlBufferManager(): p(new WlBufferManagerPrivate(this)) {}
+
+WlBufferManager::~WlBufferManager() { delete this->p; }
+
+WlBufferManager* WlBufferManager::instance() {
+	static auto* instance = new WlBufferManager();
+	return instance;
+}
+
+bool WlBufferManager::isReady() const { return this->p->mReady; }
+
+[[nodiscard]] WlBuffer* WlBufferManager::createBuffer(const WlBufferRequest& request) {
+	static const bool dmabufDisabled = qEnvironmentVariableIsSet("QS_DISABLE_DMABUF");
+
+	qCDebug(logBuffer).nospace() << "Creating buffer from request at " << request.width << 'x'
+	                             << request.height;
+	qCDebug(logBuffer).nospace() << "  Dmabuf requests on device " << request.dmabuf.device
+	                             << " (disabled: " << dmabufDisabled << ')';
+
+	for (const auto& [format, modifiers]: request.dmabuf.formats) {
+		qCDebug(logBuffer).nospace() << "    Format " << dmabuf::FourCCStr(format)
+		                             << (modifiers.length() == 0 ? " (No modifiers specified)" : "");
+
+		for (const auto& modifier: modifiers) {
+			qCDebug(logBuffer) << "      Explicit Modifier" << dmabuf::FourCCModStr(modifier);
+		}
+	}
+
+	qCDebug(logBuffer).nospace() << "  Shm requests";
+
+	for (const auto& format: request.shm.formats) {
+		qCDebug(logBuffer) << "    Format" << format;
+	}
+
+	if (request.width == 0 || request.height == 0) {
+		qCWarning(logBuffer) << "Cannot create zero-sized buffer.";
+		return nullptr;
+	}
+
+	if (!dmabufDisabled) {
+		if (auto* buf = this->p->dmabuf.createDmabuf(request)) return buf;
+		qCWarning(logBuffer) << "DMA buffer creation failed, falling back to SHM.";
+	}
+
+	return shm::ShmbufManager::createShmbuf(request);
+}
+
+WlBufferManagerPrivate::WlBufferManagerPrivate(WlBufferManager* manager)
+    : manager(manager)
+    , dmabuf(this) {}
+
+void WlBufferManagerPrivate::dmabufReady() {
+	this->mReady = true;
+	emit this->manager->ready();
+}
+
+WlBufferQSGDisplayNode::WlBufferQSGDisplayNode(QQuickWindow* window)
+    : window(window)
+    , imageNode(window->createImageNode()) {
+	this->appendChildNode(this->imageNode);
+}
+
+void WlBufferQSGDisplayNode::setRect(const QRectF& rect) {
+	const auto* buffer = (this->presentSecondBuffer ? this->buffer2 : this->buffer1).first;
+	if (!buffer) return;
+
+	auto matrix = QMatrix4x4();
+	auto center = rect.center();
+	auto centerX = static_cast<float>(center.x());
+	auto centerY = static_cast<float>(center.y());
+	matrix.translate(centerX, centerY);
+	buffer->transform.apply(matrix);
+	matrix.translate(-centerX, -centerY);
+
+	auto viewRect = matrix.mapRect(rect);
+	auto bufferSize = buffer->size().toSizeF();
+
+	bufferSize.scale(viewRect.width(), viewRect.height(), Qt::KeepAspectRatio);
+	this->imageNode->setRect(
+	    viewRect.x() + viewRect.width() / 2 - bufferSize.width() / 2,
+	    viewRect.y() + viewRect.height() / 2 - bufferSize.height() / 2,
+	    bufferSize.width(),
+	    bufferSize.height()
+	);
+
+	this->setMatrix(matrix);
+}
+
+void WlBufferQSGDisplayNode::syncSwapchain(const WlBufferSwapchain& swapchain) {
+	auto* buffer = swapchain.frontbuffer();
+	auto& texture = swapchain.presentSecondBuffer ? this->buffer2 : this->buffer1;
+
+	if (swapchain.presentSecondBuffer == this->presentSecondBuffer && texture.first == buffer) {
+		return;
+	}
+
+	this->presentSecondBuffer = swapchain.presentSecondBuffer;
+
+	if (texture.first == buffer) {
+		texture.second->sync(texture.first, this->window);
+	} else {
+		texture.first = buffer;
+		texture.second.reset(buffer->createQsgTexture(this->window));
+	}
+
+	this->imageNode->setTexture(texture.second->texture());
+}
+
+} // namespace qs::wayland::buffer
diff --git a/src/wayland/buffer/manager.hpp b/src/wayland/buffer/manager.hpp
new file mode 100644
index 00000000..8abc218c
--- /dev/null
+++ b/src/wayland/buffer/manager.hpp
@@ -0,0 +1,138 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+
+#include <qhash.h>
+#include <qlist.h>
+#include <qmatrix4x4.h>
+#include <qobject.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qvariant.h>
+#include <sys/types.h>
+#include <wayland-client-protocol.h>
+#include <wayland-client.h>
+
+#include "../../core/stacklist.hpp"
+
+class QQuickWindow;
+
+namespace qs::wayland::buffer {
+
+class WlBufferManagerPrivate;
+class WlBufferQSGTexture;
+
+struct WlBufferTransform {
+	enum Transform : uint8_t {
+		Normal0 = 0,
+		Normal90 = 1,
+		Normal180 = 2,
+		Normal270 = 3,
+		Flipped0 = 4,
+		Flipped90 = 5,
+		Flipped180 = 6,
+		Flipped270 = 7,
+	} transform = Normal0;
+
+	WlBufferTransform() = default;
+	WlBufferTransform(uint8_t transform): transform(static_cast<Transform>(transform)) {}
+
+	[[nodiscard]] int degrees() const { return 90 * (this->transform & 0b11111011); }
+	[[nodiscard]] bool flip() const { return this->transform & 0b00000100; }
+	[[nodiscard]] bool flipSize() const { return this->transform & 0b00000001; }
+
+	void apply(QMatrix4x4& matrix) const {
+		matrix.rotate(this->flip() ? 180 : 0, 0, 1, 0);
+		matrix.rotate(static_cast<float>(this->degrees()), 0, 0, 1);
+	}
+};
+
+struct WlBufferRequest {
+	uint32_t width = 0;
+	uint32_t height = 0;
+
+	struct DmaFormat {
+		DmaFormat() = default;
+		DmaFormat(uint32_t format): format(format) {}
+
+		uint32_t format = 0;
+		StackList<uint64_t, 10> modifiers;
+	};
+
+	struct {
+		StackList<uint32_t, 1> formats;
+	} shm;
+
+	struct {
+		dev_t device = 0;
+		StackList<DmaFormat, 1> formats;
+	} dmabuf;
+
+	void reset();
+};
+
+class WlBuffer {
+public:
+	virtual ~WlBuffer() = default;
+	Q_DISABLE_COPY_MOVE(WlBuffer);
+
+	[[nodiscard]] virtual wl_buffer* buffer() const = 0;
+	[[nodiscard]] virtual QSize size() const = 0;
+	[[nodiscard]] virtual bool isCompatible(const WlBufferRequest& request) const = 0;
+	[[nodiscard]] operator bool() const { return this->buffer(); }
+
+	// Must be called from render thread.
+	[[nodiscard]] virtual WlBufferQSGTexture* createQsgTexture(QQuickWindow* window) const = 0;
+
+	WlBufferTransform transform;
+
+protected:
+	explicit WlBuffer() = default;
+};
+
+class WlBufferSwapchain {
+public:
+	[[nodiscard]] WlBuffer*
+	createBackbuffer(const WlBufferRequest& request, bool* newBuffer = nullptr);
+
+	void swapBuffers() { this->presentSecondBuffer = !this->presentSecondBuffer; }
+
+	[[nodiscard]] WlBuffer* backbuffer() const {
+		return this->presentSecondBuffer ? this->buffer1.get() : this->buffer2.get();
+	}
+
+	[[nodiscard]] WlBuffer* frontbuffer() const {
+		return this->presentSecondBuffer ? this->buffer2.get() : this->buffer1.get();
+	}
+
+private:
+	std::unique_ptr<WlBuffer> buffer1;
+	std::unique_ptr<WlBuffer> buffer2;
+	bool presentSecondBuffer = false;
+
+	friend class WlBufferQSGDisplayNode;
+};
+
+class WlBufferManager: public QObject {
+	Q_OBJECT;
+
+public:
+	~WlBufferManager() override;
+	Q_DISABLE_COPY_MOVE(WlBufferManager);
+
+	static WlBufferManager* instance();
+
+	[[nodiscard]] bool isReady() const;
+	[[nodiscard]] WlBuffer* createBuffer(const WlBufferRequest& request);
+
+signals:
+	void ready();
+
+private:
+	explicit WlBufferManager();
+
+	WlBufferManagerPrivate* p;
+};
+
+} // namespace qs::wayland::buffer
diff --git a/src/wayland/buffer/manager_p.hpp b/src/wayland/buffer/manager_p.hpp
new file mode 100644
index 00000000..55f5e667
--- /dev/null
+++ b/src/wayland/buffer/manager_p.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "dmabuf.hpp"
+#include "manager.hpp"
+
+namespace qs::wayland::buffer {
+
+class WlBufferManagerPrivate {
+public:
+	explicit WlBufferManagerPrivate(WlBufferManager* manager);
+
+	void dmabufReady();
+
+	WlBufferManager* manager;
+	dmabuf::LinuxDmabufManager dmabuf;
+
+	bool mReady = false;
+};
+
+} // namespace qs::wayland::buffer
diff --git a/src/wayland/buffer/qsg.hpp b/src/wayland/buffer/qsg.hpp
new file mode 100644
index 00000000..c230cfee
--- /dev/null
+++ b/src/wayland/buffer/qsg.hpp
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <memory>
+
+#include <qcontainerfwd.h>
+#include <qquickwindow.h>
+#include <qsgimagenode.h>
+#include <qsgnode.h>
+#include <qsgtexture.h>
+#include <qvectornd.h>
+
+#include "manager.hpp"
+
+namespace qs::wayland::buffer {
+
+// Interact only from QSG thread.
+class WlBufferQSGTexture {
+public:
+	virtual ~WlBufferQSGTexture() = default;
+	Q_DISABLE_COPY_MOVE(WlBufferQSGTexture);
+
+	[[nodiscard]] virtual QSGTexture* texture() const = 0;
+	virtual void sync(const WlBuffer* /*buffer*/, QQuickWindow* /*window*/) {}
+
+protected:
+	WlBufferQSGTexture() = default;
+};
+
+// Interact only from QSG thread.
+class WlBufferQSGDisplayNode: public QSGTransformNode {
+public:
+	explicit WlBufferQSGDisplayNode(QQuickWindow* window);
+
+	void syncSwapchain(const WlBufferSwapchain& swapchain);
+	void setRect(const QRectF& rect);
+
+private:
+	QQuickWindow* window;
+	QSGImageNode* imageNode;
+	QPair<WlBuffer*, std::unique_ptr<WlBufferQSGTexture>> buffer1;
+	QPair<WlBuffer*, std::unique_ptr<WlBufferQSGTexture>> buffer2;
+	bool presentSecondBuffer = false;
+};
+
+} // namespace qs::wayland::buffer
diff --git a/src/wayland/buffer/shm.cpp b/src/wayland/buffer/shm.cpp
new file mode 100644
index 00000000..6a8c6422
--- /dev/null
+++ b/src/wayland/buffer/shm.cpp
@@ -0,0 +1,94 @@
+#include "shm.hpp"
+#include <algorithm>
+#include <memory>
+
+#include <private/qwaylanddisplay_p.h>
+#include <private/qwaylandintegration_p.h>
+#include <private/qwaylandshm_p.h>
+#include <private/qwaylandshmbackingstore_p.h>
+#include <qdebug.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qquickwindow.h>
+#include <qsize.h>
+#include <wayland-client-protocol.h>
+
+#include "../../core/logcat.hpp"
+#include "manager.hpp"
+
+namespace qs::wayland::buffer::shm {
+
+namespace {
+QS_LOGGING_CATEGORY(logShm, "quickshell.wayland.buffer.shm", QtWarningMsg);
+}
+
+bool WlShmBuffer::isCompatible(const WlBufferRequest& request) const {
+	if (QSize(static_cast<int>(request.width), static_cast<int>(request.height)) != this->size()) {
+		return false;
+	}
+
+	auto matchingFormat = std::ranges::find(request.shm.formats, this->format);
+	return matchingFormat != request.shm.formats.end();
+}
+
+QDebug& operator<<(QDebug& debug, const WlShmBuffer* buffer) {
+	auto saver = QDebugStateSaver(debug);
+	debug.nospace();
+
+	if (buffer) {
+		auto fmt = QtWaylandClient::QWaylandShm::formatFrom(
+		    static_cast<::wl_shm_format>(buffer->format) // NOLINT
+		);
+
+		debug << "WlShmBuffer(" << static_cast<const void*>(buffer) << ", size=" << buffer->size()
+		      << ", format=" << fmt << ')';
+	} else {
+		debug << "WlShmBuffer(0x0)";
+	}
+
+	return debug;
+}
+
+WlShmBuffer::~WlShmBuffer() { qCDebug(logShm) << "Destroyed" << this; }
+
+WlBufferQSGTexture* WlShmBuffer::createQsgTexture(QQuickWindow* window) const {
+	auto* texture = new WlShmBufferQSGTexture();
+
+	// If the QWaylandShmBuffer is destroyed before the QSGTexture, we'll hit a UAF
+	// in the render thread.
+	texture->shmBuffer = this->shmBuffer;
+
+	texture->qsgTexture.reset(window->createTextureFromImage(*this->shmBuffer->image()));
+	texture->sync(this, window);
+	return texture;
+}
+
+void WlShmBufferQSGTexture::sync(const WlBuffer* /*unused*/, QQuickWindow* window) {
+	// This is both dumb and expensive. We should use an RHI texture and render images into
+	// it more intelligently, but shm buffers are already a horribly slow fallback path,
+	// to the point where it barely matters.
+	this->qsgTexture.reset(window->createTextureFromImage(*this->shmBuffer->image()));
+}
+
+WlBuffer* ShmbufManager::createShmbuf(const WlBufferRequest& request) {
+	if (request.shm.formats.isEmpty()) return nullptr;
+
+	static const auto* waylandIntegration = QtWaylandClient::QWaylandIntegration::instance();
+	auto* display = waylandIntegration->display();
+
+	// Its probably fine...
+	auto format = request.shm.formats[0];
+
+	auto* buffer = new WlShmBuffer(
+	    new QtWaylandClient::QWaylandShmBuffer(
+	        display,
+	        QSize(static_cast<int>(request.width), static_cast<int>(request.height)),
+	        QtWaylandClient::QWaylandShm::formatFrom(static_cast<::wl_shm_format>(format)) // NOLINT
+	    ),
+	    format
+	);
+
+	qCDebug(logShm) << "Created shmbuf" << buffer;
+	return buffer;
+}
+} // namespace qs::wayland::buffer::shm
diff --git a/src/wayland/buffer/shm.hpp b/src/wayland/buffer/shm.hpp
new file mode 100644
index 00000000..f3597cbc
--- /dev/null
+++ b/src/wayland/buffer/shm.hpp
@@ -0,0 +1,61 @@
+#pragma once
+
+#include <memory>
+
+#include <private/qwaylandshmbackingstore_p.h>
+#include <qquickwindow.h>
+#include <qsgtexture.h>
+#include <qsize.h>
+#include <qtclasshelpermacros.h>
+#include <wayland-client-protocol.h>
+
+#include "manager.hpp"
+#include "qsg.hpp"
+
+namespace qs::wayland::buffer::shm {
+
+class WlShmBuffer: public WlBuffer {
+public:
+	~WlShmBuffer() override;
+	Q_DISABLE_COPY_MOVE(WlShmBuffer);
+
+	[[nodiscard]] wl_buffer* buffer() const override { return this->shmBuffer->buffer(); }
+	[[nodiscard]] QSize size() const override { return this->shmBuffer->size(); }
+	[[nodiscard]] bool isCompatible(const WlBufferRequest& request) const override;
+	[[nodiscard]] WlBufferQSGTexture* createQsgTexture(QQuickWindow* window) const override;
+
+private:
+	WlShmBuffer(QtWaylandClient::QWaylandShmBuffer* shmBuffer, uint32_t format)
+	    : shmBuffer(shmBuffer)
+	    , format(format) {}
+
+	std::shared_ptr<QtWaylandClient::QWaylandShmBuffer> shmBuffer;
+	uint32_t format;
+
+	friend class WlShmBufferQSGTexture;
+	friend class ShmbufManager;
+	friend QDebug& operator<<(QDebug& debug, const WlShmBuffer* buffer);
+};
+
+QDebug& operator<<(QDebug& debug, const WlShmBuffer* buffer);
+
+class WlShmBufferQSGTexture: public WlBufferQSGTexture {
+public:
+	[[nodiscard]] QSGTexture* texture() const override { return this->qsgTexture.get(); }
+	void sync(const WlBuffer* buffer, QQuickWindow* window) override;
+
+private:
+	WlShmBufferQSGTexture() = default;
+
+	std::shared_ptr<QtWaylandClient::QWaylandShmBuffer> shmBuffer;
+	std::unique_ptr<QSGTexture> qsgTexture;
+
+	friend class WlShmBuffer;
+};
+
+class ShmbufManager {
+public:
+	[[nodiscard]] static WlBuffer* createShmbuf(const WlBufferRequest& request);
+};
+
+} // namespace qs::wayland::buffer::shm
diff --git a/src/wayland/hyprland/CMakeLists.txt b/src/wayland/hyprland/CMakeLists.txt
new file mode 100644
index 00000000..66b32b6f
--- /dev/null
+++ b/src/wayland/hyprland/CMakeLists.txt
@@ -0,0 +1,38 @@
+qt_add_library(quickshell-hyprland STATIC)
+
+target_link_libraries(quickshell-hyprland PRIVATE ${QT_DEPS})
+
+set(HYPRLAND_MODULES)
+
+if (HYPRLAND_IPC)
+	add_subdirectory(ipc)
+	list(APPEND HYPRLAND_MODULES Quickshell.Hyprland._Ipc)
+endif()
+
+if (HYPRLAND_FOCUS_GRAB)
+	add_subdirectory(focus_grab)
+	list(APPEND HYPRLAND_MODULES Quickshell.Hyprland._FocusGrab)
+endif()
+
+if (HYPRLAND_GLOBAL_SHORTCUTS)
+	add_subdirectory(global_shortcuts)
+	list(APPEND HYPRLAND_MODULES Quickshell.Hyprland._GlobalShortcuts)
+endif()
+
+if (HYPRLAND_SURFACE_EXTENSIONS)
+	add_subdirectory(surface)
+	list(APPEND HYPRLAND_MODULES Quickshell.Hyprland._SurfaceExtensions)
+endif()
+
+qt_add_qml_module(quickshell-hyprland
+	URI Quickshell.Hyprland
+	VERSION 0.1
+	IMPORTS ${HYPRLAND_MODULES}
+)
+
+qs_add_module_deps_light(quickshell-io Quickshell)
+install_qml_module(quickshell-hyprland)
+
+# intentionally no pch as the module is empty
+
+target_link_libraries(quickshell PRIVATE quickshell-hyprlandplugin)
diff --git a/src/wayland/hyprland/focus_grab/CMakeLists.txt b/src/wayland/hyprland/focus_grab/CMakeLists.txt
new file mode 100644
index 00000000..95825628
--- /dev/null
+++ b/src/wayland/hyprland/focus_grab/CMakeLists.txt
@@ -0,0 +1,26 @@
+qt_add_library(quickshell-hyprland-focus-grab STATIC
+	manager.cpp
+	grab.cpp
+	qml.cpp
+)
+
+qt_add_qml_module(quickshell-hyprland-focus-grab
+	URI Quickshell.Hyprland._FocusGrab
+	VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+qs_add_module_deps_light(quickshell-hyprland-focus-grab Quickshell)
+
+install_qml_module(quickshell-hyprland-focus-grab)
+
+wl_proto(wlp-hyprland-focus-grab hyprland-focus-grab-v1 "${CMAKE_CURRENT_SOURCE_DIR}")
+
+target_link_libraries(quickshell-hyprland-focus-grab PRIVATE
+	Qt::Quick Qt::WaylandClient Qt::WaylandClientPrivate wayland-client
+	wlp-hyprland-focus-grab
+)
+
+qs_module_pch(quickshell-hyprland-focus-grab SET large)
+
+target_link_libraries(quickshell PRIVATE quickshell-hyprland-focus-grabplugin)
diff --git a/src/wayland/hyprland/focus_grab/grab.cpp b/src/wayland/hyprland/focus_grab/grab.cpp
new file mode 100644
index 00000000..188c2063
--- /dev/null
+++ b/src/wayland/hyprland/focus_grab/grab.cpp
@@ -0,0 +1,103 @@
+#include "grab.hpp"
+
+#include <private/qwaylandwindow_p.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qwindow.h>
+#include <wayland-hyprland-focus-grab-v1-client-protocol.h>
+
+namespace qs::hyprland::focus_grab {
+
+FocusGrab::FocusGrab(::hyprland_focus_grab_v1* grab) { this->init(grab); }
+
+FocusGrab::~FocusGrab() {
+	if (this->isInitialized()) {
+		this->destroy();
+	}
+}
+
+bool FocusGrab::isActive() const { return this->active; }
+
+void FocusGrab::addWindow(QWindow* window) {
+	auto tryAddWayland = [this](QWaylandWindow* waylandWindow) {
+		if (waylandWindow->surface()) {
+			this->addWaylandWindow(waylandWindow);
+			this->sync();
+		} else {
+			QObject::connect(
+			    waylandWindow,
+			    &QWaylandWindow::surfaceCreated,
+			    this,
+			    [this, waylandWindow]() {
+				    this->addWaylandWindow(waylandWindow);
+				    this->sync();
+			    }
+			);
+		}
+	};
+
+	if (auto* waylandWindow = dynamic_cast<QWaylandWindow*>(window->handle())) {
+		tryAddWayland(waylandWindow);
+	} else {
+		QObject::connect(window, &QWindow::visibleChanged, this, [window, tryAddWayland]() {
+			if (window->isVisible()) {
+				if (window->handle() == nullptr) {
+					window->create();
+				}
+
+				auto* waylandWindow = dynamic_cast<QWaylandWindow*>(window->handle());
+				tryAddWayland(waylandWindow);
+			}
+		});
+	}
+}
+
+void FocusGrab::removeWindow(QWindow* window) {
+	QObject::disconnect(window, nullptr, this, nullptr);
+
+	if (auto* waylandWindow = dynamic_cast<QWaylandWindow*>(window->handle())) {
+		this->pendingAdditions.removeAll(waylandWindow);
+		this->remove_surface(waylandWindow->surface());
+		this->commitRequired = true;
+	}
+}
+
+void FocusGrab::addWaylandWindow(QWaylandWindow* window) {
+	this->add_surface(window->surface());
+	this->pendingAdditions.append(window);
+	this->commitRequired = true;
+}
+
+void FocusGrab::sync() {
+	if (this->transactionActive) return;
+
+	if (this->commitRequired) {
+		this->commit();
+		this->commitRequired = false;
+
+		// the protocol will always send cleared() when the grab is deactivated,
+		// even if it was due to window destruction, so we don't need to track it.
+		if (!this->pendingAdditions.isEmpty()) {
+			this->pendingAdditions.clear();
+
+			if (!this->active) {
+				this->active = true;
+				emit this->activated();
+			}
+		}
+	}
+}
+
+void FocusGrab::startTransaction() { this->transactionActive = true; }
+
+void FocusGrab::completeTransaction() {
+	this->transactionActive = false;
+	this->sync();
+}
+
+void FocusGrab::hyprland_focus_grab_v1_cleared() {
+	this->active = false;
+	emit this->cleared();
+}
+
+} // namespace qs::hyprland::focus_grab
diff --git a/src/wayland/hyprland/focus_grab/grab.hpp b/src/wayland/hyprland/focus_grab/grab.hpp
new file mode 100644
index 00000000..99d5125c
--- /dev/null
+++ b/src/wayland/hyprland/focus_grab/grab.hpp
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <private/qwaylandwindow_p.h>
+#include <qlist.h>
+#include <qobject.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qwayland-hyprland-focus-grab-v1.h>
+#include <qwindow.h>
+#include <wayland-hyprland-focus-grab-v1-client-protocol.h>
+
+namespace qs::hyprland::focus_grab {
+using HyprlandFocusGrab = QtWayland::hyprland_focus_grab_v1;
+
+class FocusGrab
+    : public QObject
+    , public HyprlandFocusGrab {
+	using QWaylandWindow = QtWaylandClient::QWaylandWindow;
+
+	Q_OBJECT;
+
+public:
+	explicit FocusGrab(::hyprland_focus_grab_v1* grab);
+	~FocusGrab() override;
+	Q_DISABLE_COPY_MOVE(FocusGrab);
+
+	[[nodiscard]] bool isActive() const;
+	void addWindow(QWindow* window);
+	void removeWindow(QWindow* window);
+	void sync();
+	void startTransaction();
+	void completeTransaction();
+
+signals:
+	void activated();
+	void cleared();
+
+private:
+	void hyprland_focus_grab_v1_cleared() override;
+
+	void addWaylandWindow(QWaylandWindow* window);
+
+	QList<QWaylandWindow*> pendingAdditions;
+	bool commitRequired = false;
+	bool transactionActive = false;
+	bool active = false;
+};
+
+} // namespace qs::hyprland::focus_grab
diff --git a/src/wayland/hyprland/focus_grab/hyprland-focus-grab-v1.xml b/src/wayland/hyprland/focus_grab/hyprland-focus-grab-v1.xml
new file mode 100644
index 00000000..3b3cd344
--- /dev/null
+++ b/src/wayland/hyprland/focus_grab/hyprland-focus-grab-v1.xml
@@ -0,0 +1,128 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="hyprland_focus_grab_v1">
+  <copyright>
+    Copyright © 2024 outfoxxed
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this
+       list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright notice,
+       this list of conditions and the following disclaimer in the documentation
+       and/or other materials provided with the distribution.
+
+    3. Neither the name of the copyright holder nor the names of its
+       contributors may be used to endorse or promote products derived from
+       this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  </copyright>
+
+  <description summary="limit input focus to a set of surfaces">
+    This protocol allows clients to limit input focus to a specific set
+    of surfaces and receive a notification when the limiter is removed as
+    detailed below.
+  </description>
+
+  <interface name="hyprland_focus_grab_manager_v1" version="1">
+    <description summary="manager for focus grab objects">
+      This interface allows a client to create surface grab objects.
+    </description>
+
+    <request name="create_grab">
+      <description summary="create a focus grab object">
+        Create a surface grab object.
+      </description>
+
+      <arg name="grab" type="new_id" interface="hyprland_focus_grab_v1"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the focus grab manager">
+        Destroy the focus grab manager.
+        This doesn't destroy existing focus grab objects.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="hyprland_focus_grab_v1" version="1">
+    <description summary="input focus limiter">
+      This interface restricts input focus to a specified whitelist of
+      surfaces as long as the focus grab object exists and has at least
+      one comitted surface.
+
+      Mouse and touch events inside a whitelisted surface will be passed
+      to the surface normally, while events outside of a whitelisted surface
+      will clear the grab object. Keyboard events will be passed to the client
+      and a compositor-picked surface in the whitelist will receive a
+      wl_keyboard::enter event if a whitelisted surface is not already entered.
+
+      Upon meeting implementation-defined criteria usually meaning a mouse or
+      touch input outside of any whitelisted surfaces, the compositor will
+      clear the whitelist, rendering the grab inert and sending the cleared
+      event. The same will happen if another focus grab or similar action
+      is started at the compositor's discretion.
+    </description>
+
+    <request name="add_surface">
+      <description summary="add a surface to the focus whitelist">
+        Add a surface to the whitelist. Destroying the surface is treated the
+        same as an explicit call to remove_surface and duplicate additions are
+        ignored.
+
+        Does not take effect until commit is called.
+      </description>
+
+      <arg name="surface" type="object" interface="wl_surface"/>
+    </request>
+
+    <request name="remove_surface">
+      <description summary="remove a surface from the focus whitelist">
+        Remove a surface from the whitelist. Destroying the surface is treated
+        the same as an explicit call to this function.
+
+        If the grab was active and the removed surface was entered by the
+        keyboard, another surface will be entered on commit.
+
+        Does not take effect until commit is called.
+      </description>
+
+      <arg name="surface" type="object" interface="wl_surface"/>
+    </request>
+
+    <request name="commit">
+      <description summary="commit the focus whitelist">
+        Commit pending changes to the surface whitelist.
+
+        If the list previously had no entries and now has at least one, the grab
+        will start. If it previously had entries and now has none, the grab will
+        become inert.
+      </description>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the focus grab">
+        Destroy the grab object and remove the grab if active.
+      </description>
+    </request>
+
+    <event name="cleared">
+      <description summary="the focus grab was cleared">
+        Sent when an active grab is cancelled by the compositor,
+        regardless of cause.
+      </description>
+    </event>
+  </interface>
+</protocol>
diff --git a/src/wayland/hyprland/focus_grab/manager.cpp b/src/wayland/hyprland/focus_grab/manager.cpp
new file mode 100644
index 00000000..fb93e317
--- /dev/null
+++ b/src/wayland/hyprland/focus_grab/manager.cpp
@@ -0,0 +1,27 @@
+#include "manager.hpp"
+
+#include <qwaylandclientextension.h>
+
+#include "grab.hpp"
+
+namespace qs::hyprland::focus_grab {
+
+FocusGrabManager::FocusGrabManager(): QWaylandClientExtensionTemplate<FocusGrabManager>(1) {
+	this->initialize();
+}
+
+bool FocusGrabManager::available() const { return this->isActive(); }
+
+FocusGrab* FocusGrabManager::createGrab() { return new FocusGrab(this->create_grab()); }
+
+FocusGrabManager* FocusGrabManager::instance() {
+	static FocusGrabManager* instance = nullptr; // NOLINT
+
+	if (instance == nullptr) {
+		instance = new FocusGrabManager();
+	}
+
+	return instance;
+}
+
+} // namespace qs::hyprland::focus_grab
diff --git a/src/wayland/hyprland/focus_grab/manager.hpp b/src/wayland/hyprland/focus_grab/manager.hpp
new file mode 100644
index 00000000..86681482
--- /dev/null
+++ b/src/wayland/hyprland/focus_grab/manager.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <qwayland-hyprland-focus-grab-v1.h>
+#include <qwaylandclientextension.h>
+
+namespace qs::hyprland::focus_grab {
+using HyprlandFocusGrabManager = QtWayland::hyprland_focus_grab_manager_v1;
+class FocusGrab;
+
+class FocusGrabManager
+    : public QWaylandClientExtensionTemplate<FocusGrabManager>
+    , public HyprlandFocusGrabManager {
+public:
+	explicit FocusGrabManager();
+
+	[[nodiscard]] bool available() const;
+	[[nodiscard]] FocusGrab* createGrab();
+
+	static FocusGrabManager* instance();
+};
+
+} // namespace qs::hyprland::focus_grab
diff --git a/src/wayland/hyprland/focus_grab/qml.cpp b/src/wayland/hyprland/focus_grab/qml.cpp
new file mode 100644
index 00000000..e26a75a5
--- /dev/null
+++ b/src/wayland/hyprland/focus_grab/qml.cpp
@@ -0,0 +1,133 @@
+#include "qml.hpp"
+#include <utility>
+
+#include <qlist.h>
+#include <qlogging.h>
+#include <qobject.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+#include <qwindow.h>
+
+#include "../../../window/proxywindow.hpp"
+#include "../../../window/windowinterface.hpp"
+#include "grab.hpp"
+#include "manager.hpp"
+
+namespace qs::hyprland {
+using focus_grab::FocusGrab;
+using focus_grab::FocusGrabManager;
+
+void HyprlandFocusGrab::componentComplete() { this->tryActivate(); }
+
+bool HyprlandFocusGrab::isActive() const { return this->grab != nullptr && this->grab->isActive(); }
+
+void HyprlandFocusGrab::setActive(bool active) {
+	if (active == this->targetActive) return;
+	this->targetActive = active;
+
+	if (!active) {
+		delete this->grab;
+		this->grab = nullptr;
+		emit this->activeChanged();
+	} else {
+		this->tryActivate();
+	}
+}
+
+QObjectList HyprlandFocusGrab::windows() const { return this->windowObjects; }
+
+void HyprlandFocusGrab::setWindows(QObjectList windows) {
+	if (windows == this->windowObjects) return;
+	this->windowObjects = std::move(windows);
+	this->syncWindows();
+	emit this->windowsChanged();
+}
+
+void HyprlandFocusGrab::onGrabActivated() { emit this->activeChanged(); }
+
+void HyprlandFocusGrab::onGrabCleared() {
+	emit this->cleared();
+	this->setActive(false);
+}
+
+void HyprlandFocusGrab::onProxyConnected() {
+	if (this->grab != nullptr) {
+		this->grab->addWindow(qobject_cast<ProxyWindowBase*>(this->sender())->backingWindow());
+		this->grab->sync();
+	}
+}
+
+void HyprlandFocusGrab::tryActivate() {
+	if (!this->targetActive || this->grab) return;
+
+	auto* manager = FocusGrabManager::instance();
+	if (!manager->isActive()) {
+		qWarning() << "The active compositor does not support the hyprland_focus_grab_v1 protocol. "
+		              "HyprlandFocusGrab will not work.";
+		qWarning() << "** Learn why $XDG_CURRENT_DESKTOP sucks and download a better compositor "
+		              "today at https://hyprland.org";
+		return;
+	}
+
+	this->grab = manager->createGrab();
+	this->grab->setParent(this);
+	QObject::connect(this->grab, &FocusGrab::activated, this, &HyprlandFocusGrab::onGrabActivated);
+	QObject::connect(this->grab, &FocusGrab::cleared, this, &HyprlandFocusGrab::onGrabCleared);
+
+	this->grab->startTransaction();
+	for (auto* proxy: this->trackedProxies) {
+		if (proxy->backingWindow() != nullptr) {
+			this->grab->addWindow(proxy->backingWindow());
+		}
+	}
+	this->grab->completeTransaction();
+}
+
+void HyprlandFocusGrab::syncWindows() {
+	auto newProxy = QList<ProxyWindowBase*>();
+	for (auto* windowObject: this->windowObjects) {
+		auto* proxyWindow = qobject_cast<ProxyWindowBase*>(windowObject);
+
+		if (proxyWindow == nullptr) {
+			if (auto* iface = qobject_cast<WindowInterface*>(windowObject)) {
+				proxyWindow = iface->proxyWindow();
+			}
+		}
+
+		if (proxyWindow != nullptr) {
+			newProxy.push_back(proxyWindow);
+		}
+	}
+
+	if (this->grab) this->grab->startTransaction();
+
+	for (auto* oldWindow: this->trackedProxies) {
+		if (!newProxy.contains(oldWindow)) {
+			QObject::disconnect(oldWindow, nullptr, this, nullptr);
+
+			if (this->grab != nullptr && oldWindow->backingWindow() != nullptr) {
+				this->grab->removeWindow(oldWindow->backingWindow());
+			}
+		}
+	}
+
+	for (auto* newProxy: newProxy) {
+		if (!this->trackedProxies.contains(newProxy)) {
+			QObject::connect(
+			    newProxy,
+			    &ProxyWindowBase::windowConnected,
+			    this,
+			    &HyprlandFocusGrab::onProxyConnected
+			);
+
+			if (this->grab != nullptr && newProxy->backingWindow() != nullptr) {
+				this->grab->addWindow(newProxy->backingWindow());
+			}
+		}
+	}
+
+	this->trackedProxies = newProxy;
+	if (this->grab) this->grab->completeTransaction();
+}
+
+} // namespace qs::hyprland
diff --git a/src/wayland/hyprland/focus_grab/qml.hpp b/src/wayland/hyprland/focus_grab/qml.hpp
new file mode 100644
index 00000000..705b0d3d
--- /dev/null
+++ b/src/wayland/hyprland/focus_grab/qml.hpp
@@ -0,0 +1,112 @@
+#pragma once
+
+#include <qlist.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qqmllist.h>
+#include <qqmlparserstatus.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qwindow.h>
+
+class ProxyWindowBase;
+
+namespace qs::hyprland {
+
+namespace focus_grab {
+class FocusGrab;
+}
+
+///! Input focus grabber
+/// Object for managing input focus grabs via the [hyprland_focus_grab_v1]
+/// wayland protocol.
+///
+/// When enabled, all of the windows listed in the `windows` property will
+/// receive input normally, and will retain keyboard focus even if the mouse
+/// is moved off of them. When areas of the screen that are not part of a listed
+/// window are clicked or touched, the grab will become inactive and emit the
+/// cleared signal.
+///
+/// This is useful for implementing dismissal of popup type windows.
+/// ```qml
+/// import Quickshell
+/// import Quickshell.Hyprland
+/// import QtQuick.Controls
+///
+/// ShellRoot {
+///   FloatingWindow {
+///     id: window
+///
+///     Button {
+///       anchors.centerIn: parent
+///       text: grab.active ? "Remove exclusive focus" : "Take exclusive focus"
+///       onClicked: grab.active = !grab.active
+///     }
+///
+///     HyprlandFocusGrab {
+///       id: grab
+///       windows: [ window ]
+///     }
+///   }
+/// }
+/// ```
+///
+/// [hyprland_focus_grab_v1]: https://github.com/hyprwm/hyprland-protocols/blob/main/protocols/hyprland-global-shortcuts-v1.xml
+class HyprlandFocusGrab
+    : public QObject
+    , public QQmlParserStatus {
+	Q_OBJECT;
+	QML_ELEMENT;
+	Q_INTERFACES(QQmlParserStatus);
+	/// If the focus grab is active. Defaults to false.
+	///
+	/// When set to true, an input grab will be created for the listed windows.
+	///
+	/// This property will change to false once the grab is dismissed.
+	/// It will not change to true until the grab begins, which requires
+	/// at least one visible window.
+	Q_PROPERTY(bool active READ isActive WRITE setActive NOTIFY activeChanged);
+	/// The list of windows to whitelist for input.
+	Q_PROPERTY(QList<QObject*> windows READ windows WRITE setWindows NOTIFY windowsChanged);
+
+public:
+	explicit HyprlandFocusGrab(QObject* parent = nullptr): QObject(parent) {}
+
+	void classBegin() override {}
+	void componentComplete() override;
+
+	[[nodiscard]] bool isActive() const;
+	void setActive(bool active);
+
+	[[nodiscard]] QObjectList windows() const;
+	void setWindows(QObjectList windows);
+
+signals:
+	/// Sent whenever the compositor clears the focus grab.
+	///
+	/// This may be in response to all windows being removed
+	/// from the list or simultaneously hidden, in addition to
+	/// a normal clear.
+	void cleared();
+
+	void activeChanged();
+	void windowsChanged();
+
+private slots:
+	void onGrabActivated();
+	void onGrabCleared();
+	void onProxyConnected();
+
+private:
+	void tryActivate();
+	void syncWindows();
+
+	bool targetActive = false;
+	QObjectList windowObjects;
+	QList<ProxyWindowBase*> trackedProxies;
+	QList<QWindow*> trackedWindows;
+
+	focus_grab::FocusGrab* grab = nullptr;
+};
+
+}; // namespace qs::hyprland
diff --git a/src/wayland/hyprland/global_shortcuts/CMakeLists.txt b/src/wayland/hyprland/global_shortcuts/CMakeLists.txt
new file mode 100644
index 00000000..ece0037e
--- /dev/null
+++ b/src/wayland/hyprland/global_shortcuts/CMakeLists.txt
@@ -0,0 +1,25 @@
+qt_add_library(quickshell-hyprland-global-shortcuts STATIC
+	qml.cpp
+	manager.cpp
+	shortcut.cpp
+)
+
+qt_add_qml_module(quickshell-hyprland-global-shortcuts
+	URI Quickshell.Hyprland._GlobalShortcuts
+	VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+install_qml_module(quickshell-hyprland-global-shortcuts)
+
+wl_proto(wlp-hyprland-shortcuts hyprland-global-shortcuts-v1 "${CMAKE_CURRENT_SOURCE_DIR}")
+
+target_link_libraries(quickshell-hyprland-global-shortcuts PRIVATE
+	Qt::Qml Qt::WaylandClient Qt::WaylandClientPrivate wayland-client
+	Qt::Quick # pch
+	wlp-hyprland-shortcuts
+)
+
+qs_module_pch(quickshell-hyprland-global-shortcuts)
+
+target_link_libraries(quickshell PRIVATE quickshell-hyprland-global-shortcutsplugin)
diff --git a/src/wayland/hyprland/global_shortcuts/hyprland-global-shortcuts-v1.xml b/src/wayland/hyprland/global_shortcuts/hyprland-global-shortcuts-v1.xml
new file mode 100644
index 00000000..784d887e
--- /dev/null
+++ b/src/wayland/hyprland/global_shortcuts/hyprland-global-shortcuts-v1.xml
@@ -0,0 +1,112 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="hyprland_global_shortcuts_v1">
+  <copyright>
+    Copyright © 2022 Vaxry
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this
+       list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright notice,
+       this list of conditions and the following disclaimer in the documentation
+       and/or other materials provided with the distribution.
+
+    3. Neither the name of the copyright holder nor the names of its
+       contributors may be used to endorse or promote products derived from
+       this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  </copyright>
+
+  <description summary="registering global shortcuts">
+    This protocol allows a client to register triggerable actions,
+    meant to be global shortcuts.
+  </description>
+
+  <interface name="hyprland_global_shortcuts_manager_v1" version="1">
+    <description summary="manager to register global shortcuts">
+      This object is a manager which offers requests to create global shortcuts.
+    </description>
+
+    <request name="register_shortcut">
+      <description summary="register a shortcut">
+        Register a new global shortcut.
+
+        A global shortcut is anonymous, meaning the app does not know what key(s) trigger it.
+
+        The shortcut's keybinding shall be dealt with by the compositor.
+
+        In the case of a duplicate app_id + id combination, the already_taken protocol error is raised.
+      </description>
+      <arg name="shortcut" type="new_id" interface="hyprland_global_shortcut_v1"/>
+      <arg name="id" type="string" summary="a unique id for the shortcut"/>
+      <arg name="app_id" type="string" summary="the app_id of the application requesting the shortcut"/>
+      <arg name="description" type="string" summary="user-readable text describing what the shortcut does."/>
+      <arg name="trigger_description" type="string" summary="user-readable text describing how to trigger the shortcut for the client to render."/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the manager">
+        All objects created by the manager will still remain valid, until their
+        appropriate destroy request has been called.
+      </description>
+    </request>
+
+    <enum name="error">
+      <entry name="already_taken" value="0"
+        summary="the app_id + id combination has already been registered."/>
+    </enum>
+  </interface>
+
+  <interface name="hyprland_global_shortcut_v1" version="1">
+    <description summary="a shortcut">
+      This object represents a single shortcut.
+    </description>
+
+    <event name="pressed">
+      <description summary="keystroke pressed">
+        The keystroke was pressed.
+
+        tv_ values hold the timestamp of the occurrence.
+      </description>
+      <arg name="tv_sec_hi" type="uint"
+           summary="high 32 bits of the seconds part of the timestamp"/>
+      <arg name="tv_sec_lo" type="uint"
+           summary="low 32 bits of the seconds part of the timestamp"/>
+      <arg name="tv_nsec" type="uint"
+           summary="nanoseconds part of the timestamp"/>
+    </event>
+
+    <event name="released">
+      <description summary="keystroke released">
+        The keystroke was released.
+
+        tv_ values hold the timestamp of the occurrence.
+      </description>
+      <arg name="tv_sec_hi" type="uint"
+           summary="high 32 bits of the seconds part of the timestamp"/>
+      <arg name="tv_sec_lo" type="uint"
+           summary="low 32 bits of the seconds part of the timestamp"/>
+      <arg name="tv_nsec" type="uint"
+           summary="nanoseconds part of the timestamp"/>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="delete this object, used or not">
+        Destroys the shortcut. Can be sent at any time by the client.
+      </description>
+    </request>
+  </interface>
+</protocol>
diff --git a/src/wayland/hyprland/global_shortcuts/manager.cpp b/src/wayland/hyprland/global_shortcuts/manager.cpp
new file mode 100644
index 00000000..ce0f24c4
--- /dev/null
+++ b/src/wayland/hyprland/global_shortcuts/manager.cpp
@@ -0,0 +1,55 @@
+#include "manager.hpp"
+
+#include <qstring.h>
+#include <qwaylandclientextension.h>
+
+#include "shortcut.hpp"
+
+namespace qs::hyprland::global_shortcuts::impl {
+
+GlobalShortcutManager::GlobalShortcutManager()
+    : QWaylandClientExtensionTemplate<GlobalShortcutManager>(1) {
+	this->initialize();
+}
+
+GlobalShortcut* GlobalShortcutManager::registerShortcut(
+    const QString& appid,
+    const QString& name,
+    const QString& description,
+    const QString& triggerDescription
+) {
+	auto shortcut = this->shortcuts.value({appid, name});
+
+	if (shortcut.second != nullptr) {
+		this->shortcuts.insert({appid, name}, {shortcut.first + 1, shortcut.second});
+		return shortcut.second;
+	} else {
+		auto* shortcutObj = this->register_shortcut(name, appid, description, triggerDescription);
+		auto* managedObj = new GlobalShortcut(shortcutObj);
+		this->shortcuts.insert({appid, name}, {1, managedObj});
+		return managedObj;
+	}
+}
+
+void GlobalShortcutManager::unregisterShortcut(const QString& appid, const QString& name) {
+	auto shortcut = this->shortcuts.value({appid, name});
+
+	if (shortcut.first > 1) {
+		this->shortcuts.insert({appid, name}, {shortcut.first - 1, shortcut.second});
+	} else {
+		delete shortcut.second;
+		this->shortcuts.remove({appid, name});
+	}
+}
+
+GlobalShortcutManager* GlobalShortcutManager::instance() {
+	static GlobalShortcutManager* instance = nullptr; // NOLINT
+
+	if (instance == nullptr) {
+		instance = new GlobalShortcutManager();
+	}
+
+	return instance;
+}
+
+} // namespace qs::hyprland::global_shortcuts::impl
diff --git a/src/wayland/hyprland/global_shortcuts/manager.hpp b/src/wayland/hyprland/global_shortcuts/manager.hpp
new file mode 100644
index 00000000..0a165c53
--- /dev/null
+++ b/src/wayland/hyprland/global_shortcuts/manager.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qhash.h>
+#include <qstring.h>
+#include <qwayland-hyprland-global-shortcuts-v1.h>
+#include <qwaylandclientextension.h>
+
+#include "shortcut.hpp"
+
+namespace qs::hyprland::global_shortcuts::impl {
+
+class GlobalShortcutManager
+    : public QWaylandClientExtensionTemplate<GlobalShortcutManager>
+    , public QtWayland::hyprland_global_shortcuts_manager_v1 {
+public:
+	explicit GlobalShortcutManager();
+
+	GlobalShortcut* registerShortcut(
+	    const QString& appid,
+	    const QString& name,
+	    const QString& description,
+	    const QString& triggerDescription
+	);
+
+	void unregisterShortcut(const QString& appid, const QString& name);
+
+	static GlobalShortcutManager* instance();
+
+private:
+	QHash<QPair<QString, QString>, QPair<qint32, GlobalShortcut*>> shortcuts;
+};
+
+} // namespace qs::hyprland::global_shortcuts::impl
diff --git a/src/wayland/hyprland/global_shortcuts/qml.cpp b/src/wayland/hyprland/global_shortcuts/qml.cpp
new file mode 100644
index 00000000..1faa724c
--- /dev/null
+++ b/src/wayland/hyprland/global_shortcuts/qml.cpp
@@ -0,0 +1,114 @@
+#include "qml.hpp"
+#include <utility>
+
+#include <qlogging.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+#include "manager.hpp"
+
+namespace qs::hyprland::global_shortcuts {
+using impl::GlobalShortcutManager;
+
+GlobalShortcut::~GlobalShortcut() {
+	auto* manager = GlobalShortcutManager::instance();
+	if (manager != nullptr) {
+		manager->unregisterShortcut(this->mAppid, this->mName);
+	}
+}
+
+void GlobalShortcut::onPostReload() {
+	if (this->mName.isEmpty()) {
+		qWarning() << "Unable to create GlobalShortcut with empty name.";
+		return;
+	}
+
+	auto* manager = GlobalShortcutManager::instance();
+	if (!manager->isActive()) {
+		qWarning() << "The active compositor does not support hyprland_global_shortcuts_v1.";
+		qWarning() << "GlobalShortcut will not work.";
+		return;
+	}
+
+	this->shortcut = manager->registerShortcut(
+	    this->mAppid,
+	    this->mName,
+	    this->mDescription,
+	    this->mTriggerDescription
+	);
+
+	QObject::connect(this->shortcut, &ShortcutImpl::pressed, this, &GlobalShortcut::onPressed);
+	QObject::connect(this->shortcut, &ShortcutImpl::released, this, &GlobalShortcut::onReleased);
+}
+
+bool GlobalShortcut::isPressed() const { return this->mPressed; }
+
+QString GlobalShortcut::appid() const { return this->mAppid; }
+
+void GlobalShortcut::setAppid(QString appid) {
+	if (this->shortcut != nullptr) {
+		qWarning() << "GlobalShortcut cannot be modified after creation.";
+		return;
+	}
+
+	if (appid == this->mAppid) return;
+
+	this->mAppid = std::move(appid);
+	emit this->appidChanged();
+}
+
+QString GlobalShortcut::name() const { return this->mName; }
+
+void GlobalShortcut::setName(QString name) {
+	if (this->shortcut != nullptr) {
+		qWarning() << "GlobalShortcut cannot be modified after creation.";
+		return;
+	}
+
+	if (name == this->mName) return;
+
+	this->mName = std::move(name);
+	emit this->nameChanged();
+}
+
+QString GlobalShortcut::description() const { return this->mDescription; }
+
+void GlobalShortcut::setDescription(QString description) {
+	if (this->shortcut != nullptr) {
+		qWarning() << "GlobalShortcut cannot be modified after creation.";
+		return;
+	}
+
+	if (description == this->mDescription) return;
+
+	this->mDescription = std::move(description);
+	emit this->descriptionChanged();
+}
+
+QString GlobalShortcut::triggerDescription() const { return this->mTriggerDescription; }
+
+void GlobalShortcut::setTriggerDescription(QString triggerDescription) {
+	if (this->shortcut != nullptr) {
+		qWarning() << "GlobalShortcut cannot be modified after creation.";
+		return;
+	}
+
+	if (triggerDescription == this->mTriggerDescription) return;
+
+	this->mTriggerDescription = std::move(triggerDescription);
+	emit this->triggerDescriptionChanged();
+}
+
+void GlobalShortcut::onPressed() {
+	this->mPressed = true;
+	emit this->pressed();
+	emit this->pressedChanged();
+}
+
+void GlobalShortcut::onReleased() {
+	this->mPressed = false;
+	emit this->released();
+	emit this->pressedChanged();
+}
+
+} // namespace qs::hyprland::global_shortcuts
diff --git a/src/wayland/hyprland/global_shortcuts/qml.hpp b/src/wayland/hyprland/global_shortcuts/qml.hpp
new file mode 100644
index 00000000..f257632f
--- /dev/null
+++ b/src/wayland/hyprland/global_shortcuts/qml.hpp
@@ -0,0 +1,106 @@
+#pragma once
+
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+
+#include "../../../core/reload.hpp"
+#include "shortcut.hpp"
+
+namespace qs::hyprland::global_shortcuts {
+
+///! Hyprland global shortcut.
+/// Global shortcut implemented with [hyprland_global_shortcuts_v1].
+///
+/// You can use this within hyprland as a global shortcut:
+/// ```
+/// bind = <modifiers>, <key>, global, <appid>:<name>
+/// ```
+/// See [the wiki] for details.
+///
+/// > [!WARNING] The shortcuts protocol does not allow duplicate appid + name pairs.
+/// > Within a single instance of quickshell this is handled internally, and both
+/// > users will be notified, but multiple instances of quickshell or XDPH may collide.
+/// >
+/// > If that happens, whichever client that tries to register the shortcuts last will crash.
+///
+/// > [!INFO] This type does *not* use the xdg-desktop-portal global shortcuts protocol,
+/// > as it is not fully functional without flatpak and would cause a considerably worse
+/// > user experience from other limitations. It will only work with Hyprland.
+/// > Note that, as this type bypasses xdg-desktop-portal, XDPH is not required.
+///
+/// [hyprland_global_shortcuts_v1]: https://github.com/hyprwm/hyprland-protocols/blob/main/protocols/hyprland-global-shortcuts-v1.xml
+/// [the wiki]: https://wiki.hyprland.org/Configuring/Binds/#dbus-global-shortcuts
+class GlobalShortcut: public PostReloadHook {
+	using ShortcutImpl = impl::GlobalShortcut;
+
+	Q_OBJECT;
+	// clang-format off
+	/// If the keybind is currently pressed.
+	Q_PROPERTY(bool pressed READ isPressed NOTIFY pressedChanged);
+	/// The appid of the shortcut. Defaults to `quickshell`.
+	/// You cannot change this at runtime.
+	///
+	/// If you have more than one shortcut we recommend subclassing
+	/// GlobalShortcut to set this.
+	Q_PROPERTY(QString appid READ appid WRITE setAppid NOTIFY appidChanged);
+	/// The name of the shortcut.
+	/// You cannot change this at runtime.
+	Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged);
+	/// The description of the shortcut that appears in `hyprctl globalshortcuts`.
+	/// You cannot change this at runtime.
+	Q_PROPERTY(QString description READ description WRITE setDescription NOTIFY descriptionChanged);
+	/// Have not seen this used ever, but included for completeness. Safe to ignore.
+	Q_PROPERTY(QString triggerDescription READ triggerDescription WRITE setTriggerDescription NOTIFY triggerDescriptionChanged);
+	// clang-format on
+	QML_ELEMENT;
+
+public:
+	explicit GlobalShortcut(QObject* parent = nullptr): PostReloadHook(parent) {}
+	~GlobalShortcut() override;
+	Q_DISABLE_COPY_MOVE(GlobalShortcut);
+
+	void onPostReload() override;
+
+	[[nodiscard]] bool isPressed() const;
+
+	[[nodiscard]] QString appid() const;
+	void setAppid(QString appid);
+
+	[[nodiscard]] QString name() const;
+	void setName(QString name);
+
+	[[nodiscard]] QString description() const;
+	void setDescription(QString description);
+
+	[[nodiscard]] QString triggerDescription() const;
+	void setTriggerDescription(QString triggerDescription);
+
+signals:
+	/// Fired when the keybind is pressed.
+	void pressed();
+	/// Fired when the keybind is released.
+	void released();
+
+	void pressedChanged();
+	void appidChanged();
+	void nameChanged();
+	void descriptionChanged();
+	void triggerDescriptionChanged();
+
+private slots:
+	void onPressed();
+	void onReleased();
+
+private:
+	impl::GlobalShortcut* shortcut = nullptr;
+
+	bool mPressed = false;
+	QString mAppid = "quickshell";
+	QString mName;
+	QString mDescription;
+	QString mTriggerDescription;
+};
+
+} // namespace qs::hyprland::global_shortcuts
diff --git a/src/wayland/hyprland/global_shortcuts/shortcut.cpp b/src/wayland/hyprland/global_shortcuts/shortcut.cpp
new file mode 100644
index 00000000..2178d775
--- /dev/null
+++ b/src/wayland/hyprland/global_shortcuts/shortcut.cpp
@@ -0,0 +1,33 @@
+#include "shortcut.hpp"
+
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <wayland-hyprland-global-shortcuts-v1-client-protocol.h>
+
+namespace qs::hyprland::global_shortcuts::impl {
+
+GlobalShortcut::GlobalShortcut(::hyprland_global_shortcut_v1* shortcut) { this->init(shortcut); }
+
+GlobalShortcut::~GlobalShortcut() {
+	if (this->isInitialized()) {
+		this->destroy();
+	}
+}
+
+void GlobalShortcut::hyprland_global_shortcut_v1_pressed(
+    quint32 /*unused*/,
+    quint32 /*unused*/,
+    quint32 /*unused*/
+) {
+	emit this->pressed();
+}
+
+void GlobalShortcut::hyprland_global_shortcut_v1_released(
+    quint32 /*unused*/,
+    quint32 /*unused*/,
+    quint32 /*unused*/
+) {
+	emit this->released();
+}
+
+} // namespace qs::hyprland::global_shortcuts::impl
diff --git a/src/wayland/hyprland/global_shortcuts/shortcut.hpp b/src/wayland/hyprland/global_shortcuts/shortcut.hpp
new file mode 100644
index 00000000..6aa8fd58
--- /dev/null
+++ b/src/wayland/hyprland/global_shortcuts/shortcut.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <qobject.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qwayland-hyprland-global-shortcuts-v1.h>
+
+namespace qs::hyprland::global_shortcuts::impl {
+
+class GlobalShortcut
+    : public QObject
+    , public QtWayland::hyprland_global_shortcut_v1 {
+	Q_OBJECT;
+
+public:
+	explicit GlobalShortcut(::hyprland_global_shortcut_v1* shortcut);
+	~GlobalShortcut() override;
+	Q_DISABLE_COPY_MOVE(GlobalShortcut);
+
+signals:
+	void pressed();
+	void released();
+
+private:
+	// clang-format off
+	void hyprland_global_shortcut_v1_pressed(quint32 tvSecHi, quint32 tvSecLo, quint32 tvNsec) override;
+	void hyprland_global_shortcut_v1_released(quint32 tvSecHi, quint32 tvSecLo, quint32 tvNsec) override;
+	// clang-format on
+};
+
+} // namespace qs::hyprland::global_shortcuts::impl
diff --git a/src/wayland/hyprland/ipc/CMakeLists.txt b/src/wayland/hyprland/ipc/CMakeLists.txt
new file mode 100644
index 00000000..fd014635
--- /dev/null
+++ b/src/wayland/hyprland/ipc/CMakeLists.txt
@@ -0,0 +1,37 @@
+qt_add_library(quickshell-hyprland-ipc STATIC
+	connection.cpp
+	monitor.cpp
+	workspace.cpp
+	qml.cpp
+)
+
+qt_add_qml_module(quickshell-hyprland-ipc
+	URI Quickshell.Hyprland._Ipc
+	VERSION 0.1
+	DEPENDENCIES QtQuick
+)
+
+qs_add_module_deps_light(quickshell-hyprland-ipc Quickshell)
+
+install_qml_module(quickshell-hyprland-ipc)
+
+target_link_libraries(quickshell-hyprland-ipc PRIVATE Qt::Quick)
+
+if (WAYLAND_TOPLEVEL_MANAGEMENT)
+	target_sources(quickshell-hyprland-ipc PRIVATE
+		toplevel_mapping.cpp
+		hyprland_toplevel.cpp
+	)
+
+	wl_proto(wlp-hyprland-toplevel-mapping hyprland-toplevel-mapping-v1 "${CMAKE_CURRENT_SOURCE_DIR}")
+
+	target_link_libraries(quickshell-hyprland-ipc PRIVATE
+		Qt::WaylandClient Qt::WaylandClientPrivate wayland-client
+		wlp-hyprland-toplevel-mapping
+		wlp-foreign-toplevel
+	)
+endif()
+
+qs_module_pch(quickshell-hyprland-ipc SET large)
+
+target_link_libraries(quickshell PRIVATE quickshell-hyprland-ipcplugin)
diff --git a/src/wayland/hyprland/ipc/connection.cpp b/src/wayland/hyprland/ipc/connection.cpp
new file mode 100644
index 00000000..067b9222
--- /dev/null
+++ b/src/wayland/hyprland/ipc/connection.cpp
@@ -0,0 +1,848 @@
+#include "connection.hpp"
+#include <algorithm>
+#include <functional>
+#include <utility>
+
+#include <qbytearrayview.h>
+#include <qcontainerfwd.h>
+#include <qdir.h>
+#include <qfileinfo.h>
+#include <qjsonarray.h>
+#include <qjsondocument.h>
+#include <qjsonobject.h>
+#include <qlocalsocket.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqml.h>
+#include <qtenvironmentvariables.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+
+#include "../../../core/logcat.hpp"
+#include "../../../core/model.hpp"
+#include "../../../core/qmlscreen.hpp"
+#include "../../toplevel_management/handle.hpp"
+#include "hyprland_toplevel.hpp"
+#include "monitor.hpp"
+#include "toplevel_mapping.hpp"
+#include "workspace.hpp"
+
+namespace qs::hyprland::ipc {
+
+namespace {
+QS_LOGGING_CATEGORY(logHyprlandIpc, "quickshell.hyprland.ipc", QtWarningMsg);
+QS_LOGGING_CATEGORY(logHyprlandIpcEvents, "quickshell.hyprland.ipc.events", QtWarningMsg);
+} // namespace
+
+HyprlandIpc::HyprlandIpc() {
+	auto his = qEnvironmentVariable("HYPRLAND_INSTANCE_SIGNATURE");
+	if (his.isEmpty()) {
+		qWarning() << "$HYPRLAND_INSTANCE_SIGNATURE is unset. Cannot connect to hyprland.";
+		return;
+	}
+
+	auto runtimeDir = qEnvironmentVariable("XDG_RUNTIME_DIR");
+	auto hyprlandDir = runtimeDir + "/hypr/" + his;
+
+	if (!QFileInfo(hyprlandDir).isDir()) {
+		hyprlandDir = "/tmp/hypr/" + his;
+	}
+
+	if (!QFileInfo(hyprlandDir).isDir()) {
+		qWarning() << "Unable to find hyprland socket. Cannot connect to hyprland.";
+		return;
+	}
+
+	this->bFocusedWorkspace.setBinding([this]() -> HyprlandWorkspace* {
+		if (!this->bFocusedMonitor) return nullptr;
+		return this->bFocusedMonitor->bindableActiveWorkspace().value();
+	});
+
+	this->mRequestSocketPath = hyprlandDir + "/.socket.sock";
+	this->mEventSocketPath = hyprlandDir + "/.socket2.sock";
+
+	// clang-format off
+	QObject::connect(&this->eventSocket, &QLocalSocket::errorOccurred, this, &HyprlandIpc::eventSocketError);
+	QObject::connect(&this->eventSocket, &QLocalSocket::stateChanged, this, &HyprlandIpc::eventSocketStateChanged);
+	QObject::connect(&this->eventSocket, &QLocalSocket::readyRead, this, &HyprlandIpc::eventSocketReady);
+
+	auto *instance = HyprlandToplevelMappingManager::instance();
+	QObject::connect(instance, &HyprlandToplevelMappingManager::toplevelAddressed, this, &HyprlandIpc::toplevelAddressed);
+
+	// clang-format on
+
+	this->eventSocket.connectToServer(this->mEventSocketPath, QLocalSocket::ReadOnly);
+	this->refreshMonitors(true);
+	this->refreshWorkspaces(true);
+	this->refreshToplevels();
+}
+
+QString HyprlandIpc::requestSocketPath() const { return this->mRequestSocketPath; }
+QString HyprlandIpc::eventSocketPath() const { return this->mEventSocketPath; }
+
+void HyprlandIpc::eventSocketError(QLocalSocket::LocalSocketError error) const {
+	if (!this->valid) {
+		qWarning() << "Unable to connect to hyprland event socket:" << error;
+	} else {
+		qWarning() << "Hyprland event socket error:" << error;
+	}
+}
+
+void HyprlandIpc::eventSocketStateChanged(QLocalSocket::LocalSocketState state) {
+	if (state == QLocalSocket::ConnectedState) {
+		qCInfo(logHyprlandIpc) << "Hyprland event socket connected.";
+		emit this->connected();
+	} else if (state == QLocalSocket::UnconnectedState && this->valid) {
+		qCWarning(logHyprlandIpc) << "Hyprland event socket disconnected.";
+	}
+
+	this->valid = state == QLocalSocket::ConnectedState;
+}
+
+void HyprlandIpc::eventSocketReady() {
+	while (true) {
+		auto rawEvent = this->eventSocket.readLine();
+		if (rawEvent.isEmpty()) break;
+
+		// remove trailing \n
+		rawEvent.truncate(rawEvent.length() - 1);
+		auto splitIdx = rawEvent.indexOf(">>");
+		auto event = QByteArrayView(rawEvent.data(), splitIdx);
+		auto data = QByteArrayView(
+		    rawEvent.data() + splitIdx + 2,     // NOLINT
+		    rawEvent.data() + rawEvent.length() // NOLINT
+		);
+		qCDebug(logHyprlandIpcEvents) << "Received event:" << rawEvent << "parsed as" << event << data;
+
+		this->event.name = event;
+		this->event.data = data;
+		this->onEvent(&this->event);
+		emit this->rawEvent(&this->event);
+	}
+}
+
+void HyprlandIpc::toplevelAddressed(
+    wayland::toplevel_management::impl::ToplevelHandle* handle,
+    quint64 address
+) {
+	auto* waylandToplevel =
+	    wayland::toplevel_management::ToplevelManager::instance()->forImpl(handle);
+
+	if (!waylandToplevel) return;
+
+	auto* attached = qobject_cast<HyprlandToplevel*>(
+	    qmlAttachedPropertiesObject<HyprlandToplevel>(waylandToplevel, false)
+	);
+
+	auto* hyprToplevel = this->findToplevelByAddress(address, true);
+
+	if (attached) {
+		if (attached->address()) {
+			qCDebug(logHyprlandIpc) << "Toplevel" << attached->addressStr() << "already has address"
+			                        << address;
+
+			return;
+		}
+
+		attached->setAddress(address);
+		attached->setHyprlandHandle(hyprToplevel);
+	}
+
+	hyprToplevel->setWaylandHandle(waylandToplevel->implHandle());
+}
+
+void HyprlandIpc::makeRequest(
+    const QByteArray& request,
+    const std::function<void(bool, QByteArray)>& callback
+) {
+	auto* requestSocket = new QLocalSocket(this);
+	qCDebug(logHyprlandIpc) << "Making request:" << request;
+
+	auto connectedCallback = [this, request, requestSocket, callback]() {
+		auto responseCallback = [requestSocket, callback]() {
+			auto response = requestSocket->readAll();
+			callback(true, std::move(response));
+			delete requestSocket;
+		};
+
+		QObject::connect(requestSocket, &QLocalSocket::readyRead, this, responseCallback);
+
+		requestSocket->write(request);
+		requestSocket->flush();
+	};
+
+	auto errorCallback = [=](QLocalSocket::LocalSocketError error) {
+		qCWarning(logHyprlandIpc) << "Error making request:" << error << "request:" << request;
+		requestSocket->deleteLater();
+		callback(false, {});
+	};
+
+	QObject::connect(requestSocket, &QLocalSocket::connected, this, connectedCallback);
+	QObject::connect(requestSocket, &QLocalSocket::errorOccurred, this, errorCallback);
+
+	requestSocket->connectToServer(this->mRequestSocketPath);
+}
+
+void HyprlandIpc::dispatch(const QString& request) {
+	this->makeRequest(
+	    ("dispatch " + request).toUtf8(),
+	    [request](bool success, const QByteArray& response) {
+		    if (!success) {
+			    qCWarning(logHyprlandIpc) << "Failed to request dispatch of" << request;
+			    return;
+		    }
+
+		    if (response != "ok") {
+			    qCWarning(logHyprlandIpc)
+			        << "Dispatch request" << request << "failed with error" << response;
+		    }
+	    }
+	);
+}
+
+ObjectModel<HyprlandMonitor>* HyprlandIpc::monitors() { return &this->mMonitors; }
+
+ObjectModel<HyprlandWorkspace>* HyprlandIpc::workspaces() { return &this->mWorkspaces; }
+
+ObjectModel<HyprlandToplevel>* HyprlandIpc::toplevels() { return &this->mToplevels; }
+
+QVector<QByteArrayView> HyprlandIpc::parseEventArgs(QByteArrayView event, quint16 count) {
+	auto args = QVector<QByteArrayView>();
+
+	for (auto i = 0; i < count - 1; i++) {
+		auto splitIdx = event.indexOf(',');
+		if (splitIdx == -1) break;
+		args.push_back(event.sliced(0, splitIdx));
+		event = event.sliced(splitIdx + 1);
+	}
+
+	if (!event.isEmpty()) {
+		args.push_back(event);
+	}
+
+	while (args.length() < count) {
+		args.push_back(QByteArrayView());
+	}
+
+	return args;
+}
+
+QVector<QString> HyprlandIpcEvent::parse(qint32 argumentCount) const {
+	auto args = QVector<QString>();
+
+	for (auto arg: this->parseView(argumentCount)) {
+		args.push_back(QString::fromUtf8(arg));
+	}
+
+	return args;
+}
+
+QVector<QByteArrayView> HyprlandIpcEvent::parseView(qint32 argumentCount) const {
+	return HyprlandIpc::parseEventArgs(this->data, argumentCount);
+}
+
+QString HyprlandIpcEvent::nameStr() const { return QString::fromUtf8(this->name); }
+QString HyprlandIpcEvent::dataStr() const { return QString::fromUtf8(this->data); }
+
+HyprlandIpc* HyprlandIpc::instance() {
+	static HyprlandIpc* instance = nullptr; // NOLINT
+
+	if (instance == nullptr) {
+		instance = new HyprlandIpc();
+	}
+
+	return instance;
+}
+
+void HyprlandIpc::onEvent(HyprlandIpcEvent* event) {
+	if (event->name == "configreloaded") {
+		this->refreshMonitors(true);
+		this->refreshWorkspaces(true);
+		this->refreshToplevels();
+	} else if (event->name == "monitoraddedv2") {
+		auto args = event->parseView(3);
+
+		auto id = args.at(0).toInt();
+		auto name = QString::fromUtf8(args.at(1));
+
+		// hyprland will often reference the monitor before creation, in which case
+		// it will already exist.
+		auto* monitor = this->findMonitorByName(name, false);
+		auto existed = monitor != nullptr;
+
+		if (monitor == nullptr) {
+			monitor = new HyprlandMonitor(this);
+		}
+
+		qCDebug(logHyprlandIpc) << "Monitor added with id" << id << "name" << name
+		                        << "preemptively created:" << existed;
+
+		monitor->updateInitial(id, name, QString::fromUtf8(args.at(2)));
+
+		if (!existed) {
+			this->mMonitors.insertObject(monitor);
+		}
+
+		// refresh even if it already existed because workspace focus might have changed.
+		this->refreshMonitors(false);
+	} else if (event->name == "monitorremoved") {
+		const auto& mList = this->mMonitors.valueList();
+		auto name = QString::fromUtf8(event->data);
+
+		auto monitorIter = std::ranges::find_if(mList, [name](HyprlandMonitor* m) {
+			return m->bindableName().value() == name;
+		});
+
+		if (monitorIter == mList.end()) {
+			qCWarning(logHyprlandIpc) << "Got removal for monitor" << name
+			                          << "which was not previously tracked.";
+			return;
+		}
+
+		auto index = monitorIter - mList.begin();
+		auto* monitor = *monitorIter;
+
+		qCDebug(logHyprlandIpc) << "Monitor removed with id" << monitor->bindableId().value() << "name"
+		                        << monitor->bindableName().value();
+		this->mMonitors.removeAt(index);
+
+		// delete the monitor object in the next event loop cycle so it's likely to
+		// still exist when future events reference it after destruction.
+		// If we get to the next cycle and things still reference it (unlikely), nulls
+		// can make it to the frontend.
+		monitor->deleteLater();
+	} else if (event->name == "createworkspacev2") {
+		auto args = event->parseView(2);
+
+		auto id = args.at(0).toInt();
+		auto name = QString::fromUtf8(args.at(1));
+
+		qCDebug(logHyprlandIpc) << "Workspace created with id" << id << "name" << name;
+
+		auto* workspace = this->findWorkspaceByName(name, false);
+		auto existed = workspace != nullptr;
+
+		if (workspace == nullptr) {
+			workspace = new HyprlandWorkspace(this);
+		}
+
+		workspace->updateInitial(id, name);
+
+		if (!existed) {
+			this->refreshWorkspaces(false);
+			this->mWorkspaces.insertObjectSorted(workspace, &HyprlandIpc::compareWorkspaces);
+		}
+	} else if (event->name == "destroyworkspacev2") {
+		auto args = event->parseView(2);
+
+		auto id = args.at(0).toInt();
+		auto name = QString::fromUtf8(args.at(1));
+
+		const auto& mList = this->mWorkspaces.valueList();
+
+		auto workspaceIter = std::ranges::find_if(mList, [id](HyprlandWorkspace* m) {
+			return m->bindableId().value() == id;
+		});
+
+		if (workspaceIter == mList.end()) {
+			qCWarning(logHyprlandIpc) << "Got removal for workspace id" << id << "name" << name
+			                          << "which was not previously tracked.";
+			return;
+		}
+
+		auto index = workspaceIter - mList.begin();
+		auto* workspace = *workspaceIter;
+
+		qCDebug(logHyprlandIpc) << "Workspace removed with id" << id << "name" << name;
+		this->mWorkspaces.removeAt(index);
+
+		// workspaces have not been observed to be referenced after deletion
+		delete workspace;
+
+		for (auto* monitor: this->mMonitors.valueList()) {
+			if (monitor->bindableActiveWorkspace().value() == nullptr) {
+				// removing a monitor will cause a new workspace to be created and destroyed after removal,
+				// but it won't go back to a real workspace afterwards and just leaves a null, so we
+				// re-query monitors if this appears to be the case.
+				this->refreshMonitors(false);
+				break;
+			}
+		}
+	} else if (event->name == "focusedmon") {
+		auto args = event->parseView(2);
+		auto name = QString::fromUtf8(args.at(0));
+		auto workspaceName = QString::fromUtf8(args.at(1));
+
+		HyprlandWorkspace* workspace = nullptr;
+		if (workspaceName != "?") { // what the fuck
+			workspace = this->findWorkspaceByName(workspaceName, false);
+		}
+
+		auto* monitor = this->findMonitorByName(name, true);
+		this->setFocusedMonitor(monitor);
+		monitor->setActiveWorkspace(workspace);
+		qCDebug(logHyprlandIpc) << "Monitor" << name << "focused with workspace"
+		                        << (workspace ? workspace->bindableId().value() : -1);
+	} else if (event->name == "workspacev2") {
+		auto args = event->parseView(2);
+		auto id = args.at(0).toInt();
+		auto name = QString::fromUtf8(args.at(1));
+
+		if (this->bFocusedMonitor != nullptr) {
+			auto* workspace = this->findWorkspaceByName(name, true, id);
+			this->bFocusedMonitor->setActiveWorkspace(workspace);
+			qCDebug(logHyprlandIpc) << "Workspace" << id << "activated on"
+			                        << this->bFocusedMonitor->bindableName().value();
+		}
+	} else if (event->name == "moveworkspacev2") {
+		auto args = event->parseView(3);
+		auto id = args.at(0).toInt();
+		auto name = QString::fromUtf8(args.at(1));
+		auto monitorName = QString::fromUtf8(args.at(2));
+
+		auto* workspace = this->findWorkspaceByName(name, true, id);
+		auto* monitor = this->findMonitorByName(monitorName, true);
+
+		qCDebug(logHyprlandIpc) << "Workspace" << id << "moved to monitor" << monitorName;
+		workspace->setMonitor(monitor);
+	} else if (event->name == "renameworkspace") {
+		auto args = event->parseView(2);
+		auto id = args.at(0).toInt();
+		auto name = QString::fromUtf8(args.at(1));
+
+		const auto& mList = this->mWorkspaces.valueList();
+
+		auto workspaceIter = std::ranges::find_if(mList, [id](HyprlandWorkspace* m) {
+			return m->bindableId().value() == id;
+		});
+
+		if (workspaceIter == mList.end()) return;
+
+		qCDebug(logHyprlandIpc) << "Workspace with id" << id << "renamed from"
+		                        << (*workspaceIter)->bindableName().value() << "to" << name;
+
+		(*workspaceIter)->bindableName().setValue(name);
+	} else if (event->name == "fullscreen") {
+		if (auto* workspace = this->bFocusedWorkspace.value()) {
+			workspace->bindableHasFullscreen().setValue(event->data == "1");
+		}
+
+		// In theory knowing the current workspace would be enough to determine where
+		// the fullscreen state changed, but this falls apart if you move a fullscreen
+		// window between workspaces.
+		this->refreshWorkspaces(false);
+	} else if (event->name == "openwindow") {
+		auto args = event->parseView(4);
+		auto ok = false;
+		auto windowAddress = args.at(0).toULongLong(&ok, 16);
+
+		if (!ok) return;
+
+		auto workspaceName = QString::fromUtf8(args.at(1));
+		auto windowTitle = QString::fromUtf8(args.at(2));
+		auto windowClass = QString::fromUtf8(args.at(3));
+
+		auto* workspace = this->findWorkspaceByName(workspaceName, false);
+		if (!workspace) {
+			qCWarning(logHyprlandIpc) << "Got openwindow for workspace" << workspaceName
+			                          << "which was not previously tracked.";
+			return;
+		}
+
+		auto* toplevel = this->findToplevelByAddress(windowAddress, false);
+		const bool existed = toplevel != nullptr;
+
+		if (!toplevel) toplevel = new HyprlandToplevel(this);
+		toplevel->updateInitial(windowAddress, windowTitle, workspaceName);
+
+		workspace->insertToplevel(toplevel);
+
+		if (!existed) {
+			this->mToplevels.insertObject(toplevel);
+			qCDebug(logHyprlandIpc) << "New toplevel created with address" << windowAddress << ", title"
+			                        << windowTitle << ", workspace" << workspaceName;
+		}
+	} else if (event->name == "closewindow") {
+		auto args = event->parseView(1);
+		auto ok = false;
+		auto windowAddress = args.at(0).toULongLong(&ok, 16);
+
+		if (!ok) return;
+
+		const auto& mList = this->mToplevels.valueList();
+		auto toplevelIter = std::ranges::find_if(mList, [windowAddress](HyprlandToplevel* m) {
+			return m->address() == windowAddress;
+		});
+
+		if (toplevelIter == mList.end()) {
+			qCWarning(logHyprlandIpc) << "Got closewindow for address" << windowAddress
+			                          << "which was not previously tracked.";
+			return;
+		}
+
+		auto* toplevel = *toplevelIter;
+		auto index = toplevelIter - mList.begin();
+		this->mToplevels.removeAt(index);
+
+		// Remove from workspace
+		auto* workspace = toplevel->bindableWorkspace().value();
+		if (workspace) {
+			workspace->toplevels()->removeObject(toplevel);
+		}
+
+		delete toplevel;
+	} else if (event->name == "movewindowv2") {
+		auto args = event->parseView(3);
+		auto ok = false;
+		auto windowAddress = args.at(0).toULongLong(&ok, 16);
+		auto workspaceName = QString::fromUtf8(args.at(2));
+
+		auto* toplevel = this->findToplevelByAddress(windowAddress, false);
+		if (!toplevel) {
+			qCWarning(logHyprlandIpc) << "Got movewindowv2 event for client with address" << windowAddress
+			                          << "which was not previously tracked.";
+			return;
+		}
+
+		HyprlandWorkspace* workspace = this->findWorkspaceByName(workspaceName, false);
+		if (!workspace) {
+			qCWarning(logHyprlandIpc) << "Got movewindowv2 event for workspace" << args.at(2)
+			                          << "which was not previously tracked.";
+			return;
+		}
+
+		auto* oldWorkspace = toplevel->bindableWorkspace().value();
+		toplevel->setWorkspace(workspace);
+
+		if (oldWorkspace) {
+			oldWorkspace->removeToplevel(toplevel);
+		}
+
+		workspace->insertToplevel(toplevel);
+	} else if (event->name == "windowtitlev2") {
+		auto args = event->parseView(2);
+		auto ok = false;
+		auto windowAddress = args.at(0).toULongLong(&ok, 16);
+		auto windowTitle = QString::fromUtf8(args.at(1));
+
+		if (!ok) return;
+
+		// It happens that Hyprland sends windowtitlev2 events before event
+		// "openwindow" is emitted, so let's preemptively create it
+		auto* toplevel = this->findToplevelByAddress(windowAddress, true);
+		if (!toplevel) {
+			qCWarning(logHyprlandIpc) << "Got windowtitlev2 event for client with address"
+			                          << windowAddress << "which was not previously tracked.";
+			return;
+		}
+
+		toplevel->bindableTitle().setValue(windowTitle);
+	} else if (event->name == "activewindowv2") {
+		auto args = event->parseView(1);
+		auto ok = false;
+		auto windowAddress = args.at(0).toULongLong(&ok, 16);
+
+		if (!ok) return;
+
+		// Did not observe "activewindowv2" event before "openwindow",
+		// but better safe than sorry, so create if missing.
+		auto* toplevel = this->findToplevelByAddress(windowAddress, true);
+		this->bActiveToplevel = toplevel;
+	} else if (event->name == "urgent") {
+		auto args = event->parseView(1);
+		auto ok = false;
+		auto windowAddress = args.at(0).toULongLong(&ok, 16);
+
+		if (!ok) return;
+
+		// It happens that Hyprland sends urgent before "openwindow"
+		auto* toplevel = this->findToplevelByAddress(windowAddress, true);
+		toplevel->bindableUrgent().setValue(true);
+	}
+}
+
+HyprlandWorkspace*
+HyprlandIpc::findWorkspaceByName(const QString& name, bool createIfMissing, qint32 id) {
+	const auto& mList = this->mWorkspaces.valueList();
+	HyprlandWorkspace* workspace = nullptr;
+
+	if (id != -1) {
+		auto workspaceIter = std::ranges::find_if(mList, [&](HyprlandWorkspace* m) {
+			return m->bindableId().value() == id;
+		});
+
+		workspace = workspaceIter == mList.end() ? nullptr : *workspaceIter;
+	}
+
+	if (!workspace) {
+		auto workspaceIter = std::ranges::find_if(mList, [&](HyprlandWorkspace* m) {
+			return m->bindableName().value() == name;
+		});
+
+		workspace = workspaceIter == mList.end() ? nullptr : *workspaceIter;
+	}
+
+	if (workspace) {
+		return workspace;
+	} else if (createIfMissing) {
+		qCDebug(logHyprlandIpc) << "Workspace" << name
+		                        << "requested before creation, performing early init with id" << id;
+
+		auto* workspace = new HyprlandWorkspace(this);
+		workspace->updateInitial(id, name);
+		this->mWorkspaces.insertObjectSorted(workspace, &HyprlandIpc::compareWorkspaces);
+		return workspace;
+	} else {
+		return nullptr;
+	}
+}
+
+void HyprlandIpc::refreshWorkspaces(bool canCreate) {
+	if (this->requestingWorkspaces) return;
+	this->requestingWorkspaces = true;
+
+	this->makeRequest("j/workspaces", [this, canCreate](bool success, const QByteArray& resp) {
+		this->requestingWorkspaces = false;
+		if (!success) return;
+
+		qCDebug(logHyprlandIpc) << "Parsing workspaces response";
+		auto json = QJsonDocument::fromJson(resp).array();
+
+		const auto& mList = this->mWorkspaces.valueList();
+		auto ids = QVector<quint32>();
+
+		for (auto entry: json) {
+			auto object = entry.toObject().toVariantMap();
+
+			auto id = object.value("id").toInt();
+
+			auto workspaceIter = std::ranges::find_if(mList, [&](HyprlandWorkspace* m) {
+				return m->bindableId().value() == id;
+			});
+
+			// Only fall back to name-based filtering as a last resort, for workspaces where
+			// no ID has been determined yet.
+			if (workspaceIter == mList.end()) {
+				auto name = object.value("name").toString();
+
+				workspaceIter = std::ranges::find_if(mList, [&](HyprlandWorkspace* m) {
+					return m->bindableId().value() == -1 && m->bindableName().value() == name;
+				});
+			}
+
+			auto* workspace = workspaceIter == mList.end() ? nullptr : *workspaceIter;
+			auto existed = workspace != nullptr;
+
+			if (!existed) {
+				if (!canCreate) continue;
+				workspace = new HyprlandWorkspace(this);
+			}
+
+			workspace->updateFromObject(object);
+
+			if (!existed) {
+				this->mWorkspaces.insertObjectSorted(workspace, &HyprlandIpc::compareWorkspaces);
+			}
+
+			ids.push_back(id);
+		}
+
+		if (canCreate) {
+			auto removedWorkspaces = QVector<HyprlandWorkspace*>();
+
+			for (auto* workspace: mList) {
+				if (!ids.contains(workspace->bindableId().value())) {
+					removedWorkspaces.push_back(workspace);
+				}
+			}
+
+			for (auto* workspace: removedWorkspaces) {
+				this->mWorkspaces.removeObject(workspace);
+				delete workspace;
+			}
+		}
+	});
+}
+
+HyprlandToplevel* HyprlandIpc::findToplevelByAddress(quint64 address, bool createIfMissing) {
+	const auto& mList = this->mToplevels.valueList();
+	HyprlandToplevel* toplevel = nullptr;
+
+	auto toplevelIter =
+	    std::ranges::find_if(mList, [&](HyprlandToplevel* m) { return m->address() == address; });
+
+	toplevel = toplevelIter == mList.end() ? nullptr : *toplevelIter;
+
+	if (!toplevel && createIfMissing) {
+		qCDebug(logHyprlandIpc) << "Toplevel with address" << address
+		                        << "requested before creation, performing early init";
+
+		toplevel = new HyprlandToplevel(this);
+		toplevel->updateInitial(address, "", "");
+		this->mToplevels.insertObject(toplevel);
+	}
+
+	return toplevel;
+}
+
+void HyprlandIpc::refreshToplevels() {
+	if (this->requestingToplevels) return;
+	this->requestingToplevels = true;
+
+	this->makeRequest("j/clients", [this](bool success, const QByteArray& resp) {
+		this->requestingToplevels = false;
+		if (!success) return;
+
+		qCDebug(logHyprlandIpc) << "Parsing j/clients response";
+		auto json = QJsonDocument::fromJson(resp).array();
+
+		const auto& mList = this->mToplevels.valueList();
+
+		for (auto entry: json) {
+			auto object = entry.toObject().toVariantMap();
+
+			bool ok = false;
+			auto address = object.value("address").toString().toULongLong(&ok, 16);
+
+			if (!ok) {
+				qCWarning(logHyprlandIpc) << "Invalid address in j/clients entry:" << object;
+				continue;
+			}
+
+			auto toplevelsIter =
+			    std::ranges::find_if(mList, [&](HyprlandToplevel* m) { return m->address() == address; });
+
+			auto* toplevel = toplevelsIter == mList.end() ? nullptr : *toplevelsIter;
+			auto exists = toplevel != nullptr;
+
+			if (!exists) toplevel = new HyprlandToplevel(this);
+			toplevel->updateFromObject(object);
+
+			if (!exists) {
+				qCDebug(logHyprlandIpc) << "New toplevel created with address" << address;
+				this->mToplevels.insertObject(toplevel);
+			}
+
+			auto* workspace = toplevel->bindableWorkspace().value();
+			workspace->insertToplevel(toplevel);
+		}
+	});
+}
+
+HyprlandMonitor*
+HyprlandIpc::findMonitorByName(const QString& name, bool createIfMissing, qint32 id) {
+	const auto& mList = this->mMonitors.valueList();
+
+	auto monitorIter = std::ranges::find_if(mList, [name](HyprlandMonitor* m) {
+		return m->bindableName().value() == name;
+	});
+
+	if (monitorIter != mList.end()) {
+		return *monitorIter;
+	} else if (createIfMissing) {
+		qCDebug(logHyprlandIpc) << "Monitor" << name
+		                        << "requested before creation, performing early init";
+		auto* monitor = new HyprlandMonitor(this);
+		monitor->updateInitial(id, name, "");
+		this->mMonitors.insertObject(monitor);
+		return monitor;
+	} else {
+		return nullptr;
+	}
+}
+
+HyprlandMonitor* HyprlandIpc::monitorFor(QuickshellScreenInfo* screen) {
+	// Wayland monitors appear after hyprland ones are created and disappear after destruction
+	// so simply not doing any preemptive creation is enough, however if this call creates
+	// the HyprlandIpc singleton then monitors won't be initialized, in which case we
+	// preemptively create one.
+
+	if (screen == nullptr) return nullptr;
+	return this->findMonitorByName(screen->name(), !this->monitorsRequested);
+}
+
+void HyprlandIpc::setFocusedMonitor(HyprlandMonitor* monitor) {
+	auto* oldMonitor = this->bFocusedMonitor.value();
+	if (monitor == oldMonitor) return;
+
+	if (this->bFocusedMonitor != nullptr) {
+		QObject::disconnect(this->bFocusedMonitor, nullptr, this, nullptr);
+	}
+
+	if (monitor != nullptr) {
+		QObject::connect(monitor, &QObject::destroyed, this, &HyprlandIpc::onFocusedMonitorDestroyed);
+	}
+
+	this->bFocusedMonitor = monitor;
+}
+
+void HyprlandIpc::onFocusedMonitorDestroyed() {
+	this->bFocusedMonitor = nullptr;
+	emit this->focusedMonitorChanged();
+}
+
+void HyprlandIpc::refreshMonitors(bool canCreate) {
+	if (this->requestingMonitors) return;
+	this->requestingMonitors = true;
+
+	this->makeRequest("j/monitors", [this, canCreate](bool success, const QByteArray& resp) {
+		this->requestingMonitors = false;
+		if (!success) return;
+
+		this->monitorsRequested = true;
+
+		qCDebug(logHyprlandIpc) << "parsing monitors response";
+		auto json = QJsonDocument::fromJson(resp).array();
+
+		const auto& mList = this->mMonitors.valueList();
+		auto names = QVector<QString>();
+
+		for (auto entry: json) {
+			auto object = entry.toObject().toVariantMap();
+			auto name = object.value("name").toString();
+
+			auto monitorIter = std::ranges::find_if(mList, [name](HyprlandMonitor* m) {
+				return m->bindableName().value() == name;
+			});
+
+			auto* monitor = monitorIter == mList.end() ? nullptr : *monitorIter;
+			auto existed = monitor != nullptr;
+
+			if (monitor == nullptr) {
+				if (!canCreate) continue;
+				monitor = new HyprlandMonitor(this);
+			}
+
+			monitor->updateFromObject(object);
+
+			if (!existed) {
+				this->mMonitors.insertObject(monitor);
+			}
+
+			names.push_back(name);
+		}
+
+		auto removedMonitors = QVector<HyprlandMonitor*>();
+
+		for (auto* monitor: mList) {
+			if (!names.contains(monitor->bindableName().value())) {
+				removedMonitors.push_back(monitor);
+			}
+		}
+
+		for (auto* monitor: removedMonitors) {
+			this->mMonitors.removeObject(monitor);
+			// see comment in onEvent
+			monitor->deleteLater();
+		}
+	});
+}
+
+bool HyprlandIpc::compareWorkspaces(HyprlandWorkspace* a, HyprlandWorkspace* b) {
+	return a->bindableId().value() > b->bindableId().value();
+}
+
+} // namespace qs::hyprland::ipc
diff --git a/src/wayland/hyprland/ipc/connection.hpp b/src/wayland/hyprland/ipc/connection.hpp
new file mode 100644
index 00000000..e15d5cd7
--- /dev/null
+++ b/src/wayland/hyprland/ipc/connection.hpp
@@ -0,0 +1,178 @@
+#pragma once
+
+#include <functional>
+
+#include <qbytearrayview.h>
+#include <qcontainerfwd.h>
+#include <qhash.h>
+#include <qlocalsocket.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../../core/model.hpp"
+#include "../../../core/qmlscreen.hpp"
+#include "../../../wayland/toplevel_management/handle.hpp"
+
+namespace qs::hyprland::ipc {
+
+class HyprlandMonitor;
+class HyprlandWorkspace;
+class HyprlandToplevel;
+
+} // namespace qs::hyprland::ipc
+
+Q_DECLARE_OPAQUE_POINTER(qs::hyprland::ipc::HyprlandWorkspace*);
+Q_DECLARE_OPAQUE_POINTER(qs::hyprland::ipc::HyprlandMonitor*);
+Q_DECLARE_OPAQUE_POINTER(qs::hyprland::ipc::HyprlandToplevel*);
+
+namespace qs::hyprland::ipc {
+
+///! Live Hyprland IPC event.
+/// Live Hyprland IPC event. Holding this object after the
+/// signal handler exits is undefined as the event instance
+/// is reused.
+///
+/// Emitted by @@Hyprland.rawEvent(s).
+class HyprlandIpcEvent: public QObject {
+	Q_OBJECT;
+	/// The name of the event.
+	///
+	/// See [Hyprland Wiki: IPC](https://wiki.hyprland.org/IPC/) for a list of events.
+	Q_PROPERTY(QString name READ nameStr CONSTANT);
+	/// The unparsed data of the event.
+	Q_PROPERTY(QString data READ dataStr CONSTANT);
+	QML_NAMED_ELEMENT(HyprlandEvent);
+	QML_UNCREATABLE("HyprlandIpcEvents cannot be created.");
+
+public:
+	HyprlandIpcEvent(QObject* parent): QObject(parent) {}
+
+	/// Parse this event with a known number of arguments.
+	///
+	/// Argument count is required as some events can contain commas
+	/// in the last argument, which can be ignored as long as the count is known.
+	Q_INVOKABLE [[nodiscard]] QVector<QString> parse(qint32 argumentCount) const;
+	[[nodiscard]] QVector<QByteArrayView> parseView(qint32 argumentCount) const;
+
+	[[nodiscard]] QString nameStr() const;
+	[[nodiscard]] QString dataStr() const;
+
+	void reset();
+	QByteArrayView name;
+	QByteArrayView data;
+};
+
+class HyprlandIpc: public QObject {
+	Q_OBJECT;
+
+public:
+	static HyprlandIpc* instance();
+
+	[[nodiscard]] QString requestSocketPath() const;
+	[[nodiscard]] QString eventSocketPath() const;
+
+	void
+	makeRequest(const QByteArray& request, const std::function<void(bool, QByteArray)>& callback);
+	void dispatch(const QString& request);
+
+	[[nodiscard]] HyprlandMonitor* monitorFor(QuickshellScreenInfo* screen);
+
+	[[nodiscard]] QBindable<HyprlandMonitor*> bindableFocusedMonitor() const {
+		return &this->bFocusedMonitor;
+	}
+
+	[[nodiscard]] QBindable<HyprlandWorkspace*> bindableFocusedWorkspace() const {
+		return &this->bFocusedWorkspace;
+	}
+
+	[[nodiscard]] QBindable<HyprlandToplevel*> bindableActiveToplevel() const {
+		return &this->bActiveToplevel;
+	}
+
+	void setFocusedMonitor(HyprlandMonitor* monitor);
+
+	[[nodiscard]] ObjectModel<HyprlandMonitor>* monitors();
+	[[nodiscard]] ObjectModel<HyprlandWorkspace>* workspaces();
+	[[nodiscard]] ObjectModel<HyprlandToplevel>* toplevels();
+
+	// No byId because these preemptively create objects. The given id is set if created.
+	HyprlandWorkspace* findWorkspaceByName(const QString& name, bool createIfMissing, qint32 id = -1);
+	HyprlandMonitor* findMonitorByName(const QString& name, bool createIfMissing, qint32 id = -1);
+	HyprlandToplevel* findToplevelByAddress(quint64 address, bool createIfMissing);
+
+	// canCreate avoids making ghost workspaces when the connection races
+	void refreshWorkspaces(bool canCreate);
+	void refreshMonitors(bool canCreate);
+	void refreshToplevels();
+
+	// The last argument may contain commas, so the count is required.
+	[[nodiscard]] static QVector<QByteArrayView> parseEventArgs(QByteArrayView event, quint16 count);
+
+signals:
+	void connected();
+	void rawEvent(HyprlandIpcEvent* event);
+
+	void focusedMonitorChanged();
+	void focusedWorkspaceChanged();
+	void activeToplevelChanged();
+
+private slots:
+	void eventSocketError(QLocalSocket::LocalSocketError error) const;
+	void eventSocketStateChanged(QLocalSocket::LocalSocketState state);
+	void eventSocketReady();
+
+	void toplevelAddressed(
+	    qs::wayland::toplevel_management::impl::ToplevelHandle* handle,
+	    quint64 address
+	);
+
+	void onFocusedMonitorDestroyed();
+
+private:
+	explicit HyprlandIpc();
+
+	void onEvent(HyprlandIpcEvent* event);
+
+	static bool compareWorkspaces(HyprlandWorkspace* a, HyprlandWorkspace* b);
+
+	QLocalSocket eventSocket;
+	QString mRequestSocketPath;
+	QString mEventSocketPath;
+	bool valid = false;
+	bool requestingMonitors = false;
+	bool requestingWorkspaces = false;
+	bool requestingToplevels = false;
+	bool monitorsRequested = false;
+
+	ObjectModel<HyprlandMonitor> mMonitors {this};
+	ObjectModel<HyprlandWorkspace> mWorkspaces {this};
+	ObjectModel<HyprlandToplevel> mToplevels {this};
+
+	HyprlandIpcEvent event {this};
+
+	Q_OBJECT_BINDABLE_PROPERTY(
+	    HyprlandIpc,
+	    HyprlandMonitor*,
+	    bFocusedMonitor,
+	    &HyprlandIpc::focusedMonitorChanged
+	);
+
+	Q_OBJECT_BINDABLE_PROPERTY(
+	    HyprlandIpc,
+	    HyprlandWorkspace*,
+	    bFocusedWorkspace,
+	    &HyprlandIpc::focusedWorkspaceChanged
+	);
+
+	Q_OBJECT_BINDABLE_PROPERTY(
+	    HyprlandIpc,
+	    HyprlandToplevel*,
+	    bActiveToplevel,
+	    &HyprlandIpc::activeToplevelChanged
+	);
+};
+
+} // namespace qs::hyprland::ipc
diff --git a/src/wayland/hyprland/ipc/hyprland-toplevel-mapping-v1.xml b/src/wayland/hyprland/ipc/hyprland-toplevel-mapping-v1.xml
new file mode 100644
index 00000000..ec7b1cea
--- /dev/null
+++ b/src/wayland/hyprland/ipc/hyprland-toplevel-mapping-v1.xml
@@ -0,0 +1,113 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="hyprland_toplevel_mapping_v1">
+  <copyright>
+    Copyright © 2025 WhySoBad
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+    3. Neither the name of the copyright holder nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  </copyright>
+
+  <description summary="mapping of toplevels to windows">
+    This protocol allows clients to retrieve the mapping of toplevels to hyprland window addresses.
+  </description>
+
+  <interface name="hyprland_toplevel_mapping_manager_v1" version="1">
+    <description summary="manager to request toplevel mappings">
+      This object is a manager which offers requests to retrieve a window address
+      for a toplevel.
+    </description>
+
+    <request name="get_window_for_toplevel">
+      <description summary="">
+				This request has been edited to remove a compile dep.
+      </description>
+    </request>
+
+    <request name="get_window_for_toplevel_wlr">
+      <description summary="get window address for wlr toplevel">
+        Get the window address for a wlr toplevel.
+      </description>
+      <arg
+        name="handle"
+        type="new_id"
+        interface="hyprland_toplevel_window_mapping_handle_v1"
+      />
+      <arg
+        name="toplevel"
+        type="object"
+        interface="zwlr_foreign_toplevel_handle_v1"
+        summary="wlr toplevel to get the window address for"
+      />
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the manager">
+        All objects created by the manager will still remain valid, until their appropriate destroy
+        request has been called.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="hyprland_toplevel_window_mapping_handle_v1" version="1">
+    <description summary="toplevel to window mapping">
+      This object represents a mapping of a (wlr) toplevel to a window address.
+
+      Once created, the `window_address` event will be sent containing the address of the window
+      associated with the toplevel.
+      Should the mapping fail, the `failed` event will be sent.
+    </description>
+
+    <event name="window_address">
+      <description summary="address of the window">
+        The full 64bit window address. The `address` field contains the lower 32 bits whilst the
+        `address_hi` contains the upper 32 bits
+      </description>
+      <arg
+        name="address_hi"
+        type="uint"
+        summary="upper 32 bits of the window address"
+      />
+      <arg
+        name="address"
+        type="uint"
+        summary="lower 32 bits of the window address"
+      />
+    </event>
+
+    <event name="failed">
+      <description summary="mapping failed">
+        The mapping of the toplevel to a window address failed. Most likely the window does not
+        exist (anymore).
+      </description>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy handle">
+        Destroy the handle. This request can be sent at any time by the client.
+      </description>
+    </request>
+  </interface>
+</protocol>
diff --git a/src/wayland/hyprland/ipc/hyprland_toplevel.cpp b/src/wayland/hyprland/ipc/hyprland_toplevel.cpp
new file mode 100644
index 00000000..7b07bc84
--- /dev/null
+++ b/src/wayland/hyprland/ipc/hyprland_toplevel.cpp
@@ -0,0 +1,165 @@
+#include "hyprland_toplevel.hpp"
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../toplevel_management/qml.hpp"
+#include "connection.hpp"
+#include "toplevel_mapping.hpp"
+#include "workspace.hpp"
+
+using namespace qs::wayland::toplevel_management;
+
+namespace qs::hyprland::ipc {
+
+HyprlandToplevel::HyprlandToplevel(HyprlandIpc* ipc): QObject(ipc), ipc(ipc) {
+	this->bMonitor.setBinding([this]() {
+		return this->bWorkspace ? this->bWorkspace->bindableMonitor().value() : nullptr;
+	});
+
+	this->bActivated.setBinding([this]() {
+		return this->ipc->bindableActiveToplevel().value() == this;
+	});
+
+	QObject::connect(
+	    this,
+	    &HyprlandToplevel::activatedChanged,
+	    this,
+	    &HyprlandToplevel::onActivatedChanged
+	);
+}
+
+HyprlandToplevel::HyprlandToplevel(HyprlandIpc* ipc, Toplevel* toplevel): HyprlandToplevel(ipc) {
+	this->mWaylandHandle = toplevel->implHandle();
+	auto* instance = HyprlandToplevelMappingManager::instance();
+	auto addr = instance->getToplevelAddress(this->mWaylandHandle);
+
+	if (!addr) {
+		// Address not available, will rely on HyprlandIpc to resolve it.
+		return;
+	}
+
+	this->setAddress(addr);
+
+	// Check if client is present in HyprlandIPC
+	auto* hyprToplevel = ipc->findToplevelByAddress(addr, false);
+	// HyprlandIpc will eventually resolve it
+	if (!hyprToplevel) return;
+
+	this->setHyprlandHandle(hyprToplevel);
+}
+
+void HyprlandToplevel::updateInitial(
+    quint64 address,
+    const QString& title,
+    const QString& workspaceName
+) {
+	auto* workspace = this->ipc->findWorkspaceByName(workspaceName, false);
+	Qt::beginPropertyUpdateGroup();
+	this->setAddress(address);
+	this->bTitle = title;
+	this->setWorkspace(workspace);
+	Qt::endPropertyUpdateGroup();
+}
+
+void HyprlandToplevel::updateFromObject(const QVariantMap& object) {
+	auto addressStr = object.value("address").value<QString>();
+	auto title = object.value("title").value<QString>();
+
+	Qt::beginPropertyUpdateGroup();
+	bool ok = false;
+	auto address = addressStr.toULongLong(&ok, 16);
+	if (!ok || !address) {
+		return;
+	}
+
+	this->setAddress(address);
+	this->bTitle = title;
+
+	auto workspaceMap = object.value("workspace").toMap();
+	auto workspaceName = workspaceMap.value("name").toString();
+
+	auto* workspace = this->ipc->findWorkspaceByName(workspaceName, false);
+	if (!workspace) return;
+
+	this->setWorkspace(workspace);
+	this->bLastIpcObject = object;
+	Qt::endPropertyUpdateGroup();
+}
+
+void HyprlandToplevel::setWorkspace(HyprlandWorkspace* workspace) {
+	auto* oldWorkspace = this->bWorkspace.value();
+	if (oldWorkspace == workspace) return;
+
+	if (oldWorkspace) {
+		QObject::disconnect(oldWorkspace, nullptr, this, nullptr);
+	}
+
+	this->bWorkspace = workspace;
+
+	if (workspace) {
+		QObject::connect(workspace, &QObject::destroyed, this, [this]() {
+			this->bWorkspace = nullptr;
+		});
+	}
+}
+
+void HyprlandToplevel::setAddress(quint64 address) {
+	this->mAddress = address;
+	emit this->addressChanged();
+}
+
+Toplevel* HyprlandToplevel::waylandHandle() {
+	return ToplevelManager::instance()->forImpl(this->mWaylandHandle);
+}
+
+void HyprlandToplevel::setWaylandHandle(impl::ToplevelHandle* handle) {
+	if (this->mWaylandHandle == handle) return;
+	if (this->mWaylandHandle) {
+		QObject::disconnect(this->mWaylandHandle, nullptr, this, nullptr);
+	}
+
+	this->mWaylandHandle = handle;
+	if (handle) {
+		QObject::connect(handle, &QObject::destroyed, this, [this]() {
+			this->mWaylandHandle = nullptr;
+		});
+	}
+
+	emit this->waylandHandleChanged();
+}
+
+void HyprlandToplevel::setHyprlandHandle(HyprlandToplevel* handle) {
+	if (this->mHyprlandHandle == handle) return;
+	if (this->mHyprlandHandle) {
+		QObject::disconnect(this->mHyprlandHandle, nullptr, this, nullptr);
+	}
+	this->mHyprlandHandle = handle;
+	if (handle) {
+		QObject::connect(handle, &QObject::destroyed, this, [this]() {
+			this->mHyprlandHandle = nullptr;
+		});
+	}
+
+	emit this->hyprlandHandleChanged();
+}
+
+void HyprlandToplevel::onActivatedChanged() {
+	if (this->bUrgent.value()) {
+		// If was urgent, and now active, clear urgent state
+		this->bUrgent = false;
+	}
+}
+
+HyprlandToplevel* HyprlandToplevel::qmlAttachedProperties(QObject* object) {
+	if (auto* toplevel = qobject_cast<Toplevel*>(object)) {
+		auto* ipc = HyprlandIpc::instance();
+		return new HyprlandToplevel(ipc, toplevel);
+	} else {
+		return nullptr;
+	}
+}
+} // namespace qs::hyprland::ipc
diff --git a/src/wayland/hyprland/ipc/hyprland_toplevel.hpp b/src/wayland/hyprland/ipc/hyprland_toplevel.hpp
new file mode 100644
index 00000000..ebd4f844
--- /dev/null
+++ b/src/wayland/hyprland/ipc/hyprland_toplevel.hpp
@@ -0,0 +1,121 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../toplevel_management/handle.hpp"
+#include "../../toplevel_management/qml.hpp"
+#include "connection.hpp"
+
+namespace qs::hyprland::ipc {
+
+//! Hyprland Toplevel
+/// Represents a window as Hyprland exposes it.
+/// Can also be used as an attached object of a @@Quickshell.Wayland.Toplevel,
+/// to resolve a handle to an Hyprland toplevel.
+class HyprlandToplevel: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_UNCREATABLE("");
+	QML_ATTACHED(HyprlandToplevel);
+	// clang-format off
+	/// Hexadecimal Hyprland window address. Will be an empty string until
+	/// the address is reported.
+	Q_PROPERTY(QString address READ addressStr NOTIFY addressChanged);
+	/// The toplevel handle, exposing the Hyprland toplevel.
+	/// Will be null until the address is reported
+	Q_PROPERTY(HyprlandToplevel* handle READ hyprlandHandle NOTIFY hyprlandHandleChanged);
+	/// The wayland toplevel handle. Will be null intil the address is reported
+	Q_PROPERTY(qs::wayland::toplevel_management::Toplevel* wayland READ waylandHandle NOTIFY waylandHandleChanged);
+	/// The title of the toplevel
+	Q_PROPERTY(QString title READ default NOTIFY titleChanged BINDABLE bindableTitle);
+	/// Whether the toplevel is active or not
+	Q_PROPERTY(bool activated READ default NOTIFY activatedChanged BINDABLE bindableActivated);
+	/// Whether the client is urgent or not
+	Q_PROPERTY(bool urgent READ default NOTIFY urgentChanged BINDABLE bindableUrgent);
+	/// Last json returned for this toplevel, as a javascript object.
+	///
+	/// > [!WARNING] This is *not* updated unless the toplevel object is fetched again from
+	/// > Hyprland. If you need a value that is subject to change and does not have a dedicated
+	/// > property, run @@Hyprland.refreshToplevels() and wait for this property to update.
+	Q_PROPERTY(QVariantMap lastIpcObject READ default BINDABLE bindableLastIpcObject NOTIFY lastIpcObjectChanged);
+	/// The current workspace of the toplevel (might be null)
+	Q_PROPERTY(qs::hyprland::ipc::HyprlandWorkspace* workspace READ default NOTIFY workspaceChanged BINDABLE bindableWorkspace);
+	/// The current monitor of the toplevel (might be null)
+	Q_PROPERTY(qs::hyprland::ipc::HyprlandMonitor* monitor READ default NOTIFY monitorChanged BINDABLE bindableMonitor);
+	// clang-format on
+
+public:
+	/// When invoked from HyprlandIpc, reacting to Hyprland's IPC events.
+	explicit HyprlandToplevel(HyprlandIpc* ipc);
+	/// When attached from a Toplevel
+	explicit HyprlandToplevel(HyprlandIpc* ipc, qs::wayland::toplevel_management::Toplevel* toplevel);
+
+	static HyprlandToplevel* qmlAttachedProperties(QObject* object);
+
+	void updateInitial(quint64 address, const QString& title, const QString& workspaceName);
+
+	void updateFromObject(const QVariantMap& object);
+
+	[[nodiscard]] QString addressStr() const { return QString::number(this->mAddress, 16); }
+	[[nodiscard]] quint64 address() const { return this->mAddress; }
+	void setAddress(quint64 address);
+
+	// clang-format off
+	[[nodiscard]] HyprlandToplevel* hyprlandHandle() { return this->mHyprlandHandle; }
+	void setHyprlandHandle(HyprlandToplevel* handle);
+
+	[[nodiscard]] wayland::toplevel_management::Toplevel* waylandHandle();
+	void setWaylandHandle(wayland::toplevel_management::impl::ToplevelHandle* handle);
+	// clang-format on
+
+	[[nodiscard]] QBindable<QString> bindableTitle() { return &this->bTitle; }
+	[[nodiscard]] QBindable<bool> bindableActivated() { return &this->bActivated; }
+	[[nodiscard]] QBindable<bool> bindableUrgent() { return &this->bUrgent; }
+
+	[[nodiscard]] QBindable<QVariantMap> bindableLastIpcObject() const {
+		return &this->bLastIpcObject;
+	};
+
+	[[nodiscard]] QBindable<HyprlandWorkspace*> bindableWorkspace() { return &this->bWorkspace; }
+	void setWorkspace(HyprlandWorkspace* workspace);
+
+	[[nodiscard]] QBindable<HyprlandMonitor*> bindableMonitor() { return &this->bMonitor; }
+
+signals:
+	void addressChanged();
+	QSDOC_HIDE void waylandHandleChanged();
+	QSDOC_HIDE void hyprlandHandleChanged();
+
+	void titleChanged();
+	void activatedChanged();
+	void urgentChanged();
+	void workspaceChanged();
+	void monitorChanged();
+	void lastIpcObjectChanged();
+
+private slots:
+	void onActivatedChanged();
+
+private:
+	quint64 mAddress = 0;
+	HyprlandIpc* ipc;
+
+	qs::wayland::toplevel_management::impl::ToplevelHandle* mWaylandHandle = nullptr;
+	HyprlandToplevel* mHyprlandHandle = nullptr;
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandToplevel, QString, bTitle, &HyprlandToplevel::titleChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandToplevel, bool, bActivated, &HyprlandToplevel::activatedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandToplevel, bool, bUrgent, &HyprlandToplevel::urgentChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandToplevel, HyprlandWorkspace*, bWorkspace, &HyprlandToplevel::workspaceChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandToplevel, HyprlandMonitor*, bMonitor, &HyprlandToplevel::monitorChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandToplevel, QVariantMap, bLastIpcObject, &HyprlandToplevel::lastIpcObjectChanged);
+	// clang-format on
+};
+
+} // namespace qs::hyprland::ipc
diff --git a/src/wayland/hyprland/ipc/monitor.cpp b/src/wayland/hyprland/ipc/monitor.cpp
new file mode 100644
index 00000000..ddf37067
--- /dev/null
+++ b/src/wayland/hyprland/ipc/monitor.cpp
@@ -0,0 +1,90 @@
+#include "monitor.hpp"
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "workspace.hpp"
+
+namespace qs::hyprland::ipc {
+
+QVariantMap HyprlandMonitor::lastIpcObject() const { return this->mLastIpcObject; }
+
+void HyprlandMonitor::updateInitial(qint32 id, const QString& name, const QString& description) {
+	Qt::beginPropertyUpdateGroup();
+	this->bId = id;
+	this->bName = name;
+	this->bDescription = description;
+
+	this->bFocused.setBinding([this]() {
+		return HyprlandIpc::instance()->bindableFocusedMonitor().value() == this;
+	});
+
+	Qt::endPropertyUpdateGroup();
+}
+
+void HyprlandMonitor::updateFromObject(QVariantMap object) {
+	auto activeWorkspaceObj = object.value("activeWorkspace").value<QVariantMap>();
+	auto activeWorkspaceId = activeWorkspaceObj.value("id").value<qint32>();
+	auto activeWorkspaceName = activeWorkspaceObj.value("name").value<QString>();
+	auto focused = object.value("focused").value<bool>();
+
+	Qt::beginPropertyUpdateGroup();
+	this->bId = object.value("id").value<qint32>();
+	this->bName = object.value("name").value<QString>();
+	this->bDescription = object.value("description").value<QString>();
+	this->bX = object.value("x").value<qint32>();
+	this->bY = object.value("y").value<qint32>();
+	this->bWidth = object.value("width").value<qint32>();
+	this->bHeight = object.value("height").value<qint32>();
+	this->bScale = object.value("scale").value<qreal>();
+	Qt::endPropertyUpdateGroup();
+
+	if (this->bActiveWorkspace == nullptr
+	    || this->bActiveWorkspace->bindableName().value() != activeWorkspaceName)
+	{
+		auto* workspace = this->ipc->findWorkspaceByName(activeWorkspaceName, true, activeWorkspaceId);
+		workspace->setMonitor(this);
+		this->setActiveWorkspace(workspace);
+	}
+
+	this->mLastIpcObject = std::move(object);
+	emit this->lastIpcObjectChanged();
+
+	if (focused) {
+		this->ipc->setFocusedMonitor(this);
+	}
+}
+
+void HyprlandMonitor::setActiveWorkspace(HyprlandWorkspace* workspace) {
+	auto* oldWorkspace = this->bActiveWorkspace.value();
+	if (workspace == oldWorkspace) return;
+
+	if (oldWorkspace != nullptr) {
+		QObject::disconnect(oldWorkspace, nullptr, this, nullptr);
+	}
+
+	Qt::beginPropertyUpdateGroup();
+
+	if (workspace != nullptr) {
+		workspace->setMonitor(this);
+
+		QObject::connect(
+		    workspace,
+		    &QObject::destroyed,
+		    this,
+		    &HyprlandMonitor::onActiveWorkspaceDestroyed
+		);
+	}
+
+	this->bActiveWorkspace = workspace;
+
+	Qt::endPropertyUpdateGroup();
+}
+
+void HyprlandMonitor::onActiveWorkspaceDestroyed() { this->bActiveWorkspace = nullptr; }
+
+} // namespace qs::hyprland::ipc
diff --git a/src/wayland/hyprland/ipc/monitor.hpp b/src/wayland/hyprland/ipc/monitor.hpp
new file mode 100644
index 00000000..b9ac4349
--- /dev/null
+++ b/src/wayland/hyprland/ipc/monitor.hpp
@@ -0,0 +1,102 @@
+#pragma once
+
+#include <qbytearrayview.h>
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "connection.hpp"
+
+namespace qs::hyprland::ipc {
+
+class HyprlandWorkspace;
+
+class HyprlandMonitor: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	Q_PROPERTY(qint32 id READ default NOTIFY idChanged BINDABLE bindableId);
+	Q_PROPERTY(QString name READ default NOTIFY nameChanged BINDABLE bindableName);
+	Q_PROPERTY(QString description READ default NOTIFY descriptionChanged BINDABLE bindableDescription);
+	Q_PROPERTY(qint32 x READ default NOTIFY xChanged BINDABLE bindableX);
+	Q_PROPERTY(qint32 y READ default NOTIFY yChanged BINDABLE bindableY);
+	Q_PROPERTY(qint32 width READ default NOTIFY widthChanged BINDABLE bindableWidth);
+	Q_PROPERTY(qint32 height READ default NOTIFY heightChanged BINDABLE bindableHeight);
+	Q_PROPERTY(qreal scale READ default NOTIFY scaleChanged BINDABLE bindableScale);
+	/// Last json returned for this monitor, as a javascript object.
+	///
+	/// > [!WARNING] This is *not* updated unless the monitor object is fetched again from
+	/// > Hyprland. If you need a value that is subject to change and does not have a dedicated
+	/// > property, run @@Hyprland.refreshMonitors() and wait for this property to update.
+	Q_PROPERTY(QVariantMap lastIpcObject READ lastIpcObject NOTIFY lastIpcObjectChanged);
+	/// The currently active workspace on this monitor. May be null.
+	Q_PROPERTY(qs::hyprland::ipc::HyprlandWorkspace* activeWorkspace READ default NOTIFY activeWorkspaceChanged BINDABLE bindableActiveWorkspace);
+	/// If the monitor is currently focused.
+	Q_PROPERTY(bool focused READ default NOTIFY focusedChanged BINDABLE bindableFocused);
+	// clang-format on
+	QML_ELEMENT;
+	QML_UNCREATABLE("HyprlandMonitors must be retrieved from the HyprlandIpc object.");
+
+public:
+	explicit HyprlandMonitor(HyprlandIpc* ipc): QObject(ipc), ipc(ipc) {}
+
+	void updateInitial(qint32 id, const QString& name, const QString& description);
+	void updateFromObject(QVariantMap object);
+
+	[[nodiscard]] QBindable<qint32> bindableId() { return &this->bId; }
+	[[nodiscard]] QBindable<QString> bindableName() { return &this->bName; }
+	[[nodiscard]] QBindable<QString> bindableDescription() { return &this->bDescription; }
+	[[nodiscard]] QBindable<qint32> bindableX() { return &this->bX; }
+	[[nodiscard]] QBindable<qint32> bindableY() { return &this->bY; }
+	[[nodiscard]] QBindable<qint32> bindableWidth() { return &this->bWidth; }
+	[[nodiscard]] QBindable<qint32> bindableHeight() { return &this->bHeight; }
+	[[nodiscard]] QBindable<qreal> bindableScale() { return &this->bScale; }
+
+	[[nodiscard]] QBindable<HyprlandWorkspace*> bindableActiveWorkspace() const {
+		return &this->bActiveWorkspace;
+	}
+
+	[[nodiscard]] QBindable<bool> bindableFocused() const { return &this->bFocused; }
+
+	[[nodiscard]] QVariantMap lastIpcObject() const;
+
+	void setActiveWorkspace(HyprlandWorkspace* workspace);
+
+signals:
+	void idChanged();
+	void nameChanged();
+	void descriptionChanged();
+	void xChanged();
+	void yChanged();
+	void widthChanged();
+	void heightChanged();
+	void scaleChanged();
+	void lastIpcObjectChanged();
+	void activeWorkspaceChanged();
+	void focusedChanged();
+
+private slots:
+	void onActiveWorkspaceDestroyed();
+
+private:
+	HyprlandIpc* ipc;
+
+	QVariantMap mLastIpcObject;
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(HyprlandMonitor, qint32, bId, -1, &HyprlandMonitor::idChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandMonitor, QString, bName, &HyprlandMonitor::nameChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandMonitor, QString, bDescription, &HyprlandMonitor::descriptionChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandMonitor, qint32, bX, &HyprlandMonitor::xChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandMonitor, qint32, bY, &HyprlandMonitor::yChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandMonitor, qint32, bWidth, &HyprlandMonitor::widthChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandMonitor, qint32, bHeight, &HyprlandMonitor::heightChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandMonitor, qreal, bScale, &HyprlandMonitor::scaleChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandMonitor, HyprlandWorkspace*, bActiveWorkspace, &HyprlandMonitor::activeWorkspaceChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandMonitor, bool, bFocused, &HyprlandMonitor::focusedChanged);
+	// clang-format on
+};
+
+} // namespace qs::hyprland::ipc
diff --git a/src/wayland/hyprland/ipc/qml.cpp b/src/wayland/hyprland/ipc/qml.cpp
new file mode 100644
index 00000000..89eec9e3
--- /dev/null
+++ b/src/wayland/hyprland/ipc/qml.cpp
@@ -0,0 +1,78 @@
+#include "qml.hpp"
+
+#include <qobject.h>
+#include <qproperty.h>
+
+#include "../../../core/model.hpp"
+#include "../../../core/qmlscreen.hpp"
+#include "connection.hpp"
+#include "monitor.hpp"
+
+namespace qs::hyprland::ipc {
+
+HyprlandIpcQml::HyprlandIpcQml() {
+	auto* instance = HyprlandIpc::instance();
+
+	QObject::connect(instance, &HyprlandIpc::rawEvent, this, &HyprlandIpcQml::rawEvent);
+
+	QObject::connect(
+	    instance,
+	    &HyprlandIpc::focusedMonitorChanged,
+	    this,
+	    &HyprlandIpcQml::focusedMonitorChanged
+	);
+
+	QObject::connect(
+	    instance,
+	    &HyprlandIpc::focusedMonitorChanged,
+	    this,
+	    &HyprlandIpcQml::focusedMonitorChanged
+	);
+
+	QObject::connect(
+	    instance,
+	    &HyprlandIpc::activeToplevelChanged,
+	    this,
+	    &HyprlandIpcQml::activeToplevelChanged
+	);
+}
+
+void HyprlandIpcQml::dispatch(const QString& request) {
+	HyprlandIpc::instance()->dispatch(request);
+}
+
+HyprlandMonitor* HyprlandIpcQml::monitorFor(QuickshellScreenInfo* screen) {
+	return HyprlandIpc::instance()->monitorFor(screen);
+}
+
+void HyprlandIpcQml::refreshMonitors() { HyprlandIpc::instance()->refreshMonitors(false); }
+void HyprlandIpcQml::refreshWorkspaces() { HyprlandIpc::instance()->refreshWorkspaces(false); }
+void HyprlandIpcQml::refreshToplevels() { HyprlandIpc::instance()->refreshToplevels(); }
+QString HyprlandIpcQml::requestSocketPath() { return HyprlandIpc::instance()->requestSocketPath(); }
+QString HyprlandIpcQml::eventSocketPath() { return HyprlandIpc::instance()->eventSocketPath(); }
+
+QBindable<HyprlandMonitor*> HyprlandIpcQml::bindableFocusedMonitor() {
+	return HyprlandIpc::instance()->bindableFocusedMonitor();
+}
+
+QBindable<HyprlandWorkspace*> HyprlandIpcQml::bindableFocusedWorkspace() {
+	return HyprlandIpc::instance()->bindableFocusedWorkspace();
+}
+
+QBindable<HyprlandToplevel*> HyprlandIpcQml::bindableActiveToplevel() {
+	return HyprlandIpc::instance()->bindableActiveToplevel();
+}
+
+ObjectModel<HyprlandMonitor>* HyprlandIpcQml::monitors() {
+	return HyprlandIpc::instance()->monitors();
+}
+
+ObjectModel<HyprlandWorkspace>* HyprlandIpcQml::workspaces() {
+	return HyprlandIpc::instance()->workspaces();
+}
+
+ObjectModel<HyprlandToplevel>* HyprlandIpcQml::toplevels() {
+	return HyprlandIpc::instance()->toplevels();
+}
+
+} // namespace qs::hyprland::ipc
diff --git a/src/wayland/hyprland/ipc/qml.hpp b/src/wayland/hyprland/ipc/qml.hpp
new file mode 100644
index 00000000..ebf5d80a
--- /dev/null
+++ b/src/wayland/hyprland/ipc/qml.hpp
@@ -0,0 +1,91 @@
+#pragma once
+
+#include <qbytearrayview.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+
+#include "../../../core/doc.hpp"
+#include "../../../core/model.hpp"
+#include "../../../core/qmlscreen.hpp"
+#include "connection.hpp"
+#include "monitor.hpp"
+
+namespace qs::hyprland::ipc {
+
+class HyprlandIpcQml: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// Path to the request socket (.socket.sock)
+	Q_PROPERTY(QString requestSocketPath READ requestSocketPath CONSTANT);
+	/// Path to the event socket (.socket2.sock)
+	Q_PROPERTY(QString eventSocketPath READ eventSocketPath CONSTANT);
+	/// The currently focused hyprland monitor. May be null.
+	Q_PROPERTY(qs::hyprland::ipc::HyprlandMonitor* focusedMonitor READ default NOTIFY focusedMonitorChanged BINDABLE bindableFocusedMonitor);
+	/// The currently focused hyprland workspace. May be null.
+	Q_PROPERTY(qs::hyprland::ipc::HyprlandWorkspace* focusedWorkspace READ default NOTIFY focusedWorkspaceChanged BINDABLE bindableFocusedWorkspace);
+	/// Currently active toplevel (might be null)
+	Q_PROPERTY(qs::hyprland::ipc::HyprlandToplevel* activeToplevel READ default NOTIFY activeToplevelChanged BINDABLE bindableActiveToplevel);
+	/// All hyprland monitors.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::hyprland::ipc::HyprlandMonitor>*);
+	Q_PROPERTY(UntypedObjectModel* monitors READ monitors CONSTANT);
+	/// All hyprland workspaces, sorted by id.
+	///
+	/// > [!NOTE] Named workspaces have a negative id, and will appear before unnamed workspaces.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::hyprland::ipc::HyprlandWorkspace>*);
+	Q_PROPERTY(UntypedObjectModel* workspaces READ workspaces CONSTANT);
+	/// All hyprland toplevels
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::hyprland::ipc::HyprlandToplevel>*);
+	Q_PROPERTY(UntypedObjectModel* toplevels READ toplevels CONSTANT);
+	// clang-format on
+	QML_NAMED_ELEMENT(Hyprland);
+	QML_SINGLETON;
+
+public:
+	explicit HyprlandIpcQml();
+
+	/// Execute a hyprland [dispatcher](https://wiki.hyprland.org/Configuring/Dispatchers).
+	Q_INVOKABLE static void dispatch(const QString& request);
+
+	/// Get the HyprlandMonitor object that corrosponds to a quickshell screen.
+	Q_INVOKABLE static HyprlandMonitor* monitorFor(QuickshellScreenInfo* screen);
+
+	/// Refresh monitor information.
+	///
+	/// Many actions that will invalidate monitor state don't send events,
+	/// so this function is available if required.
+	Q_INVOKABLE static void refreshMonitors();
+
+	/// Refresh workspace information.
+	///
+	/// Many actions that will invalidate workspace state don't send events,
+	/// so this function is available if required.
+	Q_INVOKABLE static void refreshWorkspaces();
+
+	/// Refresh toplevel information.
+	///
+	/// Many actions that will invalidate workspace state don't send events,
+	/// so this function is available if required.
+	Q_INVOKABLE static void refreshToplevels();
+
+	[[nodiscard]] static QString requestSocketPath();
+	[[nodiscard]] static QString eventSocketPath();
+	[[nodiscard]] static QBindable<HyprlandMonitor*> bindableFocusedMonitor();
+	[[nodiscard]] static QBindable<HyprlandWorkspace*> bindableFocusedWorkspace();
+	[[nodiscard]] static QBindable<HyprlandToplevel*> bindableActiveToplevel();
+	[[nodiscard]] static ObjectModel<HyprlandMonitor>* monitors();
+	[[nodiscard]] static ObjectModel<HyprlandWorkspace>* workspaces();
+	[[nodiscard]] static ObjectModel<HyprlandToplevel>* toplevels();
+
+signals:
+	/// Emitted for every event that comes in through the hyprland event socket (socket2).
+	///
+	/// See [Hyprland Wiki: IPC](https://wiki.hyprland.org/IPC/) for a list of events.
+	void rawEvent(qs::hyprland::ipc::HyprlandIpcEvent* event);
+
+	void focusedMonitorChanged();
+	void focusedWorkspaceChanged();
+	void activeToplevelChanged();
+};
+
+} // namespace qs::hyprland::ipc
diff --git a/src/wayland/hyprland/ipc/toplevel_mapping.cpp b/src/wayland/hyprland/ipc/toplevel_mapping.cpp
new file mode 100644
index 00000000..dadd7d89
--- /dev/null
+++ b/src/wayland/hyprland/ipc/toplevel_mapping.cpp
@@ -0,0 +1,83 @@
+#include "toplevel_mapping.hpp"
+
+#include <qlogging.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qwaylandclientextension.h>
+
+#include "../../toplevel_management/manager.hpp"
+
+using namespace qs::wayland::toplevel_management::impl;
+
+namespace qs::hyprland::ipc {
+
+HyprlandToplevelMappingHandle::~HyprlandToplevelMappingHandle() {
+	if (this->isInitialized()) this->destroy();
+}
+
+void HyprlandToplevelMappingHandle::hyprland_toplevel_window_mapping_handle_v1_window_address(
+    quint32 addressHi,
+    quint32 addressLo
+) {
+	auto address = static_cast<quint64>(addressHi) << 32 | addressLo;
+	HyprlandToplevelMappingManager::instance()->assignAddress(this->handle, address);
+	delete this;
+}
+
+void HyprlandToplevelMappingHandle::hyprland_toplevel_window_mapping_handle_v1_failed() {
+	delete this;
+}
+
+HyprlandToplevelMappingManager::HyprlandToplevelMappingManager()
+    : QWaylandClientExtensionTemplate(1) {
+	this->initialize();
+
+	if (!this->isInitialized()) {
+		qWarning() << "Compositor does not support hyprland-toplevel-mapping-v1."
+		              "It will not be possible to derive hyprland addresses from toplevels.";
+		return;
+	}
+
+	QObject::connect(
+	    ToplevelManager::instance(),
+	    &ToplevelManager::toplevelReady,
+	    this,
+	    &HyprlandToplevelMappingManager::onToplevelReady
+	);
+
+	for (auto* toplevel: ToplevelManager::instance()->readyToplevels()) {
+		this->onToplevelReady(toplevel);
+	}
+}
+
+void HyprlandToplevelMappingManager::onToplevelReady(ToplevelHandle* handle) {
+	QObject::connect(
+	    handle,
+	    &QObject::destroyed,
+	    this,
+	    &HyprlandToplevelMappingManager::onToplevelDestroyed
+	);
+
+	new HyprlandToplevelMappingHandle(handle, this->get_window_for_toplevel_wlr(handle->object()));
+}
+
+void HyprlandToplevelMappingManager::assignAddress(ToplevelHandle* handle, quint64 address) {
+	this->addresses.insert(handle, address);
+	emit this->toplevelAddressed(handle, address);
+}
+
+void HyprlandToplevelMappingManager::onToplevelDestroyed(QObject* object) {
+	this->addresses.remove(static_cast<ToplevelHandle*>(object)); // NOLINT
+}
+
+quint64 HyprlandToplevelMappingManager::getToplevelAddress(ToplevelHandle* handle) const {
+	return this->addresses.value(handle);
+}
+
+HyprlandToplevelMappingManager* HyprlandToplevelMappingManager::instance() {
+	static auto* instance = new HyprlandToplevelMappingManager();
+	return instance;
+}
+
+} // namespace qs::hyprland::ipc
diff --git a/src/wayland/hyprland/ipc/toplevel_mapping.hpp b/src/wayland/hyprland/ipc/toplevel_mapping.hpp
new file mode 100644
index 00000000..31eeade9
--- /dev/null
+++ b/src/wayland/hyprland/ipc/toplevel_mapping.hpp
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <qhash.h>
+#include <qobject.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qwayland-hyprland-toplevel-mapping-v1.h>
+#include <qwaylandclientextension.h>
+
+#include "../../toplevel_management/handle.hpp"
+#include "wayland-hyprland-toplevel-mapping-v1-client-protocol.h"
+
+namespace qs::hyprland::ipc {
+
+class HyprlandToplevelMappingHandle: QtWayland::hyprland_toplevel_window_mapping_handle_v1 {
+public:
+	explicit HyprlandToplevelMappingHandle(
+	    qs::wayland::toplevel_management::impl::ToplevelHandle* handle,
+	    ::hyprland_toplevel_window_mapping_handle_v1* mapping
+	)
+	    : QtWayland::hyprland_toplevel_window_mapping_handle_v1(mapping)
+	    , handle(handle) {}
+
+	~HyprlandToplevelMappingHandle() override;
+	Q_DISABLE_COPY_MOVE(HyprlandToplevelMappingHandle);
+
+protected:
+	void hyprland_toplevel_window_mapping_handle_v1_window_address(
+	    quint32 addressHi,
+	    quint32 addressLo
+	) override;
+
+	void hyprland_toplevel_window_mapping_handle_v1_failed() override;
+
+private:
+	qs::wayland::toplevel_management::impl::ToplevelHandle* handle;
+};
+
+class HyprlandToplevelMappingManager
+    : public QWaylandClientExtensionTemplate<HyprlandToplevelMappingManager>
+    , public QtWayland::hyprland_toplevel_mapping_manager_v1 {
+	Q_OBJECT;
+
+public:
+	explicit HyprlandToplevelMappingManager();
+
+	static HyprlandToplevelMappingManager* instance();
+
+	[[nodiscard]] quint64
+	getToplevelAddress(qs::wayland::toplevel_management::impl::ToplevelHandle* handle) const;
+
+signals:
+	void toplevelAddressed(
+	    qs::wayland::toplevel_management::impl::ToplevelHandle* handle,
+	    quint64 address
+	);
+
+private slots:
+	void onToplevelReady(qs::wayland::toplevel_management::impl::ToplevelHandle* handle);
+	void onToplevelDestroyed(QObject* object);
+
+private:
+	void
+	assignAddress(qs::wayland::toplevel_management::impl::ToplevelHandle* handle, quint64 address);
+	QHash<wayland::toplevel_management::impl::ToplevelHandle*, quint64> addresses;
+
+	friend class HyprlandToplevelMappingHandle;
+};
+} // namespace qs::hyprland::ipc
diff --git a/src/wayland/hyprland/ipc/workspace.cpp b/src/wayland/hyprland/ipc/workspace.cpp
new file mode 100644
index 00000000..c5d63b02
--- /dev/null
+++ b/src/wayland/hyprland/ipc/workspace.cpp
@@ -0,0 +1,157 @@
+#include "workspace.hpp"
+#include <algorithm>
+#include <utility>
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "connection.hpp"
+#include "monitor.hpp"
+
+namespace qs::hyprland::ipc {
+
+QVariantMap HyprlandWorkspace::lastIpcObject() const { return this->mLastIpcObject; }
+
+HyprlandWorkspace::HyprlandWorkspace(HyprlandIpc* ipc): QObject(ipc), ipc(ipc) {
+	Qt::beginPropertyUpdateGroup();
+
+	this->bActive.setBinding([this]() {
+		return this->bMonitor.value() && this->bMonitor->bindableActiveWorkspace().value() == this;
+	});
+
+	this->bFocused.setBinding([this]() {
+		return this->ipc->bindableFocusedWorkspace().value() == this;
+	});
+
+	QObject::connect(this, &HyprlandWorkspace::focusedChanged, this, [this]() {
+		if (this->bFocused.value()) {
+			this->updateUrgent();
+		}
+	});
+
+	Qt::endPropertyUpdateGroup();
+}
+
+void HyprlandWorkspace::updateInitial(qint32 id, const QString& name) {
+	Qt::beginPropertyUpdateGroup();
+	this->bId = id;
+	this->bName = name;
+	Qt::endPropertyUpdateGroup();
+}
+
+void HyprlandWorkspace::updateFromObject(QVariantMap object) {
+	auto monitorId = object.value("monitorID").value<qint32>();
+	auto monitorName = object.value("monitor").value<QString>();
+	auto hasFullscreen = object.value("hasfullscreen").value<bool>();
+
+	auto initial = this->bId == -1;
+
+	// ID cannot be updated after creation
+	if (initial) {
+		this->bId = object.value("id").value<qint32>();
+	}
+
+	// No events we currently handle give a workspace id but not a name,
+	// so we shouldn't set this if it isn't an initial query
+	if (initial) {
+		this->bName = object.value("name").value<QString>();
+	}
+
+	if (!monitorName.isEmpty()
+	    && (this->bMonitor == nullptr || this->bMonitor->bindableName().value() != monitorName))
+	{
+		auto* monitor = this->ipc->findMonitorByName(monitorName, true, monitorId);
+		this->setMonitor(monitor);
+	}
+
+	this->bHasFullscreen = hasFullscreen;
+	this->mLastIpcObject = std::move(object);
+	emit this->lastIpcObjectChanged();
+}
+
+void HyprlandWorkspace::setMonitor(HyprlandMonitor* monitor) {
+	auto* oldMonitor = this->bMonitor.value();
+	if (monitor == oldMonitor) return;
+
+	if (oldMonitor != nullptr) {
+		QObject::disconnect(oldMonitor, nullptr, this, nullptr);
+	}
+
+	if (monitor != nullptr) {
+		QObject::connect(monitor, &QObject::destroyed, this, &HyprlandWorkspace::onMonitorDestroyed);
+	}
+
+	this->bMonitor = monitor;
+}
+
+void HyprlandWorkspace::onMonitorDestroyed() { this->bMonitor = nullptr; }
+
+void HyprlandWorkspace::insertToplevel(HyprlandToplevel* toplevel) {
+	if (!toplevel) return;
+
+	const auto& mList = this->mToplevels.valueList();
+
+	if (std::ranges::find(mList, toplevel) != mList.end()) {
+		return;
+	}
+
+	this->mToplevels.insertObject(toplevel);
+
+	QObject::connect(toplevel, &QObject::destroyed, this, [this, toplevel]() {
+		this->removeToplevel(toplevel);
+	});
+
+	QObject::connect(
+	    toplevel,
+	    &HyprlandToplevel::urgentChanged,
+	    this,
+	    &HyprlandWorkspace::updateUrgent
+	);
+
+	this->updateUrgent();
+}
+
+void HyprlandWorkspace::removeToplevel(HyprlandToplevel* toplevel) {
+	if (!toplevel) return;
+
+	this->mToplevels.removeObject(toplevel);
+	emit this->updateUrgent();
+	QObject::disconnect(toplevel, nullptr, this, nullptr);
+}
+
+// Triggered when there is an update either on the toplevel list, on a toplevel's urgent state
+void HyprlandWorkspace::updateUrgent() {
+	const auto& mList = this->mToplevels.valueList();
+
+	const bool hasUrgentToplevel = std::ranges::any_of(mList, [&](HyprlandToplevel* toplevel) {
+		return toplevel->bindableUrgent().value();
+	});
+
+	if (this->bFocused && hasUrgentToplevel) {
+		this->clearUrgent();
+		return;
+	}
+
+	if (hasUrgentToplevel != this->bUrgent.value()) {
+		this->bUrgent = hasUrgentToplevel;
+	}
+}
+
+void HyprlandWorkspace::clearUrgent() {
+	this->bUrgent = false;
+
+	// Clear all urgent toplevels
+	const auto& mList = this->mToplevels.valueList();
+	for (auto* toplevel: mList) {
+		toplevel->bindableUrgent().setValue(false);
+	}
+}
+
+void HyprlandWorkspace::activate() {
+	this->ipc->dispatch(QString("workspace %1").arg(this->bName.value()));
+}
+
+} // namespace qs::hyprland::ipc
diff --git a/src/wayland/hyprland/ipc/workspace.hpp b/src/wayland/hyprland/ipc/workspace.hpp
new file mode 100644
index 00000000..a0b09cf3
--- /dev/null
+++ b/src/wayland/hyprland/ipc/workspace.hpp
@@ -0,0 +1,110 @@
+#pragma once
+
+#include <qbytearrayview.h>
+#include <qjsonobject.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "connection.hpp"
+#include "hyprland_toplevel.hpp"
+
+namespace qs::hyprland::ipc {
+
+class HyprlandMonitor;
+
+class HyprlandWorkspace: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	Q_PROPERTY(qint32 id READ default NOTIFY idChanged BINDABLE bindableId);
+	Q_PROPERTY(QString name READ default NOTIFY nameChanged BINDABLE bindableName);
+	/// If this workspace is currently active on its monitor. See also @@focused.
+	Q_PROPERTY(bool active READ default NOTIFY activeChanged BINDABLE bindableActive);
+	/// If this workspace is currently active on a monitor and that monitor is currently
+	/// focused. See also @@active.
+	Q_PROPERTY(bool focused READ default NOTIFY focusedChanged BINDABLE bindableFocused);
+	/// If this workspace has a window that is urgent.
+	/// Becomes always falsed after the workspace is @@focused.
+	Q_PROPERTY(bool urgent READ default NOTIFY urgentChanged BINDABLE bindableUrgent);
+	/// If this workspace currently has a fullscreen client.
+	Q_PROPERTY(bool hasFullscreen READ default NOTIFY hasFullscreenChanged BINDABLE bindableHasFullscreen);
+	/// Last json returned for this workspace, as a javascript object.
+	///
+	/// > [!WARNING] This is *not* updated unless the workspace object is fetched again from
+	/// > Hyprland. If you need a value that is subject to change and does not have a dedicated
+	/// > property, run @@Hyprland.refreshWorkspaces() and wait for this property to update.
+	Q_PROPERTY(QVariantMap lastIpcObject READ lastIpcObject NOTIFY lastIpcObjectChanged);
+	Q_PROPERTY(qs::hyprland::ipc::HyprlandMonitor* monitor READ default NOTIFY monitorChanged BINDABLE bindableMonitor);
+	/// List of toplevels on this workspace.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::hyprland::ipc::HyprlandToplevel*);
+	Q_PROPERTY(UntypedObjectModel* toplevels READ toplevels CONSTANT);
+	// clang-format on
+	QML_ELEMENT;
+	QML_UNCREATABLE("HyprlandWorkspaces must be retrieved from the HyprlandIpc object.");
+
+public:
+	explicit HyprlandWorkspace(HyprlandIpc* ipc);
+
+	void updateInitial(qint32 id, const QString& name);
+	void updateFromObject(QVariantMap object);
+
+	/// Activate the workspace.
+	///
+	/// > [!NOTE] This is equivalent to running
+	/// > ```qml
+	/// > HyprlandIpc.dispatch(`workspace ${workspace.name}`);
+	/// > ```
+	Q_INVOKABLE void activate();
+
+	[[nodiscard]] QBindable<qint32> bindableId() { return &this->bId; }
+	[[nodiscard]] QBindable<QString> bindableName() { return &this->bName; }
+	[[nodiscard]] QBindable<bool> bindableActive() { return &this->bActive; }
+	[[nodiscard]] QBindable<bool> bindableFocused() { return &this->bFocused; }
+	[[nodiscard]] QBindable<bool> bindableUrgent() { return &this->bUrgent; }
+	[[nodiscard]] QBindable<bool> bindableHasFullscreen() { return &this->bHasFullscreen; }
+	[[nodiscard]] QBindable<HyprlandMonitor*> bindableMonitor() { return &this->bMonitor; }
+	[[nodiscard]] ObjectModel<HyprlandToplevel>* toplevels() { return &this->mToplevels; }
+
+	[[nodiscard]] QVariantMap lastIpcObject() const;
+
+	void setMonitor(HyprlandMonitor* monitor);
+
+	void insertToplevel(HyprlandToplevel* toplevel);
+	void removeToplevel(HyprlandToplevel* toplevel);
+
+signals:
+	void idChanged();
+	void nameChanged();
+	void activeChanged();
+	void focusedChanged();
+	void urgentChanged();
+	void hasFullscreenChanged();
+	void lastIpcObjectChanged();
+	void monitorChanged();
+
+private slots:
+	void onMonitorDestroyed();
+	void updateUrgent();
+
+private:
+	void clearUrgent();
+
+	HyprlandIpc* ipc;
+	QVariantMap mLastIpcObject;
+
+	ObjectModel<HyprlandToplevel> mToplevels {this};
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(HyprlandWorkspace, qint32, bId, -1, &HyprlandWorkspace::idChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandWorkspace, QString, bName, &HyprlandWorkspace::nameChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandWorkspace, bool, bActive, &HyprlandWorkspace::activeChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandWorkspace, bool, bFocused, &HyprlandWorkspace::focusedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandWorkspace, bool, bUrgent, &HyprlandWorkspace::urgentChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandWorkspace, bool, bHasFullscreen, &HyprlandWorkspace::hasFullscreenChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(HyprlandWorkspace, HyprlandMonitor*, bMonitor, &HyprlandWorkspace::monitorChanged);
+	// clang-format on
+};
+
+} // namespace qs::hyprland::ipc
diff --git a/src/wayland/hyprland/module.md b/src/wayland/hyprland/module.md
new file mode 100644
index 00000000..921bac99
--- /dev/null
+++ b/src/wayland/hyprland/module.md
@@ -0,0 +1,13 @@
+name = "Quickshell.Hyprland"
+description = "Hyprland specific Quickshell types"
+headers = [
+	"ipc/connection.hpp",
+	"ipc/monitor.hpp",
+	"ipc/workspace.hpp",
+	"ipc/hyprland_toplevel.hpp",
+	"ipc/qml.hpp",
+	"focus_grab/qml.hpp",
+	"global_shortcuts/qml.hpp",
+	"surface/qml.hpp",
+]
+-----
diff --git a/src/wayland/hyprland/surface/CMakeLists.txt b/src/wayland/hyprland/surface/CMakeLists.txt
new file mode 100644
index 00000000..7f889c96
--- /dev/null
+++ b/src/wayland/hyprland/surface/CMakeLists.txt
@@ -0,0 +1,24 @@
+qt_add_library(quickshell-hyprland-surface-extensions STATIC
+	qml.cpp
+	manager.cpp
+	surface.cpp
+)
+
+qt_add_qml_module(quickshell-hyprland-surface-extensions
+	URI Quickshell.Hyprland._SurfaceExtensions
+	VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+install_qml_module(quickshell-hyprland-surface-extensions)
+
+wl_proto(wlp-hyprland-surface hyprland-surface-v1 "${CMAKE_CURRENT_SOURCE_DIR}")
+
+target_link_libraries(quickshell-hyprland-surface-extensions PRIVATE
+	Qt::Quick Qt::WaylandClient Qt::WaylandClientPrivate wayland-client
+	wlp-hyprland-surface
+)
+
+qs_module_pch(quickshell-hyprland-surface-extensions)
+
+target_link_libraries(quickshell PRIVATE quickshell-hyprland-surface-extensionsplugin)
diff --git a/src/wayland/hyprland/surface/hyprland-surface-v1.xml b/src/wayland/hyprland/surface/hyprland-surface-v1.xml
new file mode 100644
index 00000000..c4b1424f
--- /dev/null
+++ b/src/wayland/hyprland/surface/hyprland-surface-v1.xml
@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="hyprland_surface_v1">
+  <copyright>
+    Copyright © 2025 outfoxxed
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this
+       list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright notice,
+       this list of conditions and the following disclaimer in the documentation
+       and/or other materials provided with the distribution.
+
+    3. Neither the name of the copyright holder nor the names of its
+       contributors may be used to endorse or promote products derived from
+       this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  </copyright>
+
+  <description summary="hyprland-specific wl_surface extensions">
+    This protocol exposes hyprland-specific wl_surface properties.
+  </description>
+
+  <interface name="hyprland_surface_manager_v1" version="2">
+    <description summary="manager for hyprland surface objects">
+      This interface allows a client to create hyprland surface objects.
+    </description>
+
+    <request name="get_hyprland_surface">
+      <description summary="create a hyprland surface object">
+        Create a hyprland surface object for the given wayland surface.
+
+        If the wl_surface already has an associated hyprland_surface_v1 object,
+        even from a different manager, creation is a protocol error.
+      </description>
+
+      <arg name="id" type="new_id" interface="hyprland_surface_v1"/>
+      <arg name="surface" type="object" interface="wl_surface"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the hyprland surface manager">
+        Destroy the surface manager.
+        This does not destroy existing surface objects.
+      </description>
+    </request>
+
+    <enum name="error">
+      <entry name="already_constructed" value="0" summary="wl_surface already has a hyprland surface object"/>
+    </enum>
+  </interface>
+
+  <interface name="hyprland_surface_v1" version="2">
+    <description summary="hyprland-specific wl_surface properties">
+      This interface allows access to hyprland-specific properties of a wl_surface.
+
+      Once the wl_surface has been destroyed, the hyprland surface object must be
+      destroyed as well. All other operations are a protocol error.
+    </description>
+
+    <request name="set_opacity">
+      <description summary="set the overall opacity of the surface">
+        Sets a multiplier for the overall opacity of the surface.
+        This multiplier applies to visual effects such as blur behind the surface
+        in addition to the surface's content.
+
+        The default value is 1.0.
+        Setting a value outside of the range 0.0 - 1.0 (inclusive) is a protocol error.
+        Does not take effect until wl_surface.commit is called.
+      </description>
+
+      <arg name="opacity" type="fixed"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the hyprland surface interface">
+        Destroy the hyprland surface object, resetting properties provided
+        by this interface to their default values on the next wl_surface.commit.
+      </description>
+    </request>
+
+    <enum name="error">
+      <entry name="no_surface" value="0" summary="wl_surface was destroyed"/>
+      <entry name="out_of_range" value="1" summary="given opacity was not in the range 0.0 - 1.0 (inclusive)"/>
+    </enum>
+
+    <request name="set_visible_region" since="2">
+      <description summary="set the visible region of the surface">
+        This request sets the region of the surface that contains visible content.
+        Visible content refers to content that has an alpha value greater than zero.
+
+        The visible region is an optimization hint for the compositor that lets it
+        avoid drawing parts of the surface that are not visible. Setting a visible region
+        that does not contain all content in the surface may result in missing content
+        not being drawn.
+
+        The visible region is specified in buffer-local coordinates.
+
+        The compositor ignores the parts of the visible region that fall outside of the surface.
+        When all parts of the region fall outside of the buffer geometry, the compositor may
+        avoid rendering the surface entirely.
+
+        The initial value for the visible region is empty. Setting the
+        visible region has copy semantics, and the wl_region object can be destroyed immediately.
+        A NULL wl_region causes the visible region to be set to empty.
+
+        Does not take effect until wl_surface.commit is called.
+      </description>
+
+      <arg name="region" type="object" interface="wl_region" allow-null="true"/>
+    </request>
+  </interface>
+</protocol>
diff --git a/src/wayland/hyprland/surface/manager.cpp b/src/wayland/hyprland/surface/manager.cpp
new file mode 100644
index 00000000..6354255e
--- /dev/null
+++ b/src/wayland/hyprland/surface/manager.cpp
@@ -0,0 +1,24 @@
+#include "manager.hpp"
+
+#include <private/qwaylandwindow_p.h>
+#include <qwaylandclientextension.h>
+
+#include "surface.hpp"
+
+namespace qs::hyprland::surface::impl {
+
+HyprlandSurfaceManager::HyprlandSurfaceManager(): QWaylandClientExtensionTemplate(2) {
+	this->initialize();
+}
+
+HyprlandSurface*
+HyprlandSurfaceManager::createHyprlandExtension(QtWaylandClient::QWaylandWindow* surface) {
+	return new HyprlandSurface(this->get_hyprland_surface(surface->surface()), surface);
+}
+
+HyprlandSurfaceManager* HyprlandSurfaceManager::instance() {
+	static auto* instance = new HyprlandSurfaceManager();
+	return instance;
+}
+
+} // namespace qs::hyprland::surface::impl
diff --git a/src/wayland/hyprland/surface/manager.hpp b/src/wayland/hyprland/surface/manager.hpp
new file mode 100644
index 00000000..8332241f
--- /dev/null
+++ b/src/wayland/hyprland/surface/manager.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <private/qwaylandwindow_p.h>
+#include <qwayland-hyprland-surface-v1.h>
+#include <qwaylandclientextension.h>
+
+#include "surface.hpp"
+
+namespace qs::hyprland::surface::impl {
+
+class HyprlandSurfaceManager
+    : public QWaylandClientExtensionTemplate<HyprlandSurfaceManager>
+    , public QtWayland::hyprland_surface_manager_v1 {
+public:
+	explicit HyprlandSurfaceManager();
+
+	HyprlandSurface* createHyprlandExtension(QtWaylandClient::QWaylandWindow* surface);
+
+	static HyprlandSurfaceManager* instance();
+};
+
+} // namespace qs::hyprland::surface::impl
diff --git a/src/wayland/hyprland/surface/qml.cpp b/src/wayland/hyprland/surface/qml.cpp
new file mode 100644
index 00000000..b00ee33e
--- /dev/null
+++ b/src/wayland/hyprland/surface/qml.cpp
@@ -0,0 +1,255 @@
+#include "qml.hpp"
+#include <memory>
+
+#include <private/qhighdpiscaling_p.h>
+#include <private/qwaylandwindow_p.h>
+#include <qlogging.h>
+#include <qobject.h>
+#include <qqmlinfo.h>
+#include <qregion.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+#include <qwindow.h>
+
+#include "../../../core/region.hpp"
+#include "../../../window/proxywindow.hpp"
+#include "../../../window/windowinterface.hpp"
+#include "manager.hpp"
+#include "surface.hpp"
+
+using QtWaylandClient::QWaylandWindow;
+
+namespace qs::hyprland::surface {
+
+HyprlandWindow* HyprlandWindow::qmlAttachedProperties(QObject* object) {
+	auto* proxyWindow = qobject_cast<ProxyWindowBase*>(object);
+
+	if (!proxyWindow) {
+		if (auto* iface = qobject_cast<WindowInterface*>(object)) {
+			proxyWindow = iface->proxyWindow();
+		}
+	}
+
+	if (!proxyWindow) return nullptr;
+	return new HyprlandWindow(proxyWindow);
+}
+
+HyprlandWindow::HyprlandWindow(ProxyWindowBase* window): QObject(nullptr), proxyWindow(window) {
+	QObject::connect(
+	    window,
+	    &ProxyWindowBase::windowConnected,
+	    this,
+	    &HyprlandWindow::onWindowConnected
+	);
+
+	QObject::connect(window, &ProxyWindowBase::polished, this, &HyprlandWindow::onWindowPolished);
+
+	QObject::connect(
+	    window,
+	    &ProxyWindowBase::devicePixelRatioChanged,
+	    this,
+	    &HyprlandWindow::updateVisibleMask
+	);
+
+	QObject::connect(window, &QObject::destroyed, this, &HyprlandWindow::onProxyWindowDestroyed);
+
+	if (window->backingWindow()) {
+		this->onWindowConnected();
+	}
+}
+
+qreal HyprlandWindow::opacity() const { return this->mOpacity; }
+
+void HyprlandWindow::setOpacity(qreal opacity) {
+	if (opacity == this->mOpacity) return;
+
+	if (opacity < 0.0 || opacity > 1.0) {
+		qmlWarning(this
+		) << "Cannot set HyprlandWindow.opacity to a value larger than 1.0 or smaller than 0.0";
+		return;
+	}
+
+	this->mOpacity = opacity;
+
+	if (this->surface && this->proxyWindow) {
+		this->pendingPolish.opacity = true;
+		this->proxyWindow->schedulePolish();
+	}
+
+	emit this->opacityChanged();
+}
+
+PendingRegion* HyprlandWindow::visibleMask() const { return this->mVisibleMask; }
+
+void HyprlandWindow::setVisibleMask(PendingRegion* mask) {
+	if (mask == this->mVisibleMask) return;
+
+	if (this->mVisibleMask) {
+		QObject::disconnect(this->mVisibleMask, nullptr, this, nullptr);
+	}
+
+	this->mVisibleMask = mask;
+
+	if (mask) {
+		QObject::connect(mask, &QObject::destroyed, this, &HyprlandWindow::onVisibleMaskDestroyed);
+		QObject::connect(mask, &PendingRegion::changed, this, &HyprlandWindow::updateVisibleMask);
+	}
+
+	this->updateVisibleMask();
+	emit this->visibleMaskChanged();
+}
+
+void HyprlandWindow::onVisibleMaskDestroyed() {
+	this->mVisibleMask = nullptr;
+	this->updateVisibleMask();
+	emit this->visibleMaskChanged();
+}
+
+void HyprlandWindow::updateVisibleMask() {
+	if (!this->surface || !this->proxyWindow) return;
+
+	this->pendingPolish.visibleMask = true;
+	this->proxyWindow->schedulePolish();
+}
+
+void HyprlandWindow::onWindowPolished() {
+	if (!this->surface) return;
+
+	if (this->pendingPolish.opacity) {
+		this->surface->setOpacity(this->mOpacity);
+		this->pendingPolish.opacity = false;
+	}
+
+	if (this->pendingPolish.visibleMask) {
+		QRegion mask;
+		if (this->mVisibleMask != nullptr) {
+			mask =
+			    this->mVisibleMask->applyTo(QRect(0, 0, this->mWindow->width(), this->mWindow->height()));
+		}
+
+		auto dpr = this->proxyWindow->devicePixelRatio();
+		if (dpr != 1.0) {
+			mask = QHighDpi::scale(mask, dpr);
+		}
+
+		if (mask.isEmpty() && this->mVisibleMask) {
+			mask = QRect(-1, -1, 1, 1);
+		}
+
+		this->surface->setVisibleRegion(mask);
+		this->pendingPolish.visibleMask = false;
+	}
+}
+
+void HyprlandWindow::onWindowConnected() {
+	this->mWindow = this->proxyWindow->backingWindow();
+	// disconnected by destructor
+	QObject::connect(
+	    this->mWindow,
+	    &QWindow::visibleChanged,
+	    this,
+	    &HyprlandWindow::onWindowVisibleChanged
+	);
+
+	this->onWindowVisibleChanged();
+}
+
+void HyprlandWindow::onWindowVisibleChanged() {
+	if (this->mWindow->isVisible()) {
+		if (!this->mWindow->handle()) {
+			this->mWindow->create();
+		}
+	}
+
+	auto* window = dynamic_cast<QWaylandWindow*>(this->mWindow->handle());
+	if (window == this->mWaylandWindow) return;
+
+	if (this->mWaylandWindow) {
+		QObject::disconnect(this->mWaylandWindow, nullptr, this, nullptr);
+	}
+
+	this->mWaylandWindow = window;
+	if (!window) return;
+
+	QObject::connect(
+	    this->mWaylandWindow,
+	    &QObject::destroyed,
+	    this,
+	    &HyprlandWindow::onWaylandWindowDestroyed
+	);
+
+	QObject::connect(
+	    this->mWaylandWindow,
+	    &QWaylandWindow::surfaceCreated,
+	    this,
+	    &HyprlandWindow::onWaylandSurfaceCreated
+	);
+
+	QObject::connect(
+	    this->mWaylandWindow,
+	    &QWaylandWindow::surfaceDestroyed,
+	    this,
+	    &HyprlandWindow::onWaylandSurfaceDestroyed
+	);
+
+	if (this->mWaylandWindow->surface()) {
+		this->onWaylandSurfaceCreated();
+	}
+}
+
+void HyprlandWindow::onWaylandWindowDestroyed() { this->mWaylandWindow = nullptr; }
+
+void HyprlandWindow::onWaylandSurfaceCreated() {
+	auto* manager = impl::HyprlandSurfaceManager::instance();
+
+	if (!manager->isActive()) {
+		qWarning() << "The active compositor does not support the hyprland_surface_v1 protocol. "
+		              "HyprlandWindow will not work.";
+		return;
+	}
+
+	auto v = this->mWaylandWindow->property("hyprland_window_ext");
+	if (v.canConvert<HyprlandWindow*>()) {
+		auto* windowExt = v.value<HyprlandWindow*>();
+		if (windowExt != this && windowExt->surface) {
+			this->surface.swap(windowExt->surface);
+		}
+	}
+
+	if (!this->surface) {
+		auto* ext = manager->createHyprlandExtension(this->mWaylandWindow);
+		this->surface = std::unique_ptr<impl::HyprlandSurface>(ext);
+	}
+
+	this->mWaylandWindow->setProperty("hyprland_window_ext", QVariant::fromValue(this));
+
+	this->pendingPolish.opacity = this->mOpacity != 1.0;
+	this->pendingPolish.visibleMask = this->mVisibleMask;
+
+	if (this->pendingPolish.opacity || this->pendingPolish.visibleMask) {
+		this->proxyWindow->schedulePolish();
+	}
+}
+
+void HyprlandWindow::onWaylandSurfaceDestroyed() {
+	this->surface = nullptr;
+
+	if (!this->proxyWindow) {
+		this->deleteLater();
+	}
+}
+
+void HyprlandWindow::onProxyWindowDestroyed() {
+	// Don't delete the HyprlandWindow, and therefore the impl::HyprlandSurface until the wl_surface is destroyed.
+	// Deleting it when the proxy window is deleted will cause a full opacity frame between the destruction of the
+	// hyprland_surface_v1 and wl_surface objects.
+
+	this->proxyWindow = nullptr;
+
+	if (this->surface == nullptr) {
+		this->deleteLater();
+	}
+}
+
+} // namespace qs::hyprland::surface
diff --git a/src/wayland/hyprland/surface/qml.hpp b/src/wayland/hyprland/surface/qml.hpp
new file mode 100644
index 00000000..157b8f32
--- /dev/null
+++ b/src/wayland/hyprland/surface/qml.hpp
@@ -0,0 +1,96 @@
+#pragma once
+
+#include <memory>
+
+#include <private/qwaylandwindow_p.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qwindow.h>
+
+#include "../../../core/region.hpp"
+#include "../../../window/proxywindow.hpp"
+#include "surface.hpp"
+
+namespace qs::hyprland::surface {
+
+///! Hyprland specific QsWindow properties.
+/// Allows setting hyprland specific window properties on a @@Quickshell.QsWindow or subclass,
+/// as an attached object.
+///
+/// #### Example
+/// ```qml
+/// @@Quickshell.PopupWindow {
+///   // ...
+///   HyprlandWindow.opacity: 0.6 // any number or binding
+/// }
+/// ```
+///
+/// > [!NOTE] Requires at least hyprland 0.47.0, or [hyprland-surface-v1] support.
+///
+/// [hyprland-surface-v1]: https://github.com/hyprwm/hyprland-protocols/blob/main/protocols/hyprland-surface-v1.xml
+class HyprlandWindow: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// A multiplier for the window's overall opacity, ranging from 1.0 to 0.0. Overall opacity includes the opacity of
+	/// both the window content *and* visual effects such as blur that apply to it.
+	///
+	/// Default: 1.0
+	Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity NOTIFY opacityChanged);
+	/// A hint to the compositor that only certain regions of the surface should be rendered.
+	/// This can be used to avoid rendering large empty regions of a window which can increase
+	/// performance, especially if the window is blurred. The mask should include all pixels
+	/// of the window that do not have an alpha value of 0.
+	Q_PROPERTY(PendingRegion* visibleMask READ visibleMask WRITE setVisibleMask NOTIFY visibleMaskChanged);
+	// clang-format on
+	QML_ELEMENT;
+	QML_UNCREATABLE("HyprlandWindow can only be used as an attached object.");
+	QML_ATTACHED(HyprlandWindow);
+
+public:
+	explicit HyprlandWindow(ProxyWindowBase* window);
+
+	[[nodiscard]] static bool available();
+
+	[[nodiscard]] qreal opacity() const;
+	void setOpacity(qreal opacity);
+
+	[[nodiscard]] PendingRegion* visibleMask() const;
+	virtual void setVisibleMask(PendingRegion* mask);
+
+	static HyprlandWindow* qmlAttachedProperties(QObject* object);
+
+signals:
+	void opacityChanged();
+	void visibleMaskChanged();
+
+private slots:
+	void onWindowConnected();
+	void onWindowVisibleChanged();
+	void onWaylandWindowDestroyed();
+	void onWaylandSurfaceCreated();
+	void onWaylandSurfaceDestroyed();
+	void onProxyWindowDestroyed();
+	void onVisibleMaskDestroyed();
+	void onWindowPolished();
+	void updateVisibleMask();
+
+private:
+	void disconnectWaylandWindow();
+
+	ProxyWindowBase* proxyWindow = nullptr;
+	QWindow* mWindow = nullptr;
+	QtWaylandClient::QWaylandWindow* mWaylandWindow = nullptr;
+
+	struct {
+		bool opacity : 1 = false;
+		bool visibleMask : 1 = false;
+	} pendingPolish;
+
+	qreal mOpacity = 1.0;
+	PendingRegion* mVisibleMask = nullptr;
+	std::unique_ptr<impl::HyprlandSurface> surface;
+};
+
+} // namespace qs::hyprland::surface
diff --git a/src/wayland/hyprland/surface/surface.cpp b/src/wayland/hyprland/surface/surface.cpp
new file mode 100644
index 00000000..f49ab8fd
--- /dev/null
+++ b/src/wayland/hyprland/surface/surface.cpp
@@ -0,0 +1,52 @@
+#include "surface.hpp"
+#include <cmath>
+
+#include <private/qwaylanddisplay_p.h>
+#include <private/qwaylandintegration_p.h>
+#include <qlogging.h>
+#include <qregion.h>
+#include <qtypes.h>
+#include <qwayland-hyprland-surface-v1.h>
+#include <wayland-client-protocol.h>
+#include <wayland-hyprland-surface-v1-client-protocol.h>
+#include <wayland-util.h>
+
+namespace qs::hyprland::surface::impl {
+
+HyprlandSurface::HyprlandSurface(
+    ::hyprland_surface_v1* surface,
+    QtWaylandClient::QWaylandWindow* backer
+)
+    : QtWayland::hyprland_surface_v1(surface)
+    , backerSurface(backer->surface()) {}
+
+HyprlandSurface::~HyprlandSurface() { this->destroy(); }
+
+bool HyprlandSurface::surfaceEq(wl_surface* surface) const {
+	return surface == this->backerSurface;
+}
+
+void HyprlandSurface::setOpacity(qreal opacity) {
+	this->set_opacity(wl_fixed_from_double(opacity));
+}
+
+void HyprlandSurface::setVisibleRegion(const QRegion& region) {
+	if (this->version() < HYPRLAND_SURFACE_V1_SET_VISIBLE_REGION_SINCE_VERSION) {
+		qWarning() << "Cannot set hyprland surface visible region: compositor does not support "
+		              "hyprland_surface_v1.set_visible_region";
+		return;
+	}
+
+	if (region.isEmpty()) {
+		this->set_visible_region(nullptr);
+	} else {
+		static const auto* waylandIntegration = QtWaylandClient::QWaylandIntegration::instance();
+		auto* display = waylandIntegration->display();
+
+		auto* wlRegion = display->createRegion(region);
+		this->set_visible_region(wlRegion);
+		wl_region_destroy(wlRegion); // NOLINT(misc-include-cleaner)
+	}
+}
+
+} // namespace qs::hyprland::surface::impl
diff --git a/src/wayland/hyprland/surface/surface.hpp b/src/wayland/hyprland/surface/surface.hpp
new file mode 100644
index 00000000..48a2cda5
--- /dev/null
+++ b/src/wayland/hyprland/surface/surface.hpp
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <private/qwaylandwindow_p.h>
+#include <qobject.h>
+#include <qregion.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qwayland-hyprland-surface-v1.h>
+#include <wayland-client-protocol.h>
+#include <wayland-hyprland-surface-v1-client-protocol.h>
+
+namespace qs::hyprland::surface::impl {
+
+class HyprlandSurface: public QtWayland::hyprland_surface_v1 {
+public:
+	explicit HyprlandSurface(::hyprland_surface_v1* surface, QtWaylandClient::QWaylandWindow* backer);
+	~HyprlandSurface() override;
+	Q_DISABLE_COPY_MOVE(HyprlandSurface);
+
+	[[nodiscard]] bool surfaceEq(wl_surface* surface) const;
+
+	void setOpacity(qreal opacity);
+	void setVisibleRegion(const QRegion& region);
+
+private:
+	wl_surface* backerSurface = nullptr;
+};
+
+} // namespace qs::hyprland::surface::impl
diff --git a/src/wayland/hyprland/test/manual/toplevel-association.qml b/src/wayland/hyprland/test/manual/toplevel-association.qml
new file mode 100644
index 00000000..042b915a
--- /dev/null
+++ b/src/wayland/hyprland/test/manual/toplevel-association.qml
@@ -0,0 +1,37 @@
+import QtQuick
+import QtQuick.Layouts
+import Quickshell
+import Quickshell.Hyprland
+import Quickshell.Wayland
+
+FloatingWindow {
+	ColumnLayout {
+		anchors.fill: parent
+
+		Text { text: "Hyprland -> Wayland" }
+
+		ListView {
+			Layout.fillWidth: true
+			Layout.fillHeight: true
+			clip: true
+			model: Hyprland.toplevels
+			delegate: Text {
+				required property HyprlandToplevel modelData
+				text: `${modelData} -> ${modelData.wayland}`
+			}
+		}
+
+		Text { text: "Wayland -> Hyprland" }
+
+		ListView {
+			Layout.fillWidth: true
+			Layout.fillHeight: true
+			clip: true
+			model: ToplevelManager.toplevels
+			delegate: Text {
+				required property Toplevel modelData
+				text: `${modelData} -> ${modelData.HyprlandToplevel.handle}`
+			}
+		}
+	}
+}
diff --git a/src/wayland/hyprland/test/manual/toplevels.qml b/src/wayland/hyprland/test/manual/toplevels.qml
new file mode 100644
index 00000000..da54e5ce
--- /dev/null
+++ b/src/wayland/hyprland/test/manual/toplevels.qml
@@ -0,0 +1,34 @@
+import QtQuick
+import QtQuick.Layouts
+import Quickshell
+import Quickshell.Hyprland
+
+FloatingWindow {
+	ColumnLayout {
+		anchors.fill: parent
+
+		Text { text: "Current toplevel:" }
+
+		ToplevelFromHyprland {
+			modelData: Hyprland.activeToplevel
+		}
+
+		Text { text: "\nAll toplevels:" }
+
+		ListView {
+			Layout.fillHeight: true
+			Layout.fillWidth: true
+			clip: true
+			model: Hyprland.toplevels
+			delegate: ToplevelFromHyprland {}
+		}
+	}
+
+	component ToplevelFromHyprland: ColumnLayout {
+		required property HyprlandToplevel modelData
+
+		Text {
+			text: `Window 0x${modelData.address}, title: ${modelData.title}, activated: ${modelData.activated}, workspace id: ${modelData.workspace.id}, monitor name: ${modelData.monitor.name}, urgent: ${modelData.urgent}`
+		}
+	}
+}
diff --git a/src/wayland/hyprland/test/manual/workspaces.qml b/src/wayland/hyprland/test/manual/workspaces.qml
new file mode 100644
index 00000000..ef1bafe2
--- /dev/null
+++ b/src/wayland/hyprland/test/manual/workspaces.qml
@@ -0,0 +1,34 @@
+import QtQuick
+import QtQuick.Layouts
+import Quickshell
+import Quickshell.Widgets
+import Quickshell.Hyprland
+
+FloatingWindow {
+	ListView {
+		anchors.fill: parent
+		model: Hyprland.workspaces
+		spacing: 5
+
+		delegate: WrapperRectangle {
+			id: wsDelegate
+			required property HyprlandWorkspace modelData
+			color: "lightgray"
+
+			ColumnLayout {
+				Text { text: `Workspace ${wsDelegate.modelData.id} on ${wsDelegate.modelData.monitor} | urgent: ${wsDelegate.modelData.urgent}`}
+
+				ColumnLayout {
+					Repeater {
+						model: wsDelegate.modelData.toplevels
+						Text {
+							id: tDelegate
+							required property HyprlandToplevel modelData;
+							text: `${tDelegate.modelData}: ${tDelegate.modelData.title}`
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/src/wayland/init.cpp b/src/wayland/init.cpp
index 4a70de8d..e56eee3f 100644
--- a/src/wayland/init.cpp
+++ b/src/wayland/init.cpp
@@ -1,32 +1,55 @@
 #include <qguiapplication.h>
+#include <qlist.h>
+#include <qlogging.h>
 #include <qqml.h>
+#include <qtenvironmentvariables.h>
 
 #include "../core/plugin.hpp"
 
 #ifdef QS_WAYLAND_WLR_LAYERSHELL
-#include "wlr_layershell.hpp"
+#include "wlr_layershell/wlr_layershell.hpp"
 #endif
 
+void installPlatformMenuHook(); // NOLINT(misc-use-internal-linkage)
+void installPopupPositioner();  // NOLINT(misc-use-internal-linkage)
+
 namespace {
 
-class WaylandPlugin: public QuickshellPlugin {
-	bool applies() override { return QGuiApplication::platformName() == "wayland"; }
+class WaylandPlugin: public QsEnginePlugin {
+	QList<QString> dependencies() override { return {"window"}; }
+
+	bool applies() override {
+		auto isWayland = QGuiApplication::platformName() == "wayland";
+
+		if (!isWayland && !qEnvironmentVariable("WAYLAND_DISPLAY").isEmpty()) {
+			qWarning() << "--- WARNING ---";
+			qWarning() << "WAYLAND_DISPLAY is present but QT_QPA_PLATFORM is"
+			           << QGuiApplication::platformName();
+			qWarning() << "If you are actually running wayland, set QT_QPA_PLATFORM to \"wayland\" or "
+			              "most functionality will be broken.";
+		}
+
+		return isWayland;
+	}
+
+	void init() override {
+		installPlatformMenuHook();
+		installPopupPositioner();
+	}
 
 	void registerTypes() override {
 #ifdef QS_WAYLAND_WLR_LAYERSHELL
-		qmlRegisterType<WaylandPanelInterface>("Quickshell._WaylandOverlay", 1, 0, "PanelWindow");
+		qmlRegisterType<qs::wayland::layershell::WaylandPanelInterface>(
+		    "Quickshell._WaylandOverlay",
+		    1,
+		    0,
+		    "PanelWindow"
+		);
 
 		// If any types are defined inside a module using QML_ELEMENT then all QML_ELEMENT types
 		// will not be registered. This can be worked around with a module import which makes
 		// the QML_ELMENT module import the old register-type style module.
 
-		qmlRegisterModuleImport(
-		    "Quickshell.Wayland",
-		    QQmlModuleImportModuleAny,
-		    "Quickshell.Wayland._WlrLayerShell",
-		    QQmlModuleImportLatest
-		);
-
 		qmlRegisterModuleImport(
 		    "Quickshell",
 		    QQmlModuleImportModuleAny,
diff --git a/src/wayland/module.md b/src/wayland/module.md
index 7a427df9..b9f8f594 100644
--- a/src/wayland/module.md
+++ b/src/wayland/module.md
@@ -1,8 +1,9 @@
 name = "Quickshell.Wayland"
 description = "Wayland specific Quickshell types"
 headers = [
-	"wlr_layershell/window.hpp",
-	"wlr_layershell.hpp",
+	"wlr_layershell/wlr_layershell.hpp",
 	"session_lock.hpp",
+	"toplevel_management/qml.hpp",
+	"screencopy/view.hpp",
 ]
 -----
diff --git a/src/wayland/output_tracking.cpp b/src/wayland/output_tracking.cpp
new file mode 100644
index 00000000..9d69ee71
--- /dev/null
+++ b/src/wayland/output_tracking.cpp
@@ -0,0 +1,73 @@
+#include "output_tracking.hpp"
+
+#include <private/qwaylanddisplay_p.h>
+#include <private/qwaylandintegration_p.h>
+#include <private/qwaylandscreen_p.h>
+#include <qguiapplication.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qscreen.h>
+#include <qtmetamacros.h>
+
+namespace qs::wayland {
+
+void WlOutputTracker::addOutput(::wl_output* output) {
+	auto* display = QtWaylandClient::QWaylandIntegration::instance()->display();
+
+	if (auto* platformScreen = display->screenForOutput(output)) {
+		auto* screen = platformScreen->screen();
+		this->mScreens.append(screen);
+		emit this->screenAdded(screen);
+	} else {
+		QObject::connect(
+		    static_cast<QGuiApplication*>(QGuiApplication::instance()), // NOLINT
+		    &QGuiApplication::screenAdded,
+		    this,
+		    &WlOutputTracker::onQScreenAdded,
+		    Qt::UniqueConnection
+		);
+
+		this->mOutputs.append(output);
+	}
+}
+
+void WlOutputTracker::removeOutput(::wl_output* output) {
+	auto* display = QtWaylandClient::QWaylandIntegration::instance()->display();
+
+	if (auto* platformScreen = display->screenForOutput(output)) {
+		auto* screen = platformScreen->screen();
+		this->mScreens.removeOne(screen);
+		emit this->screenRemoved(screen);
+	} else {
+		this->mOutputs.removeOne(output);
+
+		if (this->mOutputs.isEmpty()) {
+			QObject::disconnect(
+			    static_cast<QGuiApplication*>(QGuiApplication::instance()), // NOLINT
+			    nullptr,
+			    this,
+			    nullptr
+			);
+		}
+	}
+}
+
+void WlOutputTracker::onQScreenAdded(QScreen* screen) {
+	if (auto* platformScreen = dynamic_cast<QtWaylandClient::QWaylandScreen*>(screen->handle())) {
+		if (this->mOutputs.removeOne(platformScreen->output())) {
+			this->mScreens.append(screen);
+			emit this->screenAdded(screen);
+
+			if (this->mOutputs.isEmpty()) {
+				QObject::disconnect(
+				    static_cast<QGuiApplication*>(QGuiApplication::instance()), // NOLINT
+				    nullptr,
+				    this,
+				    nullptr
+				);
+			}
+		}
+	}
+}
+
+} // namespace qs::wayland
diff --git a/src/wayland/output_tracking.hpp b/src/wayland/output_tracking.hpp
new file mode 100644
index 00000000..988e53b3
--- /dev/null
+++ b/src/wayland/output_tracking.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <qlist.h>
+#include <qobject.h>
+#include <qscreen.h>
+#include <qtmetamacros.h>
+
+struct wl_output;
+
+namespace qs::wayland {
+
+class WlOutputTracker: public QObject {
+	Q_OBJECT;
+
+public:
+	[[nodiscard]] const QList<QScreen*>& screens() const { return this->mScreens; }
+
+signals:
+	void screenAdded(QScreen* screen);
+	void screenRemoved(QScreen* screen);
+
+public slots:
+	void addOutput(::wl_output* output);
+	void removeOutput(::wl_output* output);
+
+private slots:
+	void onQScreenAdded(QScreen* screen);
+
+private:
+	QList<QScreen*> mScreens;
+	QList<::wl_output*> mOutputs;
+};
+
+} // namespace qs::wayland
diff --git a/src/wayland/platformmenu.cpp b/src/wayland/platformmenu.cpp
new file mode 100644
index 00000000..117d028d
--- /dev/null
+++ b/src/wayland/platformmenu.cpp
@@ -0,0 +1,69 @@
+#include "platformmenu.hpp"
+
+#include <private/qwayland-xdg-shell.h>
+#include <qmargins.h>
+#include <qnamespace.h>
+#include <qsize.h>
+#include <qvariant.h>
+#include <qwindow.h>
+
+#include "../core/platformmenu.hpp"
+#include "../core/platformmenu_p.hpp"
+
+using namespace qs::menu::platform;
+
+namespace {
+
+// fixes positioning of submenus when hitting screen edges
+void platformMenuHook(PlatformMenuQMenu* menu) {
+	auto* window = menu->windowHandle();
+
+	Qt::Edges anchor;
+	Qt::Edges gravity;
+
+	if (auto* containingMenu = menu->containingMenu) {
+		auto geom = containingMenu->actionGeometry(menu->menuAction());
+
+		// Forces action rects to be refreshed. Without this the geometry is intermittently null.
+		containingMenu->sizeHint();
+
+		// use the first action to find the offsets relative to the containing window
+		auto baseGeom = containingMenu->actionGeometry(containingMenu->actions().first());
+		geom += QMargins(0, baseGeom.top(), 0, baseGeom.top());
+
+		window->setProperty("_q_waylandPopupAnchorRect", geom);
+
+		auto sideEdge = menu->isRightToLeft() ? Qt::LeftEdge : Qt::RightEdge;
+		anchor = Qt::TopEdge | sideEdge;
+		gravity = Qt::BottomEdge | sideEdge;
+	} else if (auto* parent = window->transientParent()) {
+		// abort if already set by a PopupAnchor
+		if (window->property("_q_waylandPopupAnchorRect").isValid()) return;
+
+		// The menu geometry will be adjusted to flip internally by qt already, but it ends up off by
+		// one pixel which causes the compositor to also flip which results in the menu being placed
+		// left of the edge by its own width. To work around this the intended position is stored prior
+		// to tampering by qt.
+		auto anchorRect = QRect(menu->targetPosition - parent->geometry().topLeft(), QSize(1, 1));
+		window->setProperty("_q_waylandPopupAnchorRect", anchorRect);
+
+		anchor = Qt::BottomEdge | Qt::RightEdge;
+		gravity = Qt::BottomEdge | Qt::RightEdge;
+	}
+
+	window->setProperty("_q_waylandPopupAnchor", QVariant::fromValue(anchor));
+	window->setProperty("_q_waylandPopupGravity", QVariant::fromValue(gravity));
+
+	auto constraintAdjustment = QtWayland::xdg_positioner::constraint_adjustment_flip_x
+	                          | QtWayland::xdg_positioner::constraint_adjustment_flip_y
+	                          | QtWayland::xdg_positioner::constraint_adjustment_slide_x
+	                          | QtWayland::xdg_positioner::constraint_adjustment_slide_y
+	                          | QtWayland::xdg_positioner::constraint_adjustment_resize_x
+	                          | QtWayland::xdg_positioner::constraint_adjustment_resize_y;
+
+	window->setProperty("_q_waylandPopupConstraintAdjustment", constraintAdjustment);
+}
+
+} // namespace
+
+void installPlatformMenuHook() { PlatformMenuEntry::registerCreationHook(&platformMenuHook); }
diff --git a/src/wayland/platformmenu.hpp b/src/wayland/platformmenu.hpp
new file mode 100644
index 00000000..0362932e
--- /dev/null
+++ b/src/wayland/platformmenu.hpp
@@ -0,0 +1,3 @@
+#pragma once
+
+void installPlatformMenuHook();
diff --git a/src/wayland/popupanchor.cpp b/src/wayland/popupanchor.cpp
new file mode 100644
index 00000000..cbbccae9
--- /dev/null
+++ b/src/wayland/popupanchor.cpp
@@ -0,0 +1,119 @@
+#include "popupanchor.hpp"
+
+#include <private/qhighdpiscaling_p.h>
+#include <private/qwayland-xdg-shell.h>
+#include <private/qwaylandwindow_p.h>
+#include <private/wayland-xdg-shell-client-protocol.h>
+#include <qvariant.h>
+#include <qwindow.h>
+
+#include "../core/popupanchor.hpp"
+#include "../core/types.hpp"
+#include "xdgshell.hpp"
+
+using QtWaylandClient::QWaylandWindow;
+using XdgPositioner = QtWayland::xdg_positioner;
+using qs::wayland::xdg_shell::XdgWmBase;
+
+void WaylandPopupPositioner::reposition(PopupAnchor* anchor, QWindow* window, bool onlyIfDirty) {
+
+	auto* waylandWindow = dynamic_cast<QWaylandWindow*>(window->handle());
+	auto* popupRole = waylandWindow ? waylandWindow->surfaceRole<::xdg_popup>() : nullptr;
+
+	anchor->updateAnchor();
+
+	// If a popup becomes invisble after creation ensure the _q properties will
+	// be set and not ignored because the rest is the same.
+	anchor->updatePlacement({popupRole != nullptr, 0}, window->size());
+
+	if (onlyIfDirty && !anchor->isDirty()) return;
+	anchor->markClean();
+
+	if (popupRole) {
+		auto* xdgWmBase = XdgWmBase::instance();
+
+		if (xdgWmBase->QtWayland::xdg_wm_base::version() < XDG_POPUP_REPOSITION_SINCE_VERSION) {
+			window->setVisible(false);
+			WaylandPopupPositioner::setFlags(anchor, window);
+			window->setVisible(true);
+			return;
+		}
+
+		auto positioner = XdgPositioner(xdgWmBase->create_positioner());
+
+		positioner.set_constraint_adjustment(anchor->adjustment().toInt());
+
+		auto anchorRect = anchor->windowRect();
+
+		if (auto* p = window->transientParent()) {
+			anchorRect = QHighDpi::toNativePixels(anchorRect, p);
+		}
+
+		positioner
+		    .set_anchor_rect(anchorRect.x(), anchorRect.y(), anchorRect.width(), anchorRect.height());
+
+		XdgPositioner::anchor anchorFlag = XdgPositioner::anchor_none;
+		switch (anchor->edges()) {
+		case Edges::Top: anchorFlag = XdgPositioner::anchor_top; break;
+		case Edges::Top | Edges::Right: anchorFlag = XdgPositioner::anchor_top_right; break;
+		case Edges::Right: anchorFlag = XdgPositioner::anchor_right; break;
+		case Edges::Bottom | Edges::Right: anchorFlag = XdgPositioner::anchor_bottom_right; break;
+		case Edges::Bottom: anchorFlag = XdgPositioner::anchor_bottom; break;
+		case Edges::Bottom | Edges::Left: anchorFlag = XdgPositioner::anchor_bottom_left; break;
+		case Edges::Left: anchorFlag = XdgPositioner::anchor_left; break;
+		case Edges::Top | Edges::Left: anchorFlag = XdgPositioner::anchor_top_left; break;
+		default: break;
+		}
+
+		positioner.set_anchor(anchorFlag);
+
+		XdgPositioner::gravity gravity = XdgPositioner::gravity_none;
+		switch (anchor->gravity()) {
+		case Edges::Top: gravity = XdgPositioner::gravity_top; break;
+		case Edges::Top | Edges::Right: gravity = XdgPositioner::gravity_top_right; break;
+		case Edges::Right: gravity = XdgPositioner::gravity_right; break;
+		case Edges::Bottom | Edges::Right: gravity = XdgPositioner::gravity_bottom_right; break;
+		case Edges::Bottom: gravity = XdgPositioner::gravity_bottom; break;
+		case Edges::Bottom | Edges::Left: gravity = XdgPositioner::gravity_bottom_left; break;
+		case Edges::Left: gravity = XdgPositioner::gravity_left; break;
+		case Edges::Top | Edges::Left: gravity = XdgPositioner::gravity_top_left; break;
+		default: break;
+		}
+
+		positioner.set_gravity(gravity);
+		auto geometry = waylandWindow->geometry();
+		positioner.set_size(geometry.width(), geometry.height());
+
+		// Note: this needs to be set for the initial position as well but no compositor
+		// supports it enough to test
+		positioner.set_reactive();
+
+		xdg_popup_reposition(popupRole, positioner.object(), 0);
+
+		positioner.destroy();
+	} else {
+		WaylandPopupPositioner::setFlags(anchor, window);
+	}
+}
+
+// Should be false but nobody supports set_reactive.
+// This just tries its best when something like a bar gets resized.
+bool WaylandPopupPositioner::shouldRepositionOnMove() const { return true; }
+
+void WaylandPopupPositioner::setFlags(PopupAnchor* anchor, QWindow* window) {
+	anchor->updateAnchor();
+	auto anchorRect = anchor->windowRect();
+
+	if (auto* p = window->transientParent()) {
+		anchorRect = QHighDpi::toNativePixels(anchorRect, p);
+	}
+
+	// clang-format off
+	window->setProperty("_q_waylandPopupConstraintAdjustment", anchor->adjustment().toInt());
+	window->setProperty("_q_waylandPopupAnchorRect", anchorRect);
+	window->setProperty("_q_waylandPopupAnchor", QVariant::fromValue(Edges::toQt(anchor->edges())));
+	window->setProperty("_q_waylandPopupGravity", QVariant::fromValue(Edges::toQt(anchor->gravity())));
+	// clang-format on
+}
+
+void installPopupPositioner() { PopupPositioner::setInstance(new WaylandPopupPositioner()); }
diff --git a/src/wayland/popupanchor.hpp b/src/wayland/popupanchor.hpp
new file mode 100644
index 00000000..3e84e4b8
--- /dev/null
+++ b/src/wayland/popupanchor.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <qwindow.h>
+
+#include "../core/popupanchor.hpp"
+
+class WaylandPopupPositioner: public PopupPositioner {
+public:
+	void reposition(PopupAnchor* anchor, QWindow* window, bool onlyIfDirty = true) override;
+	[[nodiscard]] bool shouldRepositionOnMove() const override;
+
+private:
+	static void setFlags(PopupAnchor* anchor, QWindow* window);
+};
+
+void installPopupPositioner();
diff --git a/src/wayland/screencopy/CMakeLists.txt b/src/wayland/screencopy/CMakeLists.txt
new file mode 100644
index 00000000..97c4209e
--- /dev/null
+++ b/src/wayland/screencopy/CMakeLists.txt
@@ -0,0 +1,42 @@
+qt_add_library(quickshell-wayland-screencopy STATIC
+	manager.cpp
+	view.cpp
+)
+
+qt_add_qml_module(quickshell-wayland-screencopy
+	URI Quickshell.Wayland._Screencopy
+	VERSION 0.1
+	DEPENDENCIES QtQuick
+)
+
+install_qml_module(quickshell-wayland-screencopy)
+
+set(SCREENCOPY_MODULES)
+
+if (SCREENCOPY_ICC)
+	add_subdirectory(image_copy_capture)
+	list(APPEND SCREENCOPY_MODULES quickshell-wayland-screencopy-icc)
+endif()
+
+if (SCREENCOPY_WLR)
+	add_subdirectory(wlr_screencopy)
+	list(APPEND SCREENCOPY_MODULES quickshell-wayland-screencopy-wlr)
+endif()
+
+if (SCREENCOPY_HYPRLAND_TOPLEVEL)
+	add_subdirectory(hyprland_screencopy)
+	list(APPEND SCREENCOPY_MODULES quickshell-wayland-screencopy-hyprland)
+endif()
+
+configure_file(build.hpp.in build.hpp @ONLY)
+target_include_directories(quickshell-wayland-screencopy PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+
+target_link_libraries(quickshell-wayland-screencopy PRIVATE
+	Qt::Quick Qt::WaylandClient Qt::WaylandClientPrivate wayland-client
+	quickshell-wayland-buffer
+	${SCREENCOPY_MODULES}
+)
+
+qs_module_pch(quickshell-wayland-screencopy SET large)
+
+target_link_libraries(quickshell PRIVATE quickshell-wayland-screencopyplugin)
diff --git a/src/wayland/screencopy/build.hpp.in b/src/wayland/screencopy/build.hpp.in
new file mode 100644
index 00000000..9276daaa
--- /dev/null
+++ b/src/wayland/screencopy/build.hpp.in
@@ -0,0 +1,6 @@
+#pragma once
+// NOLINTBEGIN
+#cmakedefine01 SCREENCOPY_ICC
+#cmakedefine01 SCREENCOPY_WLR
+#cmakedefine01 SCREENCOPY_HYPRLAND_TOPLEVEL
+// NOLINTEND
diff --git a/src/wayland/screencopy/hyprland_screencopy/CMakeLists.txt b/src/wayland/screencopy/hyprland_screencopy/CMakeLists.txt
new file mode 100644
index 00000000..d06a91e5
--- /dev/null
+++ b/src/wayland/screencopy/hyprland_screencopy/CMakeLists.txt
@@ -0,0 +1,16 @@
+qt_add_library(quickshell-wayland-screencopy-hyprland STATIC
+	hyprland_screencopy.cpp
+)
+
+wl_proto(wlp-hyprland-screencopy hyprland-toplevel-export-v1 "${CMAKE_CURRENT_SOURCE_DIR}")
+
+target_link_libraries(quickshell-wayland-screencopy-hyprland PRIVATE
+	Qt::WaylandClient Qt::WaylandClientPrivate wayland-client
+	Qt::Quick # for pch
+)
+
+target_link_libraries(quickshell-wayland-screencopy-hyprland PUBLIC
+	wlp-hyprland-screencopy wlp-foreign-toplevel
+)
+
+qs_pch(quickshell-wayland-screencopy-hyprland SET large)
diff --git a/src/wayland/screencopy/hyprland_screencopy/hyprland-toplevel-export-v1.xml b/src/wayland/screencopy/hyprland_screencopy/hyprland-toplevel-export-v1.xml
new file mode 100644
index 00000000..b1185aa5
--- /dev/null
+++ b/src/wayland/screencopy/hyprland_screencopy/hyprland-toplevel-export-v1.xml
@@ -0,0 +1,228 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="hyprland_toplevel_export_v1">
+  <copyright>
+    Copyright © 2022 Vaxry
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this
+       list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright notice,
+       this list of conditions and the following disclaimer in the documentation
+       and/or other materials provided with the distribution.
+
+    3. Neither the name of the copyright holder nor the names of its
+       contributors may be used to endorse or promote products derived from
+       this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  </copyright>
+
+  <description summary="capturing the contents of toplevel windows">
+    This protocol allows clients to ask for exporting another toplevel's
+    surface(s) to a buffer.
+
+    Particularly useful for sharing a single window.
+  </description>
+
+  <interface name="hyprland_toplevel_export_manager_v1" version="2">
+    <description summary="manager to inform clients and begin capturing">
+      This object is a manager which offers requests to start capturing from a
+      source.
+    </description>
+
+    <request name="capture_toplevel">
+      <description summary="capture a toplevel">
+        Capture the next frame of a toplevel. (window)
+
+        The captured frame will not contain any server-side decorations and will
+        ignore the compositor-set geometry, like e.g. rounded corners.
+
+        It will contain all the subsurfaces and popups, however the latter will be clipped
+        to the geometry of the base surface.
+
+        The handle parameter refers to the address of the window as seen in `hyprctl clients`.
+        For example, for d161e7b0 it would be 3512854448.
+      </description>
+      <arg name="frame" type="new_id" interface="hyprland_toplevel_export_frame_v1"/>
+      <arg name="overlay_cursor" type="int"
+        summary="composite cursor onto the frame"/>
+      <arg name="handle" type="uint" summary="the handle of the toplevel (window) to be captured"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the manager">
+        All objects created by the manager will still remain valid, until their
+        appropriate destroy request has been called.
+      </description>
+    </request>
+
+    <!-- Version 2 -->
+    <request name="capture_toplevel_with_wlr_toplevel_handle" since="2">
+      <description summary="capture a toplevel">
+        Same as capture_toplevel, but with a zwlr_foreign_toplevel_handle_v1 handle.
+      </description>
+      <arg name="frame" type="new_id" interface="hyprland_toplevel_export_frame_v1"/>
+      <arg name="overlay_cursor" type="int"
+        summary="composite cursor onto the frame"/>
+      <arg name="handle" type="object" interface="zwlr_foreign_toplevel_handle_v1" allow-null="false" summary="the zwlr_foreign_toplevel_handle_v1 handle of the toplevel to be captured"/>
+    </request>
+    <!-- End Version 2 -->
+  </interface>
+
+  <interface name="hyprland_toplevel_export_frame_v1" version="2">
+    <description summary="a frame ready for copy">
+      This object represents a single frame.
+
+      When created, a series of buffer events will be sent, each representing a
+      supported buffer type. The "buffer_done" event is sent afterwards to
+      indicate that all supported buffer types have been enumerated. The client
+      will then be able to send a "copy" request. If the capture is successful,
+      the compositor will send a "flags" followed by a "ready" event.
+
+      wl_shm buffers are always supported, ie. the "buffer" event is guaranteed to be sent.
+
+      If the capture failed, the "failed" event is sent. This can happen anytime
+      before the "ready" event.
+
+      Once either a "ready" or a "failed" event is received, the client should
+      destroy the frame.
+    </description>
+
+    <event name="buffer">
+      <description summary="wl_shm buffer information">
+        Provides information about wl_shm buffer parameters that need to be
+        used for this frame. This event is sent once after the frame is created
+        if wl_shm buffers are supported.
+      </description>
+      <arg name="format" type="uint" enum="wl_shm.format" summary="buffer format"/>
+      <arg name="width" type="uint" summary="buffer width"/>
+      <arg name="height" type="uint" summary="buffer height"/>
+      <arg name="stride" type="uint" summary="buffer stride"/>
+    </event>
+
+    <request name="copy">
+      <description summary="copy the frame">
+        Copy the frame to the supplied buffer. The buffer must have the
+        correct size, see hyprland_toplevel_export_frame_v1.buffer and
+        hyprland_toplevel_export_frame_v1.linux_dmabuf. The buffer needs to have a
+        supported format.
+
+        If the frame is successfully copied, a "flags" and a "ready" event is
+        sent. Otherwise, a "failed" event is sent.
+
+        This event will wait for appropriate damage to be copied, unless the ignore_damage
+        arg is set to a non-zero value.
+      </description>
+      <arg name="buffer" type="object" interface="wl_buffer"/>
+      <arg name="ignore_damage" type="int"/>
+    </request>
+
+    <event name="damage">
+      <description summary="carries the coordinates of the damaged region">
+        This event is sent right before the ready event when ignore_damage was
+        not set. It may be generated multiple times for each copy
+        request.
+
+        The arguments describe a box around an area that has changed since the
+        last copy request that was derived from the current screencopy manager
+        instance.
+
+        The union of all regions received between the call to copy
+        and a ready event is the total damage since the prior ready event.
+      </description>
+      <arg name="x" type="uint" summary="damaged x coordinates"/>
+      <arg name="y" type="uint" summary="damaged y coordinates"/>
+      <arg name="width" type="uint" summary="current width"/>
+      <arg name="height" type="uint" summary="current height"/>
+    </event>
+
+    <enum name="error">
+      <entry name="already_used" value="0"
+        summary="the object has already been used to copy a wl_buffer"/>
+      <entry name="invalid_buffer" value="1"
+        summary="buffer attributes are invalid"/>
+    </enum>
+
+    <enum name="flags" bitfield="true">
+      <entry name="y_invert" value="1" summary="contents are y-inverted"/>
+    </enum>
+
+    <event name="flags">
+      <description summary="frame flags">
+        Provides flags about the frame. This event is sent once before the
+        "ready" event.
+      </description>
+      <arg name="flags" type="uint" enum="flags" summary="frame flags"/>
+    </event>
+
+    <event name="ready">
+      <description summary="indicates frame is available for reading">
+        Called as soon as the frame is copied, indicating it is available
+        for reading. This event includes the time at which presentation happened
+        at.
+
+        The timestamp is expressed as tv_sec_hi, tv_sec_lo, tv_nsec triples,
+        each component being an unsigned 32-bit value. Whole seconds are in
+        tv_sec which is a 64-bit value combined from tv_sec_hi and tv_sec_lo,
+        and the additional fractional part in tv_nsec as nanoseconds. Hence,
+        for valid timestamps tv_nsec must be in [0, 999999999]. The seconds part
+        may have an arbitrary offset at start.
+
+        After receiving this event, the client should destroy the object.
+      </description>
+      <arg name="tv_sec_hi" type="uint"
+           summary="high 32 bits of the seconds part of the timestamp"/>
+      <arg name="tv_sec_lo" type="uint"
+           summary="low 32 bits of the seconds part of the timestamp"/>
+      <arg name="tv_nsec" type="uint"
+           summary="nanoseconds part of the timestamp"/>
+    </event>
+
+    <event name="failed">
+      <description summary="frame copy failed">
+        This event indicates that the attempted frame copy has failed.
+
+        After receiving this event, the client should destroy the object.
+      </description>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="delete this object, used or not">
+        Destroys the frame. This request can be sent at any time by the client.
+      </description>
+    </request>
+
+    <event name="linux_dmabuf">
+      <description summary="linux-dmabuf buffer information">
+        Provides information about linux-dmabuf buffer parameters that need to
+        be used for this frame. This event is sent once after the frame is
+        created if linux-dmabuf buffers are supported.
+      </description>
+      <arg name="format" type="uint" summary="fourcc pixel format"/>
+      <arg name="width" type="uint" summary="buffer width"/>
+      <arg name="height" type="uint" summary="buffer height"/>
+    </event>
+
+    <event name="buffer_done">
+      <description summary="all buffer types reported">
+        This event is sent once after all buffer events have been sent.
+
+        The client should proceed to create a buffer of one of the supported
+        types, and send a "copy" request.
+      </description>
+    </event>
+  </interface>
+</protocol>
diff --git a/src/wayland/screencopy/hyprland_screencopy/hyprland_screencopy.cpp b/src/wayland/screencopy/hyprland_screencopy/hyprland_screencopy.cpp
new file mode 100644
index 00000000..6fc29558
--- /dev/null
+++ b/src/wayland/screencopy/hyprland_screencopy/hyprland_screencopy.cpp
@@ -0,0 +1,135 @@
+#include "hyprland_screencopy.hpp"
+#include <cstdint>
+
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qwaylandclientextension.h>
+#include <wayland-hyprland-toplevel-export-v1-client-protocol.h>
+
+#include "../../../core/logcat.hpp"
+#include "../../toplevel_management/handle.hpp"
+#include "../manager.hpp"
+#include "hyprland_screencopy_p.hpp"
+
+namespace qs::wayland::screencopy::hyprland {
+
+namespace {
+QS_LOGGING_CATEGORY(logScreencopy, "quickshell.wayland.screencopy.hyprland", QtWarningMsg);
+}
+
+HyprlandScreencopyManager::HyprlandScreencopyManager(): QWaylandClientExtensionTemplate(2) {
+	this->initialize();
+}
+
+HyprlandScreencopyManager* HyprlandScreencopyManager::instance() {
+	static auto* instance = new HyprlandScreencopyManager();
+	return instance;
+}
+
+ScreencopyContext* HyprlandScreencopyManager::captureToplevel(
+    toplevel_management::impl::ToplevelHandle* handle,
+    bool paintCursors
+) {
+	return new HyprlandScreencopyContext(this, handle, paintCursors);
+}
+
+HyprlandScreencopyContext::HyprlandScreencopyContext(
+    HyprlandScreencopyManager* manager,
+    toplevel_management::impl::ToplevelHandle* handle,
+    bool paintCursors
+)
+    : manager(manager)
+    , handle(handle)
+    , paintCursors(paintCursors) {
+	QObject::connect(
+	    handle,
+	    &QObject::destroyed,
+	    this,
+	    &HyprlandScreencopyContext::onToplevelDestroyed
+	);
+}
+
+HyprlandScreencopyContext::~HyprlandScreencopyContext() {
+	if (this->object()) this->destroy();
+}
+
+void HyprlandScreencopyContext::onToplevelDestroyed() {
+	qCWarning(logScreencopy) << "Toplevel destroyed while recording. Stopping" << this;
+	if (this->object()) this->destroy();
+	emit this->stopped();
+}
+
+void HyprlandScreencopyContext::captureFrame() {
+	if (this->object()) return;
+
+	this->request.reset();
+
+	this->init(this->manager->capture_toplevel_with_wlr_toplevel_handle(
+	    this->paintCursors ? 1 : 0,
+	    this->handle->object()
+	));
+}
+
+void HyprlandScreencopyContext::hyprland_toplevel_export_frame_v1_buffer(
+    uint32_t format,
+    uint32_t width,
+    uint32_t height,
+    uint32_t /*stride*/
+) {
+	// While different sizes can technically be requested, that would be insane.
+	this->request.width = width;
+	this->request.height = height;
+	this->request.shm.formats.push(format);
+}
+
+void HyprlandScreencopyContext::hyprland_toplevel_export_frame_v1_linux_dmabuf(
+    uint32_t format,
+    uint32_t width,
+    uint32_t height
+) {
+	// While different sizes can technically be requested, that would be insane.
+	this->request.width = width;
+	this->request.height = height;
+	this->request.dmabuf.formats.push(format);
+}
+
+void HyprlandScreencopyContext::hyprland_toplevel_export_frame_v1_flags(uint32_t flags) {
+	if (flags & HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_FLAGS_Y_INVERT) {
+		this->mSwapchain.backbuffer()->transform = buffer::WlBufferTransform::Flipped180;
+	}
+}
+
+void HyprlandScreencopyContext::hyprland_toplevel_export_frame_v1_buffer_done() {
+	auto* backbuffer = this->mSwapchain.createBackbuffer(this->request);
+
+	if (!backbuffer || !backbuffer->buffer()) {
+		qCWarning(logScreencopy) << "Backbuffer creation failed for screencopy. Skipping frame.";
+
+		// Try again. This will be spammy if the compositor continuously sends bad frames.
+		this->destroy();
+		this->captureFrame();
+		return;
+	}
+
+	this->copy(backbuffer->buffer(), this->copiedFirstFrame ? 0 : 1);
+}
+
+void HyprlandScreencopyContext::hyprland_toplevel_export_frame_v1_ready(
+    uint32_t /*tvSecHi*/,
+    uint32_t /*tvSecLo*/,
+    uint32_t /*tvNsec*/
+) {
+	this->destroy();
+	this->copiedFirstFrame = true;
+	this->mSwapchain.swapBuffers();
+	emit this->frameCaptured();
+}
+
+void HyprlandScreencopyContext::hyprland_toplevel_export_frame_v1_failed() {
+	qCWarning(logScreencopy) << "Ending recording due to screencopy failure for" << this;
+	emit this->stopped();
+}
+
+} // namespace qs::wayland::screencopy::hyprland
diff --git a/src/wayland/screencopy/hyprland_screencopy/hyprland_screencopy.hpp b/src/wayland/screencopy/hyprland_screencopy/hyprland_screencopy.hpp
new file mode 100644
index 00000000..fbd08c54
--- /dev/null
+++ b/src/wayland/screencopy/hyprland_screencopy/hyprland_screencopy.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <qwayland-hyprland-toplevel-export-v1.h>
+#include <qwaylandclientextension.h>
+
+#include "../../toplevel_management/handle.hpp"
+#include "../manager.hpp"
+
+namespace qs::wayland::screencopy::hyprland {
+
+class HyprlandScreencopyManager
+    : public QWaylandClientExtensionTemplate<HyprlandScreencopyManager>
+    , public QtWayland::hyprland_toplevel_export_manager_v1 {
+public:
+	ScreencopyContext*
+	captureToplevel(toplevel_management::impl::ToplevelHandle* handle, bool paintCursors);
+
+	static HyprlandScreencopyManager* instance();
+
+private:
+	explicit HyprlandScreencopyManager();
+
+	friend class HyprlandScreencopyContext;
+};
+
+} // namespace qs::wayland::screencopy::hyprland
diff --git a/src/wayland/screencopy/hyprland_screencopy/hyprland_screencopy_p.hpp b/src/wayland/screencopy/hyprland_screencopy/hyprland_screencopy_p.hpp
new file mode 100644
index 00000000..199390ec
--- /dev/null
+++ b/src/wayland/screencopy/hyprland_screencopy/hyprland_screencopy_p.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <qtclasshelpermacros.h>
+#include <qwayland-hyprland-toplevel-export-v1.h>
+
+#include "../../toplevel_management/handle.hpp"
+#include "../manager.hpp"
+
+namespace qs::wayland::screencopy::hyprland {
+
+class HyprlandScreencopyManager;
+
+class HyprlandScreencopyContext
+    : public ScreencopyContext
+    , public QtWayland::hyprland_toplevel_export_frame_v1 {
+public:
+	explicit HyprlandScreencopyContext(
+	    HyprlandScreencopyManager* manager,
+	    toplevel_management::impl::ToplevelHandle* handle,
+	    bool paintCursors
+	);
+
+	~HyprlandScreencopyContext() override;
+	Q_DISABLE_COPY_MOVE(HyprlandScreencopyContext);
+
+	void captureFrame() override;
+
+protected:
+	// clang-format off
+	void hyprland_toplevel_export_frame_v1_buffer(uint32_t format, uint32_t width, uint32_t height, uint32_t stride) override;
+	void hyprland_toplevel_export_frame_v1_linux_dmabuf(uint32_t format, uint32_t width, uint32_t height) override;
+	void hyprland_toplevel_export_frame_v1_flags(uint32_t flags) override;
+	void hyprland_toplevel_export_frame_v1_buffer_done() override;
+	void hyprland_toplevel_export_frame_v1_ready(uint32_t tvSecHi, uint32_t tvSecLo, uint32_t tvNsec) override;
+	void hyprland_toplevel_export_frame_v1_failed() override;
+	// clang-format on
+
+private slots:
+	void onToplevelDestroyed();
+
+private:
+	HyprlandScreencopyManager* manager;
+	buffer::WlBufferRequest request;
+	bool copiedFirstFrame = false;
+
+	toplevel_management::impl::ToplevelHandle* handle;
+	bool paintCursors;
+};
+
+} // namespace qs::wayland::screencopy::hyprland
diff --git a/src/wayland/screencopy/image_copy_capture/CMakeLists.txt b/src/wayland/screencopy/image_copy_capture/CMakeLists.txt
new file mode 100644
index 00000000..954fdda3
--- /dev/null
+++ b/src/wayland/screencopy/image_copy_capture/CMakeLists.txt
@@ -0,0 +1,19 @@
+qt_add_library(quickshell-wayland-screencopy-icc STATIC
+	image_copy_capture.cpp
+)
+
+wl_proto(wlp-ext-foreign-toplevel ext-foreign-toplevel-list-v1 "${WAYLAND_PROTOCOLS}/staging/ext-foreign-toplevel-list")
+wl_proto(wlp-image-copy-capture ext-image-copy-capture-v1 "${WAYLAND_PROTOCOLS}/staging/ext-image-copy-capture")
+wl_proto(wlp-image-capture-source ext-image-capture-source-v1 "${WAYLAND_PROTOCOLS}/staging/ext-image-capture-source")
+
+target_link_libraries(quickshell-wayland-screencopy-icc PRIVATE
+	Qt::WaylandClient Qt::WaylandClientPrivate wayland-client
+	Qt::Quick # for pch
+)
+
+target_link_libraries(quickshell-wayland-screencopy-icc PUBLIC
+	wlp-image-copy-capture wlp-image-capture-source
+	wlp-ext-foreign-toplevel # required for capture source to build
+)
+
+qs_pch(quickshell-wayland-screencopy-icc SET large)
diff --git a/src/wayland/screencopy/image_copy_capture/image_copy_capture.cpp b/src/wayland/screencopy/image_copy_capture/image_copy_capture.cpp
new file mode 100644
index 00000000..13d1bc6d
--- /dev/null
+++ b/src/wayland/screencopy/image_copy_capture/image_copy_capture.cpp
@@ -0,0 +1,232 @@
+#include "image_copy_capture.hpp"
+#include <cstdint>
+
+#include <private/qwaylandscreen_p.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qrect.h>
+#include <qscreen.h>
+#include <qtmetamacros.h>
+#include <qwayland-ext-image-copy-capture-v1.h>
+#include <qwaylandclientextension.h>
+#include <sys/types.h>
+#include <wayland-ext-image-copy-capture-v1-client-protocol.h>
+#include <wayland-util.h>
+
+#include "../../../core/logcat.hpp"
+#include "../manager.hpp"
+#include "image_copy_capture_p.hpp"
+
+namespace qs::wayland::screencopy::icc {
+
+namespace {
+QS_LOGGING_CATEGORY(logIcc, "quickshell.wayland.screencopy.icc", QtWarningMsg);
+}
+
+using IccCaptureSession = QtWayland::ext_image_copy_capture_session_v1;
+using IccCaptureFrame = QtWayland::ext_image_copy_capture_frame_v1;
+
+IccScreencopyContext::IccScreencopyContext(::ext_image_copy_capture_session_v1* session)
+    : IccCaptureSession(session) {}
+
+IccScreencopyContext::~IccScreencopyContext() {
+	if (this->IccCaptureSession::object()) {
+		this->IccCaptureSession::destroy();
+	}
+
+	if (this->IccCaptureFrame::object()) {
+		this->IccCaptureFrame::destroy();
+	}
+}
+
+void IccScreencopyContext::captureFrame() {
+	if (this->IccCaptureFrame::object() || this->capturePending) return;
+
+	if (this->statePending) this->capturePending = true;
+	else this->doCapture();
+}
+
+void IccScreencopyContext::ext_image_copy_capture_session_v1_buffer_size(
+    uint32_t width,
+    uint32_t height
+) {
+	this->clearOldState();
+
+	this->request.width = width;
+	this->request.height = height;
+}
+
+void IccScreencopyContext::ext_image_copy_capture_session_v1_shm_format(uint32_t format) {
+	this->clearOldState();
+
+	this->request.shm.formats.push(format);
+}
+
+void IccScreencopyContext::ext_image_copy_capture_session_v1_dmabuf_device(wl_array* device) {
+	this->clearOldState();
+
+	if (device->size != sizeof(dev_t)) {
+		qCFatal(logIcc) << "The size of dev_t used by the compositor and quickshell is mismatched. Try "
+		                   "recompiling both.";
+	}
+
+	this->request.dmabuf.device = *reinterpret_cast<dev_t*>(device->data);
+}
+
+void IccScreencopyContext::ext_image_copy_capture_session_v1_dmabuf_format(
+    uint32_t format,
+    wl_array* modifiers
+) {
+	this->clearOldState();
+
+	auto* modifierArray = reinterpret_cast<uint64_t*>(modifiers->data);
+	auto modifierCount = modifiers->size / sizeof(uint64_t);
+
+	auto reqFormat = buffer::WlBufferRequest::DmaFormat(format);
+
+	for (uint16_t i = 0; i != modifierCount; i++) {
+		reqFormat.modifiers.push(modifierArray[i]); // NOLINT
+	}
+
+	this->request.dmabuf.formats.push(reqFormat);
+}
+
+void IccScreencopyContext::ext_image_copy_capture_session_v1_done() {
+	this->statePending = false;
+
+	if (this->capturePending) {
+		this->doCapture();
+	}
+}
+
+void IccScreencopyContext::ext_image_copy_capture_session_v1_stopped() {
+	qCInfo(logIcc) << "Ending recording due to screencopy stop for" << this;
+	emit this->stopped();
+}
+
+void IccScreencopyContext::clearOldState() {
+	if (!this->statePending) {
+		this->request = buffer::WlBufferRequest();
+		this->statePending = true;
+	}
+}
+
+void IccScreencopyContext::doCapture() {
+	this->capturePending = false;
+
+	auto newBuffer = false;
+	auto* backbuffer = this->mSwapchain.createBackbuffer(this->request, &newBuffer);
+
+	if (!backbuffer || !backbuffer->buffer()) {
+		qCWarning(logIcc) << "Backbuffer creation failed for screencopy. Waiting for updated buffer "
+		                     "creation parameters before trying again.";
+		return;
+	}
+
+	this->IccCaptureFrame::init(this->IccCaptureSession::create_frame());
+	this->IccCaptureFrame::attach_buffer(backbuffer->buffer());
+
+	if (newBuffer) {
+		// If the buffer was replaced, it will be blank and the compositor needs
+		// to repaint the whole thing.
+		this->IccCaptureFrame::damage_buffer(
+		    0,
+		    0,
+		    static_cast<int>(this->request.width),
+		    static_cast<int>(this->request.height)
+		);
+
+		// We don't care about partial damage if the whole buffer was replaced.
+		this->lastDamage = QRect();
+	} else if (!this->lastDamage.isEmpty()) {
+		// If buffers were swapped between the last frame and the current one, request a repaint
+		// of the backbuffer in the same places that changes to the frontbuffer were recorded.
+		this->IccCaptureFrame::damage_buffer(
+		    this->lastDamage.x(),
+		    this->lastDamage.y(),
+		    this->lastDamage.width(),
+		    this->lastDamage.height()
+		);
+
+		// We don't need to do this more than once per buffer swap.
+		this->lastDamage = QRect();
+	}
+
+	this->IccCaptureFrame::capture();
+}
+
+void IccScreencopyContext::ext_image_copy_capture_frame_v1_transform(uint32_t transform) {
+	this->mSwapchain.backbuffer()->transform = transform;
+}
+
+void IccScreencopyContext::ext_image_copy_capture_frame_v1_damage(
+    int32_t x,
+    int32_t y,
+    int32_t width,
+    int32_t height
+) {
+	this->damage = this->damage.united(QRect(x, y, width, height));
+}
+
+void IccScreencopyContext::ext_image_copy_capture_frame_v1_ready() {
+	this->IccCaptureFrame::destroy();
+
+	this->mSwapchain.swapBuffers();
+	this->lastDamage = this->damage;
+	this->damage = QRect();
+
+	emit this->frameCaptured();
+}
+
+void IccScreencopyContext::ext_image_copy_capture_frame_v1_failed(uint32_t reason) {
+	switch (static_cast<IccCaptureFrame::failure_reason>(reason)) {
+	case IccCaptureFrame::failure_reason_buffer_constraints:
+		qFatal(logIcc) << "Got a buffer_constraints failure, however the buffer matches the last sent "
+		                  "size. There is a bug in quickshell or your compositor.";
+		break;
+	case IccCaptureFrame::failure_reason_stopped:
+		// Handled in the ExtCaptureSession handler.
+		break;
+	case IccCaptureFrame::failure_reason_unknown:
+		qCWarning(logIcc) << "Ending recording due to screencopy failure for" << this;
+		emit this->stopped();
+		break;
+	}
+}
+
+IccManager::IccManager(): QWaylandClientExtensionTemplate(1) { this->initialize(); }
+
+IccManager* IccManager::instance() {
+	static auto* instance = new IccManager();
+	return instance;
+}
+
+ScreencopyContext*
+IccManager::createSession(::ext_image_capture_source_v1* source, bool paintCursors) {
+	auto* session = this->create_session(
+	    source,
+	    paintCursors ? QtWayland::ext_image_copy_capture_manager_v1::options_paint_cursors : 0
+	);
+	return new IccScreencopyContext(session);
+}
+
+IccOutputSourceManager::IccOutputSourceManager(): QWaylandClientExtensionTemplate(1) {
+	this->initialize();
+}
+
+IccOutputSourceManager* IccOutputSourceManager::instance() {
+	static auto* instance = new IccOutputSourceManager();
+	return instance;
+}
+
+ScreencopyContext* IccOutputSourceManager::captureOutput(QScreen* screen, bool paintCursors) {
+	auto* waylandScreen = dynamic_cast<QtWaylandClient::QWaylandScreen*>(screen->handle());
+	if (!waylandScreen) return nullptr;
+
+	return IccManager::instance()->createSession(
+	    this->create_source(waylandScreen->output()),
+	    paintCursors
+	);
+}
+
+} // namespace qs::wayland::screencopy::icc
diff --git a/src/wayland/screencopy/image_copy_capture/image_copy_capture.hpp b/src/wayland/screencopy/image_copy_capture/image_copy_capture.hpp
new file mode 100644
index 00000000..93ba36c3
--- /dev/null
+++ b/src/wayland/screencopy/image_copy_capture/image_copy_capture.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <qscreen.h>
+#include <qwayland-ext-image-capture-source-v1.h>
+#include <qwayland-ext-image-copy-capture-v1.h>
+#include <qwaylandclientextension.h>
+
+#include "../manager.hpp"
+
+namespace qs::wayland::screencopy::icc {
+
+class IccManager
+    : public QWaylandClientExtensionTemplate<IccManager>
+    , public QtWayland::ext_image_copy_capture_manager_v1 {
+public:
+	ScreencopyContext* createSession(::ext_image_capture_source_v1* source, bool paintCursors);
+
+	static IccManager* instance();
+
+private:
+	explicit IccManager();
+};
+
+class IccOutputSourceManager
+    : public QWaylandClientExtensionTemplate<IccOutputSourceManager>
+    , public QtWayland::ext_output_image_capture_source_manager_v1 {
+public:
+	ScreencopyContext* captureOutput(QScreen* screen, bool paintCursors);
+
+	static IccOutputSourceManager* instance();
+
+private:
+	explicit IccOutputSourceManager();
+};
+
+} // namespace qs::wayland::screencopy::icc
diff --git a/src/wayland/screencopy/image_copy_capture/image_copy_capture_p.hpp b/src/wayland/screencopy/image_copy_capture/image_copy_capture_p.hpp
new file mode 100644
index 00000000..e89af4a5
--- /dev/null
+++ b/src/wayland/screencopy/image_copy_capture/image_copy_capture_p.hpp
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <cstdint>
+
+#include <qrect.h>
+#include <qtclasshelpermacros.h>
+#include <qwayland-ext-image-copy-capture-v1.h>
+
+#include "../manager.hpp"
+
+namespace qs::wayland::screencopy::icc {
+
+class IccScreencopyContext
+    : public ScreencopyContext
+    , public QtWayland::ext_image_copy_capture_session_v1
+    , public QtWayland::ext_image_copy_capture_frame_v1 {
+
+public:
+	IccScreencopyContext(::ext_image_copy_capture_session_v1* session);
+	~IccScreencopyContext() override;
+	Q_DISABLE_COPY_MOVE(IccScreencopyContext);
+
+	void captureFrame() override;
+
+protected:
+	// clang-format off
+	void ext_image_copy_capture_session_v1_buffer_size(uint32_t width, uint32_t height) override;
+	void ext_image_copy_capture_session_v1_shm_format(uint32_t format) override;
+	void ext_image_copy_capture_session_v1_dmabuf_device(wl_array* device) override;
+	void ext_image_copy_capture_session_v1_dmabuf_format(uint32_t format, wl_array* modifiers) override;
+	void ext_image_copy_capture_session_v1_done() override;
+	void ext_image_copy_capture_session_v1_stopped() override;
+
+	void ext_image_copy_capture_frame_v1_transform(uint32_t transform) override;
+	void ext_image_copy_capture_frame_v1_damage(int32_t x, int32_t y, int32_t width, int32_t height) override;
+	void ext_image_copy_capture_frame_v1_ready() override;
+	void ext_image_copy_capture_frame_v1_failed(uint32_t reason) override;
+	// clang-format on
+
+private:
+	void clearOldState();
+	void doCapture();
+
+	buffer::WlBufferRequest request;
+	bool statePending = true;
+	bool capturePending = false;
+	QRect damage;
+	QRect lastDamage;
+};
+
+} // namespace qs::wayland::screencopy::icc
diff --git a/src/wayland/screencopy/manager.cpp b/src/wayland/screencopy/manager.cpp
new file mode 100644
index 00000000..8345e314
--- /dev/null
+++ b/src/wayland/screencopy/manager.cpp
@@ -0,0 +1,56 @@
+#include "manager.hpp"
+
+#include <qobject.h>
+
+#include "build.hpp"
+
+#if SCREENCOPY_ICC || SCREENCOPY_WLR
+#include "../../core/qmlscreen.hpp"
+#endif
+
+#if SCREENCOPY_ICC
+#include "image_copy_capture/image_copy_capture.hpp"
+#endif
+
+#if SCREENCOPY_WLR
+#include "wlr_screencopy/wlr_screencopy.hpp"
+#endif
+
+#if SCREENCOPY_HYPRLAND_TOPLEVEL
+#include "../toplevel_management/qml.hpp"
+#include "hyprland_screencopy/hyprland_screencopy.hpp"
+#endif
+
+namespace qs::wayland::screencopy {
+
+ScreencopyContext* ScreencopyManager::createContext(QObject* object, bool paintCursors) {
+	if (auto* screen = qobject_cast<QuickshellScreenInfo*>(object)) {
+#if SCREENCOPY_ICC
+		{
+			auto* manager = icc::IccOutputSourceManager::instance();
+			if (manager->isActive()) {
+				return manager->captureOutput(screen->screen, paintCursors);
+			}
+		}
+#endif
+#if SCREENCOPY_WLR
+		{
+			auto* manager = wlr::WlrScreencopyManager::instance();
+			if (manager->isActive()) {
+				return manager->captureOutput(screen->screen, paintCursors);
+			}
+		}
+#endif
+#if SCREENCOPY_HYPRLAND_TOPLEVEL
+	} else if (auto* toplevel = qobject_cast<toplevel_management::Toplevel*>(object)) {
+		auto* manager = hyprland::HyprlandScreencopyManager::instance();
+		if (manager->isActive()) {
+			return manager->captureToplevel(toplevel->implHandle(), paintCursors);
+		}
+#endif
+	}
+
+	return nullptr;
+}
+
+} // namespace qs::wayland::screencopy
diff --git a/src/wayland/screencopy/manager.hpp b/src/wayland/screencopy/manager.hpp
new file mode 100644
index 00000000..f58e0052
--- /dev/null
+++ b/src/wayland/screencopy/manager.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <qobject.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+
+#include "../buffer/manager.hpp"
+
+namespace qs::wayland::screencopy {
+
+class ScreencopyContext: public QObject {
+	Q_OBJECT;
+
+public:
+	[[nodiscard]] buffer::WlBufferSwapchain& swapchain() { return this->mSwapchain; }
+	virtual void captureFrame() = 0;
+
+signals:
+	void frameCaptured();
+	void stopped();
+
+protected:
+	ScreencopyContext() = default;
+
+	buffer::WlBufferSwapchain mSwapchain;
+};
+
+class ScreencopyManager {
+public:
+	static ScreencopyContext* createContext(QObject* object, bool paintCursors);
+};
+
+} // namespace qs::wayland::screencopy
diff --git a/src/wayland/screencopy/view.cpp b/src/wayland/screencopy/view.cpp
new file mode 100644
index 00000000..7828c98d
--- /dev/null
+++ b/src/wayland/screencopy/view.cpp
@@ -0,0 +1,180 @@
+#include "view.hpp"
+
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qqmlinfo.h>
+#include <qquickitem.h>
+#include <qsize.h>
+#include <qtmetamacros.h>
+
+#include "../buffer/manager.hpp"
+#include "../buffer/qsg.hpp"
+#include "manager.hpp"
+
+namespace qs::wayland::screencopy {
+
+ScreencopyView::ScreencopyView(QQuickItem* parent): QQuickItem(parent) {
+	this->bImplicitSize.setBinding([this] {
+		auto constraint = this->bConstraintSize.value();
+		auto size = this->bSourceSize.value().toSizeF();
+
+		if (constraint.width() != 0 && constraint.height() != 0) {
+			size.scale(constraint.width(), constraint.height(), Qt::KeepAspectRatio);
+		} else if (constraint.width() != 0) {
+			size = QSizeF(constraint.width(), size.height() / constraint.width());
+		} else if (constraint.height() != 0) {
+			size = QSizeF(size.width() / constraint.height(), constraint.height());
+		}
+
+		return size;
+	});
+}
+
+void ScreencopyView::setCaptureSource(QObject* captureSource) {
+	if (captureSource == this->mCaptureSource) return;
+	auto hadContext = this->context != nullptr;
+	this->destroyContext(false);
+
+	this->mCaptureSource = captureSource;
+
+	if (captureSource) {
+		QObject::connect(
+		    captureSource,
+		    &QObject::destroyed,
+		    this,
+		    &ScreencopyView::onCaptureSourceDestroyed
+		);
+
+		if (this->completed) this->createContext();
+	}
+
+	if (!this->context && hadContext) this->update();
+	emit this->captureSourceChanged();
+}
+
+void ScreencopyView::onCaptureSourceDestroyed() {
+	this->mCaptureSource = nullptr;
+	this->destroyContext();
+}
+
+void ScreencopyView::setPaintCursors(bool paintCursors) {
+	if (paintCursors == this->mPaintCursors) return;
+	this->mPaintCursors = paintCursors;
+	if (this->completed && this->context) this->createContext();
+	emit this->paintCursorsChanged();
+}
+
+void ScreencopyView::setLive(bool live) {
+	if (live == this->mLive) return;
+
+	if (live && !this->mLive && this->context) {
+		this->context->captureFrame();
+	}
+
+	this->mLive = live;
+	emit this->liveChanged();
+}
+
+void ScreencopyView::createContext() {
+	this->destroyContext(false);
+	this->context = ScreencopyManager::createContext(this->mCaptureSource, this->mPaintCursors);
+
+	if (!this->context) {
+		qmlWarning(this) << "Capture source set to non captureable object.";
+		return;
+	}
+
+	this->context->setParent(this);
+
+	QObject::connect(
+	    this->context,
+	    &ScreencopyContext::stopped,
+	    this,
+	    &ScreencopyView::destroyContextWithUpdate
+	);
+
+	QObject::connect(
+	    this->context,
+	    &ScreencopyContext::frameCaptured,
+	    this,
+	    &ScreencopyView::onFrameCaptured
+	);
+
+	this->context->captureFrame();
+}
+
+void ScreencopyView::destroyContext(bool update) {
+	auto hadContext = this->context != nullptr;
+	delete this->context;
+	this->context = nullptr;
+	this->bHasContent = false;
+	this->bSourceSize = QSize();
+	if (hadContext && update) this->update();
+}
+
+void ScreencopyView::captureFrame() {
+	if (this->context) this->context->captureFrame();
+	else qmlWarning(this) << "Cannot capture frame, as no recording context is ready.";
+}
+
+void ScreencopyView::onFrameCaptured() {
+	this->setFlag(QQuickItem::ItemHasContents);
+	this->update();
+
+	const auto& frontbuffer = this->context->swapchain().frontbuffer();
+
+	auto size = frontbuffer->size();
+	if (frontbuffer->transform.flipSize()) size.transpose();
+
+	this->bSourceSize = size;
+	this->bHasContent = true;
+}
+
+void ScreencopyView::componentComplete() {
+	this->QQuickItem::componentComplete();
+
+	auto* bufManager = buffer::WlBufferManager::instance();
+	if (!bufManager->isReady()) {
+		QObject::connect(
+		    bufManager,
+		    &buffer::WlBufferManager::ready,
+		    this,
+		    &ScreencopyView::onBuffersReady
+		);
+	} else {
+		this->onBuffersReady();
+	}
+}
+
+void ScreencopyView::onBuffersReady() {
+	this->completed = true;
+	if (this->mCaptureSource) this->createContext();
+}
+
+QSGNode* ScreencopyView::updatePaintNode(QSGNode* oldNode, UpdatePaintNodeData* /*unused*/) {
+	if (!this->context || !this->bHasContent) {
+		delete oldNode;
+		this->setFlag(QQuickItem::ItemHasContents, false);
+		return nullptr;
+	}
+
+	auto* node = static_cast<buffer::WlBufferQSGDisplayNode*>(oldNode); // NOLINT
+
+	if (!node) {
+		node = new buffer::WlBufferQSGDisplayNode(this->window());
+	}
+
+	auto& swapchain = this->context->swapchain();
+	node->syncSwapchain(swapchain);
+	node->setRect(this->boundingRect());
+
+	if (this->mLive) this->context->captureFrame();
+	return node;
+}
+
+void ScreencopyView::updateImplicitSize() {
+	auto size = this->bImplicitSize.value();
+	this->setImplicitSize(size.width(), size.height());
+}
+
+} // namespace qs::wayland::screencopy
diff --git a/src/wayland/screencopy/view.hpp b/src/wayland/screencopy/view.hpp
new file mode 100644
index 00000000..d2b304ec
--- /dev/null
+++ b/src/wayland/screencopy/view.hpp
@@ -0,0 +1,104 @@
+#pragma once
+
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qquickitem.h>
+#include <qsgnode.h>
+#include <qtmetamacros.h>
+
+#include "manager.hpp"
+
+namespace qs::wayland::screencopy {
+
+///! Displays a video stream from other windows or a monitor.
+/// ScreencopyView displays live video streams or single captured frames from valid
+/// capture sources. See @@captureSource for details on which objects are accepted.
+class ScreencopyView: public QQuickItem {
+	Q_OBJECT;
+	QML_ELEMENT;
+	// clang-format off
+	/// The object to capture from. Accepts any of the following:
+	/// - `null` - Clears the displayed image.
+	/// - @@Quickshell.ShellScreen - A monitor.
+	///   Requires a compositor that supports `wlr-screencopy-unstable`
+	///   or both `ext-image-copy-capture-v1` and `ext-capture-source-v1`.
+	/// - @@Quickshell.Wayland.Toplevel - A toplevel window.
+	///   Requires a compositor that supports `hyprland-toplevel-export-v1`.
+	Q_PROPERTY(QObject* captureSource READ captureSource WRITE setCaptureSource NOTIFY captureSourceChanged);
+	/// If true, the system cursor will be painted on the image. Defaults to false.
+	Q_PROPERTY(bool paintCursor READ paintCursors WRITE setPaintCursors NOTIFY paintCursorsChanged);
+	/// If true, a live video feed from the capture source will be displayed instead of a still image.
+	/// Defaults to false.
+	Q_PROPERTY(bool live READ live WRITE setLive NOTIFY liveChanged);
+	/// If true, the view has content ready to display. Content is not always immediately available,
+	/// and this property can be used to avoid displaying it until ready.
+	Q_PROPERTY(bool hasContent READ default NOTIFY hasContentChanged BINDABLE bindableHasContent);
+	/// The size of the source image. Valid when @@hasContent is true.
+	Q_PROPERTY(QSize sourceSize READ default NOTIFY sourceSizeChanged BINDABLE bindableSourceSize);
+	/// If nonzero, the width and height constraints set for this property will constrain those
+	/// dimensions of the ScreencopyView's implicit size, maintaining the image's aspect ratio.
+	Q_PROPERTY(QSizeF constraintSize READ default WRITE default NOTIFY constraintSizeChanged BINDABLE bindableConstraintSize);
+	// clang-format on
+
+public:
+	explicit ScreencopyView(QQuickItem* parent = nullptr);
+
+	void componentComplete() override;
+
+	/// Capture a single frame. Has no effect if @@live is true.
+	Q_INVOKABLE void captureFrame();
+
+	[[nodiscard]] QObject* captureSource() const { return this->mCaptureSource; }
+	void setCaptureSource(QObject* captureSource);
+
+	[[nodiscard]] bool paintCursors() const { return this->mPaintCursors; }
+	void setPaintCursors(bool paintCursors);
+
+	[[nodiscard]] bool live() const { return this->mLive; }
+	void setLive(bool live);
+
+	[[nodiscard]] QBindable<bool> bindableHasContent() { return &this->bHasContent; }
+	[[nodiscard]] QBindable<QSize> bindableSourceSize() { return &this->bSourceSize; }
+	[[nodiscard]] QBindable<QSizeF> bindableConstraintSize() { return &this->bConstraintSize; }
+
+signals:
+	/// The compositor has ended the video stream. Attempting to restart it may or may not work.
+	void stopped();
+
+	void captureSourceChanged();
+	void paintCursorsChanged();
+	void liveChanged();
+	void hasContentChanged();
+	void sourceSizeChanged();
+	void constraintSizeChanged();
+
+protected:
+	QSGNode* updatePaintNode(QSGNode* oldNode, UpdatePaintNodeData* data) override;
+
+private slots:
+	void onCaptureSourceDestroyed();
+	void onFrameCaptured();
+	void destroyContextWithUpdate() { this->destroyContext(); }
+	void onBuffersReady();
+
+private:
+	void destroyContext(bool update = true);
+	void createContext();
+	void updateImplicitSize();
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(ScreencopyView, bool, bHasContent, &ScreencopyView::hasContentChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(ScreencopyView, QSize, bSourceSize, &ScreencopyView::sourceSizeChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(ScreencopyView, QSizeF, bConstraintSize, &ScreencopyView::constraintSizeChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(ScreencopyView, QSizeF, bImplicitSize, &ScreencopyView::updateImplicitSize);
+	// clang-format on
+
+	QObject* mCaptureSource = nullptr;
+	bool mPaintCursors = false;
+	bool mLive = false;
+	ScreencopyContext* context = nullptr;
+	bool completed = false;
+};
+
+} // namespace qs::wayland::screencopy
diff --git a/src/wayland/screencopy/wlr_screencopy/CMakeLists.txt b/src/wayland/screencopy/wlr_screencopy/CMakeLists.txt
new file mode 100644
index 00000000..5829d915
--- /dev/null
+++ b/src/wayland/screencopy/wlr_screencopy/CMakeLists.txt
@@ -0,0 +1,14 @@
+qt_add_library(quickshell-wayland-screencopy-wlr STATIC
+	wlr_screencopy.cpp
+)
+
+wl_proto(wlp-wlr-screencopy wlr-screencopy-unstable-v1 "${CMAKE_CURRENT_SOURCE_DIR}")
+
+target_link_libraries(quickshell-wayland-screencopy-wlr PRIVATE
+	Qt::WaylandClient Qt::WaylandClientPrivate wayland-client
+	Qt::Quick # for pch
+)
+
+target_link_libraries(quickshell-wayland-screencopy-wlr PUBLIC wlp-wlr-screencopy)
+
+qs_pch(quickshell-wayland-screencopy-wlr SET large)
diff --git a/src/wayland/screencopy/wlr_screencopy/wlr-screencopy-unstable-v1.xml b/src/wayland/screencopy/wlr_screencopy/wlr-screencopy-unstable-v1.xml
new file mode 100644
index 00000000..50b1b7d2
--- /dev/null
+++ b/src/wayland/screencopy/wlr_screencopy/wlr-screencopy-unstable-v1.xml
@@ -0,0 +1,232 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wlr_screencopy_unstable_v1">
+  <copyright>
+    Copyright © 2018 Simon Ser
+    Copyright © 2019 Andri Yngvason
+
+    Permission is hereby granted, free of charge, to any person obtaining a
+    copy of this software and associated documentation files (the "Software"),
+    to deal in the Software without restriction, including without limitation
+    the rights to use, copy, modify, merge, publish, distribute, sublicense,
+    and/or sell copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS IN THE SOFTWARE.
+  </copyright>
+
+  <description summary="screen content capturing on client buffers">
+    This protocol allows clients to ask the compositor to copy part of the
+    screen content to a client buffer.
+
+    Warning! The protocol described in this file is experimental and
+    backward incompatible changes may be made. Backward compatible changes
+    may be added together with the corresponding interface version bump.
+    Backward incompatible changes are done by bumping the version number in
+    the protocol and interface names and resetting the interface version.
+    Once the protocol is to be declared stable, the 'z' prefix and the
+    version number in the protocol and interface names are removed and the
+    interface version number is reset.
+  </description>
+
+  <interface name="zwlr_screencopy_manager_v1" version="3">
+    <description summary="manager to inform clients and begin capturing">
+      This object is a manager which offers requests to start capturing from a
+      source.
+    </description>
+
+    <request name="capture_output">
+      <description summary="capture an output">
+        Capture the next frame of an entire output.
+      </description>
+      <arg name="frame" type="new_id" interface="zwlr_screencopy_frame_v1"/>
+      <arg name="overlay_cursor" type="int"
+        summary="composite cursor onto the frame"/>
+      <arg name="output" type="object" interface="wl_output"/>
+    </request>
+
+    <request name="capture_output_region">
+      <description summary="capture an output's region">
+        Capture the next frame of an output's region.
+
+        The region is given in output logical coordinates, see
+        xdg_output.logical_size. The region will be clipped to the output's
+        extents.
+      </description>
+      <arg name="frame" type="new_id" interface="zwlr_screencopy_frame_v1"/>
+      <arg name="overlay_cursor" type="int"
+        summary="composite cursor onto the frame"/>
+      <arg name="output" type="object" interface="wl_output"/>
+      <arg name="x" type="int"/>
+      <arg name="y" type="int"/>
+      <arg name="width" type="int"/>
+      <arg name="height" type="int"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the manager">
+        All objects created by the manager will still remain valid, until their
+        appropriate destroy request has been called.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zwlr_screencopy_frame_v1" version="3">
+    <description summary="a frame ready for copy">
+      This object represents a single frame.
+
+      When created, a series of buffer events will be sent, each representing a
+      supported buffer type. The "buffer_done" event is sent afterwards to
+      indicate that all supported buffer types have been enumerated. The client
+      will then be able to send a "copy" request. If the capture is successful,
+      the compositor will send a "flags" followed by a "ready" event.
+
+      For objects version 2 or lower, wl_shm buffers are always supported, ie.
+      the "buffer" event is guaranteed to be sent.
+
+      If the capture failed, the "failed" event is sent. This can happen anytime
+      before the "ready" event.
+
+      Once either a "ready" or a "failed" event is received, the client should
+      destroy the frame.
+    </description>
+
+    <event name="buffer">
+      <description summary="wl_shm buffer information">
+        Provides information about wl_shm buffer parameters that need to be
+        used for this frame. This event is sent once after the frame is created
+        if wl_shm buffers are supported.
+      </description>
+      <arg name="format" type="uint" enum="wl_shm.format" summary="buffer format"/>
+      <arg name="width" type="uint" summary="buffer width"/>
+      <arg name="height" type="uint" summary="buffer height"/>
+      <arg name="stride" type="uint" summary="buffer stride"/>
+    </event>
+
+    <request name="copy">
+      <description summary="copy the frame">
+        Copy the frame to the supplied buffer. The buffer must have a the
+        correct size, see zwlr_screencopy_frame_v1.buffer and
+        zwlr_screencopy_frame_v1.linux_dmabuf. The buffer needs to have a
+        supported format.
+
+        If the frame is successfully copied, a "flags" and a "ready" events are
+        sent. Otherwise, a "failed" event is sent.
+      </description>
+      <arg name="buffer" type="object" interface="wl_buffer"/>
+    </request>
+
+    <enum name="error">
+      <entry name="already_used" value="0"
+        summary="the object has already been used to copy a wl_buffer"/>
+      <entry name="invalid_buffer" value="1"
+        summary="buffer attributes are invalid"/>
+    </enum>
+
+    <enum name="flags" bitfield="true">
+      <entry name="y_invert" value="1" summary="contents are y-inverted"/>
+    </enum>
+
+    <event name="flags">
+      <description summary="frame flags">
+        Provides flags about the frame. This event is sent once before the
+        "ready" event.
+      </description>
+      <arg name="flags" type="uint" enum="flags" summary="frame flags"/>
+    </event>
+
+    <event name="ready">
+      <description summary="indicates frame is available for reading">
+        Called as soon as the frame is copied, indicating it is available
+        for reading. This event includes the time at which presentation happened
+        at.
+
+        The timestamp is expressed as tv_sec_hi, tv_sec_lo, tv_nsec triples,
+        each component being an unsigned 32-bit value. Whole seconds are in
+        tv_sec which is a 64-bit value combined from tv_sec_hi and tv_sec_lo,
+        and the additional fractional part in tv_nsec as nanoseconds. Hence,
+        for valid timestamps tv_nsec must be in [0, 999999999]. The seconds part
+        may have an arbitrary offset at start.
+
+        After receiving this event, the client should destroy the object.
+      </description>
+      <arg name="tv_sec_hi" type="uint"
+           summary="high 32 bits of the seconds part of the timestamp"/>
+      <arg name="tv_sec_lo" type="uint"
+           summary="low 32 bits of the seconds part of the timestamp"/>
+      <arg name="tv_nsec" type="uint"
+           summary="nanoseconds part of the timestamp"/>
+    </event>
+
+    <event name="failed">
+      <description summary="frame copy failed">
+        This event indicates that the attempted frame copy has failed.
+
+        After receiving this event, the client should destroy the object.
+      </description>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="delete this object, used or not">
+        Destroys the frame. This request can be sent at any time by the client.
+      </description>
+    </request>
+
+    <!-- Version 2 additions -->
+    <request name="copy_with_damage" since="2">
+      <description summary="copy the frame when it's damaged">
+        Same as copy, except it waits until there is damage to copy.
+      </description>
+      <arg name="buffer" type="object" interface="wl_buffer"/>
+    </request>
+
+    <event name="damage" since="2">
+      <description summary="carries the coordinates of the damaged region">
+        This event is sent right before the ready event when copy_with_damage is
+        requested. It may be generated multiple times for each copy_with_damage
+        request.
+
+        The arguments describe a box around an area that has changed since the
+        last copy request that was derived from the current screencopy manager
+        instance.
+
+        The union of all regions received between the call to copy_with_damage
+        and a ready event is the total damage since the prior ready event.
+      </description>
+      <arg name="x" type="uint" summary="damaged x coordinates"/>
+      <arg name="y" type="uint" summary="damaged y coordinates"/>
+      <arg name="width" type="uint" summary="current width"/>
+      <arg name="height" type="uint" summary="current height"/>
+    </event>
+
+    <!-- Version 3 additions -->
+    <event name="linux_dmabuf" since="3">
+      <description summary="linux-dmabuf buffer information">
+        Provides information about linux-dmabuf buffer parameters that need to
+        be used for this frame. This event is sent once after the frame is
+        created if linux-dmabuf buffers are supported.
+      </description>
+      <arg name="format" type="uint" summary="fourcc pixel format"/>
+      <arg name="width" type="uint" summary="buffer width"/>
+      <arg name="height" type="uint" summary="buffer height"/>
+    </event>
+
+    <event name="buffer_done" since="3">
+      <description summary="all buffer types reported">
+        This event is sent once after all buffer events have been sent.
+
+        The client should proceed to create a buffer of one of the supported
+        types, and send a "copy" request.
+      </description>
+    </event>
+  </interface>
+</protocol>
diff --git a/src/wayland/screencopy/wlr_screencopy/wlr_screencopy.cpp b/src/wayland/screencopy/wlr_screencopy/wlr_screencopy.cpp
new file mode 100644
index 00000000..e1553f51
--- /dev/null
+++ b/src/wayland/screencopy/wlr_screencopy/wlr_screencopy.cpp
@@ -0,0 +1,200 @@
+#include "wlr_screencopy.hpp"
+#include <cstdint>
+
+#include <private/qwaylanddisplay_p.h>
+#include <private/qwaylandscreen_p.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qscreen.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qwaylandclientextension.h>
+#include <wayland-wlr-screencopy-unstable-v1-client-protocol.h>
+
+#include "../../../core/logcat.hpp"
+#include "../../buffer/manager.hpp"
+#include "../manager.hpp"
+#include "wlr_screencopy_p.hpp"
+
+namespace qs::wayland::screencopy::wlr {
+
+namespace {
+QS_LOGGING_CATEGORY(logScreencopy, "quickshell.wayland.screencopy.wlr", QtWarningMsg);
+}
+
+WlrScreencopyManager::WlrScreencopyManager(): QWaylandClientExtensionTemplate(3) {
+	this->initialize();
+}
+
+WlrScreencopyManager* WlrScreencopyManager::instance() {
+	static auto* instance = new WlrScreencopyManager();
+	return instance;
+}
+
+ScreencopyContext*
+WlrScreencopyManager::captureOutput(QScreen* screen, bool paintCursors, QRect region) {
+	if (!dynamic_cast<QtWaylandClient::QWaylandScreen*>(screen->handle())) return nullptr;
+	return new WlrScreencopyContext(this, screen, paintCursors, region);
+}
+
+WlrScreencopyContext::WlrScreencopyContext(
+    WlrScreencopyManager* manager,
+    QScreen* screen,
+    bool paintCursors,
+    QRect region
+)
+    : manager(manager)
+    , screen(dynamic_cast<QtWaylandClient::QWaylandScreen*>(screen->handle()))
+    , paintCursors(paintCursors)
+    , region(region) {
+	this->transform.setScreen(this->screen);
+	QObject::connect(screen, &QObject::destroyed, this, &WlrScreencopyContext::onScreenDestroyed);
+}
+
+WlrScreencopyContext::~WlrScreencopyContext() {
+	if (this->object()) this->destroy();
+}
+
+void WlrScreencopyContext::onScreenDestroyed() {
+	qCWarning(logScreencopy) << "Screen destroyed while recording. Stopping" << this;
+	if (this->object()) this->destroy();
+	emit this->stopped();
+}
+
+void WlrScreencopyContext::captureFrame() {
+	if (this->object()) return;
+
+	this->request.reset();
+
+	if (this->region.isEmpty()) {
+		this->init(manager->capture_output(this->paintCursors ? 1 : 0, screen->output()));
+	} else {
+		this->init(manager->capture_output_region(
+		    this->paintCursors ? 1 : 0,
+		    screen->output(),
+		    this->region.x(),
+		    this->region.y(),
+		    this->region.width(),
+		    this->region.height()
+		));
+	}
+}
+
+void WlrScreencopyContext::zwlr_screencopy_frame_v1_buffer(
+    uint32_t format,
+    uint32_t width,
+    uint32_t height,
+    uint32_t /*stride*/
+) {
+	// While different sizes can technically be requested, that would be insane.
+	this->request.width = width;
+	this->request.height = height;
+	this->request.shm.formats.push(format);
+}
+
+void WlrScreencopyContext::zwlr_screencopy_frame_v1_linux_dmabuf(
+    uint32_t format,
+    uint32_t width,
+    uint32_t height
+) {
+	// While different sizes can technically be requested, that would be insane.
+	this->request.width = width;
+	this->request.height = height;
+	this->request.dmabuf.formats.push(format);
+}
+
+void WlrScreencopyContext::zwlr_screencopy_frame_v1_flags(uint32_t flags) {
+	this->yInvert = flags & ZWLR_SCREENCOPY_FRAME_V1_FLAGS_Y_INVERT;
+}
+
+void WlrScreencopyContext::zwlr_screencopy_frame_v1_buffer_done() {
+	auto* backbuffer = this->mSwapchain.createBackbuffer(this->request);
+
+	if (!backbuffer || !backbuffer->buffer()) {
+		qCWarning(logScreencopy) << "Backbuffer creation failed for screencopy. Skipping frame.";
+
+		// Try again. This will be spammy if the compositor continuously sends bad frames.
+		this->destroy();
+		this->captureFrame();
+		return;
+	}
+
+	if (this->copiedFirstFrame) {
+		this->copy_with_damage(backbuffer->buffer());
+	} else {
+		this->copy(backbuffer->buffer());
+	}
+}
+
+void WlrScreencopyContext::zwlr_screencopy_frame_v1_ready(
+    uint32_t /*tvSecHi*/,
+    uint32_t /*tvSecLo*/,
+    uint32_t /*tvNsec*/
+) {
+	this->submitFrame();
+}
+
+void WlrScreencopyContext::zwlr_screencopy_frame_v1_failed() {
+	qCWarning(logScreencopy) << "Ending recording due to screencopy failure for" << this;
+	emit this->stopped();
+}
+
+void WlrScreencopyContext::updateTransform(bool previouslyUnset) {
+	if (previouslyUnset && this->copiedFirstFrame) this->submitFrame();
+}
+
+void WlrScreencopyContext::submitFrame() {
+	this->copiedFirstFrame = true;
+	if (this->transform.transform == -1) return;
+
+	auto flipTransform =
+	    this->yInvert ? buffer::WlBufferTransform::Flipped180 : buffer::WlBufferTransform::Normal0;
+
+	this->mSwapchain.backbuffer()->transform = this->transform.transform ^ flipTransform;
+
+	this->destroy();
+	this->mSwapchain.swapBuffers();
+	emit this->frameCaptured();
+}
+
+WlrScreencopyContext::OutputTransformQuery::OutputTransformQuery(WlrScreencopyContext* context)
+    : context(context) {}
+
+WlrScreencopyContext::OutputTransformQuery::~OutputTransformQuery() {
+	if (this->isInitialized()) this->release();
+}
+
+void WlrScreencopyContext::OutputTransformQuery::setScreen(QtWaylandClient::QWaylandScreen* screen
+) {
+	// cursed hack
+	class QWaylandScreenReflector: public QtWaylandClient::QWaylandScreen {
+	public:
+		[[nodiscard]] int globalId() const { return this->m_outputId; }
+	};
+
+	if (this->isInitialized()) this->release();
+
+	this->init(
+	    screen->display()->wl_registry(),
+	    static_cast<QWaylandScreenReflector*>(screen)->globalId(), // NOLINT
+	    3
+	);
+}
+
+void WlrScreencopyContext::OutputTransformQuery::output_geometry(
+    qint32 /*x*/,
+    qint32 /*y*/,
+    qint32 /*width*/,
+    qint32 /*height*/,
+    qint32 /*subpixel*/,
+    const QString& /*make*/,
+    const QString& /*model*/,
+    qint32 transform
+) {
+	auto newTransform = this->transform == -1;
+	this->transform = transform;
+	this->context->updateTransform(newTransform);
+}
+
+} // namespace qs::wayland::screencopy::wlr
diff --git a/src/wayland/screencopy/wlr_screencopy/wlr_screencopy.hpp b/src/wayland/screencopy/wlr_screencopy/wlr_screencopy.hpp
new file mode 100644
index 00000000..bea17332
--- /dev/null
+++ b/src/wayland/screencopy/wlr_screencopy/wlr_screencopy.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <qscreen.h>
+#include <qwayland-wlr-screencopy-unstable-v1.h>
+#include <qwaylandclientextension.h>
+
+#include "../manager.hpp"
+
+namespace qs::wayland::screencopy::wlr {
+
+class WlrScreencopyManager
+    : public QWaylandClientExtensionTemplate<WlrScreencopyManager>
+    , public QtWayland::zwlr_screencopy_manager_v1 {
+public:
+	ScreencopyContext* captureOutput(QScreen* screen, bool paintCursors, QRect region = QRect());
+
+	static WlrScreencopyManager* instance();
+
+private:
+	explicit WlrScreencopyManager();
+
+	friend class WlrScreencopyContext;
+};
+
+} // namespace qs::wayland::screencopy::wlr
diff --git a/src/wayland/screencopy/wlr_screencopy/wlr_screencopy_p.hpp b/src/wayland/screencopy/wlr_screencopy/wlr_screencopy_p.hpp
new file mode 100644
index 00000000..6e7620c5
--- /dev/null
+++ b/src/wayland/screencopy/wlr_screencopy/wlr_screencopy_p.hpp
@@ -0,0 +1,84 @@
+#pragma once
+
+#include <private/qwayland-wayland.h>
+#include <private/qwaylandscreen_p.h>
+#include <qcontainerfwd.h>
+#include <qtclasshelpermacros.h>
+#include <qtypes.h>
+#include <qwayland-wlr-screencopy-unstable-v1.h>
+
+#include "../manager.hpp"
+
+namespace qs::wayland::screencopy::wlr {
+
+class WlrScreencopyManager;
+
+class WlrScreencopyContext
+    : public ScreencopyContext
+    , public QtWayland::zwlr_screencopy_frame_v1 {
+public:
+	explicit WlrScreencopyContext(
+	    WlrScreencopyManager* manager,
+	    QScreen* screen,
+	    bool paintCursors,
+	    QRect region
+	);
+	~WlrScreencopyContext() override;
+	Q_DISABLE_COPY_MOVE(WlrScreencopyContext);
+
+	void captureFrame() override;
+	void updateTransform(bool previouslyUnset);
+
+protected:
+	// clang-format off
+	void zwlr_screencopy_frame_v1_buffer(uint32_t format, uint32_t width, uint32_t height, uint32_t stride) override;
+	void zwlr_screencopy_frame_v1_linux_dmabuf(uint32_t format, uint32_t width, uint32_t height) override;
+	void zwlr_screencopy_frame_v1_flags(uint32_t flags) override;
+	void zwlr_screencopy_frame_v1_buffer_done() override;
+	void zwlr_screencopy_frame_v1_ready(uint32_t tvSecHi, uint32_t tvSecLo, uint32_t tvNsec) override;
+	void zwlr_screencopy_frame_v1_failed() override;
+	// clang-format on
+
+private slots:
+	void onScreenDestroyed();
+
+private:
+	void submitFrame();
+
+	class OutputTransformQuery: public QtWayland::wl_output {
+	public:
+		OutputTransformQuery(WlrScreencopyContext* context);
+		~OutputTransformQuery() override;
+		Q_DISABLE_COPY_MOVE(OutputTransformQuery);
+
+		qint32 transform = -1;
+		void setScreen(QtWaylandClient::QWaylandScreen* screen);
+
+	protected:
+		void output_geometry(
+		    qint32 x,
+		    qint32 y,
+		    qint32 width,
+		    qint32 height,
+		    qint32 subpixel,
+		    const QString& make,
+		    const QString& model,
+		    qint32 transform
+		) override;
+
+	private:
+		WlrScreencopyContext* context;
+	};
+
+	WlrScreencopyManager* manager;
+	buffer::WlBufferRequest request;
+	bool copiedFirstFrame = false;
+	OutputTransformQuery transform {this};
+	bool yInvert = false;
+
+	QtWaylandClient::QWaylandScreen* screen;
+	bool paintCursors;
+	QRect region;
+};
+
+} // namespace qs::wayland::screencopy::wlr
diff --git a/src/wayland/session_lock.cpp b/src/wayland/session_lock.cpp
index a7aa4731..0ecf9ec0 100644
--- a/src/wayland/session_lock.cpp
+++ b/src/wayland/session_lock.cpp
@@ -1,5 +1,6 @@
 #include "session_lock.hpp"
 
+#include <private/qwaylandscreen_p.h>
 #include <qcolor.h>
 #include <qcoreapplication.h>
 #include <qguiapplication.h>
@@ -14,12 +15,13 @@
 #include <qtmetamacros.h>
 #include <qtypes.h>
 
+#include "../core/qmlglobal.hpp"
 #include "../core/qmlscreen.hpp"
 #include "../core/reload.hpp"
 #include "session_lock/session_lock.hpp"
 
-void SessionLock::onReload(QObject* oldInstance) {
-	auto* old = qobject_cast<SessionLock*>(oldInstance);
+void WlSessionLock::onReload(QObject* oldInstance) {
+	auto* old = qobject_cast<WlSessionLock*>(oldInstance);
 
 	if (old != nullptr) {
 		QObject::disconnect(old->manager, nullptr, old, nullptr);
@@ -30,77 +32,109 @@ void SessionLock::onReload(QObject* oldInstance) {
 	}
 
 	// clang-format off
-	QObject::connect(this->manager, &SessionLockManager::locked, this, &SessionLock::secureStateChanged);
-	QObject::connect(this->manager, &SessionLockManager::unlocked, this, &SessionLock::secureStateChanged);
+	QObject::connect(this->manager, &SessionLockManager::locked, this, &WlSessionLock::secureStateChanged);
+	QObject::connect(this->manager, &SessionLockManager::unlocked, this, &WlSessionLock::secureStateChanged);
 
-	QObject::connect(this->manager, &SessionLockManager::unlocked, this, &SessionLock::unlock);
+	QObject::connect(this->manager, &SessionLockManager::unlocked, this, &WlSessionLock::unlock);
 
 	auto* app = QCoreApplication::instance();
 	auto* guiApp = qobject_cast<QGuiApplication*>(app);
 
 	if (guiApp != nullptr) {
-		QObject::connect(guiApp, &QGuiApplication::primaryScreenChanged, this, &SessionLock::onScreensChanged);
-		QObject::connect(guiApp, &QGuiApplication::screenAdded, this, &SessionLock::onScreensChanged);
-		QObject::connect(guiApp, &QGuiApplication::screenRemoved, this, &SessionLock::onScreensChanged);
+		QObject::connect(guiApp, &QGuiApplication::primaryScreenChanged, this, &WlSessionLock::onScreensChanged);
+		QObject::connect(guiApp, &QGuiApplication::screenAdded, this, &WlSessionLock::onScreensChanged);
+		QObject::connect(guiApp, &QGuiApplication::screenRemoved, this, &WlSessionLock::onScreensChanged);
 	}
 	// clang-format on
 
-	if (this->lockTarget) {
-		if (!this->manager->lock()) this->lockTarget = false;
-		this->updateSurfaces(old);
-	} else {
-		this->setLocked(false);
+	this->realizeLockTarget(old);
+}
+
+void WlSessionLock::updateSurfaces(bool show, WlSessionLock* old) {
+	auto screens = QGuiApplication::screens();
+
+	screens.removeIf([](QScreen* screen) {
+		if (dynamic_cast<QtWaylandClient::QWaylandScreen*>(screen->handle()) == nullptr) {
+			qDebug() << "Not creating lock surface for screen" << screen
+			         << "as it is not backed by a wayland screen.";
+
+			return true;
+		}
+
+		return false;
+	});
+
+	auto map = this->surfaces.toStdMap();
+	for (auto& [screen, surface]: map) {
+		if (!screens.contains(screen)) {
+			this->surfaces.remove(screen);
+			surface->deleteLater();
+		}
+	}
+
+	for (auto* screen: screens) {
+		if (!this->surfaces.contains(screen)) {
+			auto* instanceObj =
+			    this->mSurfaceComponent->create(QQmlEngine::contextForObject(this->mSurfaceComponent));
+			auto* instance = qobject_cast<WlSessionLockSurface*>(instanceObj);
+
+			if (instance == nullptr) {
+				qWarning(
+				) << "WlSessionLock.surface does not create a WlSessionLockSurface. Aborting lock.";
+				if (instanceObj != nullptr) instanceObj->deleteLater();
+				this->unlock();
+				return;
+			}
+
+			instance->setParent(this);
+			instance->setScreen(screen);
+
+			auto* oldInstance = old == nullptr ? nullptr : old->surfaces.value(screen, nullptr);
+			instance->reload(oldInstance);
+
+			this->surfaces[screen] = instance;
+		}
+	}
+
+	if (show) {
+		if (!this->manager->isLocked()) {
+			qFatal() << "Tried to show lockscreen surfaces without active lock";
+		}
+
+		for (auto* surface: this->surfaces.values()) {
+			surface->show();
+		}
 	}
 }
 
-void SessionLock::updateSurfaces(SessionLock* old) {
-	if (this->manager->isLocked()) {
-		auto screens = QGuiApplication::screens();
-
-		auto map = this->surfaces.toStdMap();
-		for (auto& [screen, surface]: map) {
-			if (!screens.contains(screen)) {
-				this->surfaces.remove(screen);
-				surface->deleteLater();
-			}
-		}
-
-		if (this->mSurfaceComponent == nullptr) {
-			qWarning() << "SessionLock.surface is null. Aborting lock.";
+void WlSessionLock::realizeLockTarget(WlSessionLock* old) {
+	if (this->lockTarget) {
+		if (!SessionLockManager::lockAvailable()) {
+			qCritical() << "Cannot start session lock: The current compositor does not support the "
+			               "ext-session-lock-v1 protocol.";
 			this->unlock();
 			return;
 		}
 
-		for (auto* screen: screens) {
-			if (!this->surfaces.contains(screen)) {
-				auto* instanceObj =
-				    this->mSurfaceComponent->create(QQmlEngine::contextForObject(this->mSurfaceComponent));
-				auto* instance = qobject_cast<SessionLockSurface*>(instanceObj);
-
-				if (instance == nullptr) {
-					qWarning() << "SessionLock.surface does not create a SessionLockSurface. Aborting lock.";
-					if (instanceObj != nullptr) instanceObj->deleteLater();
-					this->unlock();
-					return;
-				}
-
-				instance->setParent(this);
-				instance->setScreen(screen);
-
-				auto* oldInstance = old == nullptr ? nullptr : old->surfaces.value(screen, nullptr);
-				instance->onReload(oldInstance);
-
-				this->surfaces[screen] = instance;
-			}
-
-			for (auto* surface: this->surfaces.values()) {
-				surface->show();
-			}
+		if (this->mSurfaceComponent == nullptr) {
+			qWarning() << "WlSessionLock.surface is null. Aborting lock.";
+			this->unlock();
+			return;
 		}
+
+		// preload initial surfaces to make the chance of the compositor displaying a blank
+		// frame before the lock surfaces are shown as low as possible.
+		this->updateSurfaces(false);
+
+		if (!this->manager->lock()) this->lockTarget = false;
+
+		this->updateSurfaces(true, old);
+	} else {
+		this->unlock(); // emits lockStateChanged
 	}
 }
 
-void SessionLock::unlock() {
+void WlSessionLock::unlock() {
 	if (this->isLocked()) {
 		this->lockTarget = false;
 		this->manager->unlock();
@@ -115,17 +149,21 @@ void SessionLock::unlock() {
 	}
 }
 
-void SessionLock::onScreensChanged() { this->updateSurfaces(); }
+void WlSessionLock::onScreensChanged() {
+	if (this->manager != nullptr && this->manager->isLocked()) {
+		this->updateSurfaces(true);
+	}
+}
 
-bool SessionLock::isLocked() const {
+bool WlSessionLock::isLocked() const {
 	return this->manager == nullptr ? this->lockTarget : this->manager->isLocked();
 }
 
-bool SessionLock::isSecure() const {
+bool WlSessionLock::isSecure() const {
 	return this->manager != nullptr && SessionLockManager::isSecure();
 }
 
-void SessionLock::setLocked(bool locked) {
+void WlSessionLock::setLocked(bool locked) {
 	if (this->isLocked() == locked) return;
 	this->lockTarget = locked;
 
@@ -134,18 +172,17 @@ void SessionLock::setLocked(bool locked) {
 		return;
 	}
 
-	if (locked) {
-		if (!this->manager->lock()) this->lockTarget = false;
-		this->updateSurfaces();
-		if (this->lockTarget) emit this->lockStateChanged();
-	} else {
-		this->unlock(); // emits lockStateChanged
-	}
+	this->realizeLockTarget();
 }
 
-QQmlComponent* SessionLock::surfaceComponent() const { return this->mSurfaceComponent; }
+QQmlComponent* WlSessionLock::surfaceComponent() const { return this->mSurfaceComponent; }
+
+void WlSessionLock::setSurfaceComponent(QQmlComponent* surfaceComponent) {
+	if (this->manager != nullptr && this->manager->isLocked()) {
+		qCritical() << "WlSessionLock.surfaceComponent cannot be changed while the lock is active.";
+		return;
+	}
 
-void SessionLock::setSurfaceComponent(QQmlComponent* surfaceComponent) {
 	if (this->mSurfaceComponent != nullptr) this->mSurfaceComponent->deleteLater();
 	if (surfaceComponent != nullptr) surfaceComponent->setParent(this);
 
@@ -153,7 +190,7 @@ void SessionLock::setSurfaceComponent(QQmlComponent* surfaceComponent) {
 	emit this->surfaceComponentChanged();
 }
 
-SessionLockSurface::SessionLockSurface(QObject* parent)
+WlSessionLockSurface::WlSessionLockSurface(QObject* parent)
     : Reloadable(parent)
     , mContentItem(new QQuickItem())
     , ext(new LockWindowExtension(this)) {
@@ -161,19 +198,19 @@ SessionLockSurface::SessionLockSurface(QObject* parent)
 	this->mContentItem->setParent(this);
 
 	// clang-format off
-	QObject::connect(this, &SessionLockSurface::widthChanged, this, &SessionLockSurface::onWidthChanged);
-	QObject::connect(this, &SessionLockSurface::heightChanged, this, &SessionLockSurface::onHeightChanged);
+	QObject::connect(this, &WlSessionLockSurface::widthChanged, this, &WlSessionLockSurface::onWidthChanged);
+	QObject::connect(this, &WlSessionLockSurface::heightChanged, this, &WlSessionLockSurface::onHeightChanged);
 	// clang-format on
 }
 
-SessionLockSurface::~SessionLockSurface() {
+WlSessionLockSurface::~WlSessionLockSurface() {
 	if (this->window != nullptr) {
 		this->window->deleteLater();
 	}
 }
 
-void SessionLockSurface::onReload(QObject* oldInstance) {
-	if (auto* old = qobject_cast<SessionLockSurface*>(oldInstance)) {
+void WlSessionLockSurface::onReload(QObject* oldInstance) {
+	if (auto* old = qobject_cast<WlSessionLockSurface*>(oldInstance)) {
 		this->window = old->disownWindow();
 	}
 
@@ -190,25 +227,27 @@ void SessionLockSurface::onReload(QObject* oldInstance) {
 	this->window->setColor(this->mColor);
 
 	// clang-format off
-	QObject::connect(this->window, &QWindow::visibilityChanged, this, &SessionLockSurface::visibleChanged);
-	QObject::connect(this->window, &QWindow::widthChanged, this, &SessionLockSurface::widthChanged);
-	QObject::connect(this->window, &QWindow::heightChanged, this, &SessionLockSurface::heightChanged);
-	QObject::connect(this->window, &QWindow::screenChanged, this, &SessionLockSurface::screenChanged);
-	QObject::connect(this->window, &QQuickWindow::colorChanged, this, &SessionLockSurface::colorChanged);
+	QObject::connect(this->window, &QWindow::visibilityChanged, this, &WlSessionLockSurface::visibleChanged);
+	QObject::connect(this->window, &QWindow::widthChanged, this, &WlSessionLockSurface::widthChanged);
+	QObject::connect(this->window, &QWindow::heightChanged, this, &WlSessionLockSurface::heightChanged);
+	QObject::connect(this->window, &QWindow::screenChanged, this, &WlSessionLockSurface::screenChanged);
+	QObject::connect(this->window, &QQuickWindow::colorChanged, this, &WlSessionLockSurface::colorChanged);
 	// clang-format on
+}
 
-	if (auto* parent = qobject_cast<SessionLock*>(this->parent())) {
+void WlSessionLockSurface::attach() {
+	if (this->ext->isAttached()) return;
+
+	if (auto* parent = qobject_cast<WlSessionLock*>(this->parent())) {
 		if (!this->ext->attach(this->window, parent->manager)) {
-			qWarning(
-			) << "Failed to attach LockWindowExtension to window. Surface will not behave correctly.";
+			qFatal() << "Failed to attach WlSessionLockSurface";
 		}
 	} else {
-		qWarning(
-		) << "SessionLockSurface parent is not a SessionLock. Surface will not behave correctly.";
+		qFatal() << "Tried to attach a WlSessionLockSurface whose parent is not a WlSessionLock";
 	}
 }
 
-QQuickWindow* SessionLockSurface::disownWindow() {
+QQuickWindow* WlSessionLockSurface::disownWindow() {
 	QObject::disconnect(this->window, nullptr, this, nullptr);
 	this->mContentItem->setParentItem(nullptr);
 
@@ -217,23 +256,26 @@ QQuickWindow* SessionLockSurface::disownWindow() {
 	return window;
 }
 
-void SessionLockSurface::show() { this->ext->setVisible(); }
+void WlSessionLockSurface::show() {
+	this->attach();
+	this->ext->setVisible();
+}
 
-QQuickItem* SessionLockSurface::contentItem() const { return this->mContentItem; }
+QQuickItem* WlSessionLockSurface::contentItem() const { return this->mContentItem; }
 
-bool SessionLockSurface::isVisible() const { return this->window->isVisible(); }
+bool WlSessionLockSurface::isVisible() const { return this->window->isVisible(); }
 
-qint32 SessionLockSurface::width() const {
+qint32 WlSessionLockSurface::width() const {
 	if (this->window == nullptr) return 0;
 	else return this->window->width();
 }
 
-qint32 SessionLockSurface::height() const {
+qint32 WlSessionLockSurface::height() const {
 	if (this->window == nullptr) return 0;
 	else return this->window->height();
 }
 
-QuickshellScreenInfo* SessionLockSurface::screen() const {
+QuickshellScreenInfo* WlSessionLockSurface::screen() const {
 	QScreen* qscreen = nullptr;
 
 	if (this->window == nullptr) {
@@ -242,44 +284,44 @@ QuickshellScreenInfo* SessionLockSurface::screen() const {
 		qscreen = this->window->screen();
 	}
 
-	return new QuickshellScreenInfo(
-	    const_cast<SessionLockSurface*>(this), // NOLINT
-	    qscreen
-	);
+	return QuickshellTracked::instance()->screenInfo(qscreen);
 }
 
-void SessionLockSurface::setScreen(QScreen* qscreen) {
+void WlSessionLockSurface::setScreen(QScreen* qscreen) {
 	if (this->mScreen != nullptr) {
 		QObject::disconnect(this->mScreen, nullptr, this, nullptr);
 	}
 
 	if (qscreen != nullptr) {
-		QObject::connect(qscreen, &QObject::destroyed, this, &SessionLockSurface::onScreenDestroyed);
+		QObject::connect(qscreen, &QObject::destroyed, this, &WlSessionLockSurface::onScreenDestroyed);
 	}
 
 	if (this->window == nullptr) {
 		this->mScreen = qscreen;
-		emit this->screenChanged();
-	} else this->window->setScreen(qscreen);
+	} else {
+		this->window->setScreen(qscreen);
+	}
+
+	emit this->screenChanged();
 }
 
-void SessionLockSurface::onScreenDestroyed() { this->mScreen = nullptr; }
+void WlSessionLockSurface::onScreenDestroyed() { this->mScreen = nullptr; }
 
-QColor SessionLockSurface::color() const {
+QColor WlSessionLockSurface::color() const {
 	if (this->window == nullptr) return this->mColor;
 	else return this->window->color();
 }
 
-void SessionLockSurface::setColor(QColor color) {
+void WlSessionLockSurface::setColor(QColor color) {
 	if (this->window == nullptr) {
 		this->mColor = color;
 		emit this->colorChanged();
 	} else this->window->setColor(color);
 }
 
-QQmlListProperty<QObject> SessionLockSurface::data() {
+QQmlListProperty<QObject> WlSessionLockSurface::data() {
 	return this->mContentItem->property("data").value<QQmlListProperty<QObject>>();
 }
 
-void SessionLockSurface::onWidthChanged() { this->mContentItem->setWidth(this->width()); }
-void SessionLockSurface::onHeightChanged() { this->mContentItem->setHeight(this->height()); }
+void WlSessionLockSurface::onWidthChanged() { this->mContentItem->setWidth(this->width()); }
+void WlSessionLockSurface::onHeightChanged() { this->mContentItem->setHeight(this->height()); }
diff --git a/src/wayland/session_lock.hpp b/src/wayland/session_lock.hpp
index 1f709a4c..9a34eafa 100644
--- a/src/wayland/session_lock.hpp
+++ b/src/wayland/session_lock.hpp
@@ -19,21 +19,21 @@
 #include "../core/reload.hpp"
 #include "session_lock/session_lock.hpp"
 
-class SessionLockSurface;
+class WlSessionLockSurface;
 
 ///! Wayland session locker.
 /// Wayland session lock implemented using the [ext_session_lock_v1] protocol.
 ///
-/// SessionLock will create an instance of its `surface` component for every screen when
-/// `locked` is set to true. The `surface` component must create a [SessionLockSurface]
+/// WlSessionLock will create an instance of its `surface` component for every screen when
+/// `locked` is set to true. The `surface` component must create a @@WlSessionLockSurface
 /// which will be displayed on each screen.
 ///
 /// The below example will create a session lock that disappears when the button is clicked.
 /// ```qml
-/// SessionLock {
+/// WlSessionLock {
 ///   id: lock
 ///
-///   SessionLockSurface {
+///   WlSessionLockSurface {
 ///     Button {
 ///       text: "unlock me"
 ///       onClicked: lock.locked = false
@@ -45,7 +45,7 @@ class SessionLockSurface;
 /// lock.locked = true
 /// ```
 ///
-/// > [!WARNING] If the SessionLock is destroyed or quickshell exits without setting `locked`
+/// > [!WARNING] If the WlSessionLock is destroyed or quickshell exits without setting `locked`
 /// > to false, conformant compositors will leave the screen locked and painted with a solid
 /// > color.
 /// >
@@ -53,29 +53,26 @@ class SessionLockSurface;
 /// > but it will render it inoperable.
 ///
 /// [ext_session_lock_v1]: https://wayland.app/protocols/ext-session-lock-v1
-/// [SessionLockSurface]: ../sessionlocksurface
-class SessionLock: public Reloadable {
+class WlSessionLock: public Reloadable {
 	Q_OBJECT;
 	// clang-format off
 	/// Controls the lock state.
 	///
-	/// > [!WARNING] Only one SessionLock may be locked at a time. Attempting to enable a lock while
+	/// > [!WARNING] Only one WlSessionLock may be locked at a time. Attempting to enable a lock while
 	/// > another lock is enabled will do nothing.
 	Q_PROPERTY(bool locked READ isLocked WRITE setLocked NOTIFY lockStateChanged);
 	/// The compositor lock state.
 	///
 	/// This is set to true once the compositor has confirmed all screens are covered with locks.
 	Q_PROPERTY(bool secure READ isSecure NOTIFY secureStateChanged);
-	/// The surface that will be created for each screen. Must create a [SessionLockSurface].
-	///
-	/// [SessionLockSurface]: ../sessionlocksurface
+	/// The surface that will be created for each screen. Must create a @@WlSessionLockSurface$.
 	Q_PROPERTY(QQmlComponent* surface READ surfaceComponent WRITE setSurfaceComponent NOTIFY surfaceComponentChanged);
 	// clang-format on
 	QML_ELEMENT;
 	Q_CLASSINFO("DefaultProperty", "surface");
 
 public:
-	explicit SessionLock(QObject* parent = nullptr): Reloadable(parent) {}
+	explicit WlSessionLock(QObject* parent = nullptr): Reloadable(parent) {}
 
 	void onReload(QObject* oldInstance) override;
 
@@ -97,21 +94,20 @@ private slots:
 	void onScreensChanged();
 
 private:
-	void updateSurfaces(SessionLock* old = nullptr);
+	void updateSurfaces(bool show, WlSessionLock* old = nullptr);
+	void realizeLockTarget(WlSessionLock* old = nullptr);
 
 	SessionLockManager* manager = nullptr;
 	QQmlComponent* mSurfaceComponent = nullptr;
-	QMap<QScreen*, SessionLockSurface*> surfaces;
+	QMap<QScreen*, WlSessionLockSurface*> surfaces;
 	bool lockTarget = false;
 
-	friend class SessionLockSurface;
+	friend class WlSessionLockSurface;
 };
 
-///! Surface to display with a `SessionLock`.
-/// Surface displayed by a [SessionLock] when it is locked.
-///
-/// [SessionLock]: ../sessionlock
-class SessionLockSurface: public Reloadable {
+///! Surface to display with a `WlSessionLock`.
+/// Surface displayed by a @@WlSessionLock when it is locked.
+class WlSessionLockSurface: public Reloadable {
 	Q_OBJECT;
 	// clang-format off
 	Q_PROPERTY(QQuickItem* contentItem READ contentItem);
@@ -142,17 +138,18 @@ class SessionLockSurface: public Reloadable {
 	Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged);
 	Q_PROPERTY(QQmlListProperty<QObject> data READ data);
 	// clang-format on
-	QML_ELEMENT;
+	QML_NAMED_ELEMENT(WlSessionLockSurface);
 	Q_CLASSINFO("DefaultProperty", "data");
 
 public:
-	explicit SessionLockSurface(QObject* parent = nullptr);
-	~SessionLockSurface() override;
-	Q_DISABLE_COPY_MOVE(SessionLockSurface);
+	explicit WlSessionLockSurface(QObject* parent = nullptr);
+	~WlSessionLockSurface() override;
+	Q_DISABLE_COPY_MOVE(WlSessionLockSurface);
 
 	void onReload(QObject* oldInstance) override;
 	QQuickWindow* disownWindow();
 
+	void attach();
 	void show();
 
 	[[nodiscard]] QQuickItem* contentItem() const;
diff --git a/src/wayland/session_lock/CMakeLists.txt b/src/wayland/session_lock/CMakeLists.txt
index 23d90393..d157fc13 100644
--- a/src/wayland/session_lock/CMakeLists.txt
+++ b/src/wayland/session_lock/CMakeLists.txt
@@ -6,7 +6,13 @@ qt_add_library(quickshell-wayland-sessionlock STATIC
 	session_lock.cpp
 )
 
-wl_proto(quickshell-wayland-sessionlock ext-session-lock-v1 "${WAYLAND_PROTOCOLS}/staging/ext-session-lock/ext-session-lock-v1.xml")
-target_link_libraries(quickshell-wayland-sessionlock PRIVATE ${QT_DEPS} wayland-client)
+wl_proto(wlp-session-lock ext-session-lock-v1 "${WAYLAND_PROTOCOLS}/staging/ext-session-lock")
+
+target_link_libraries(quickshell-wayland-sessionlock PRIVATE
+	Qt::Quick Qt::WaylandClient Qt::WaylandClientPrivate wayland-client
+	wlp-session-lock
+)
+
+qs_pch(quickshell-wayland-sessionlock SET large)
 
 target_link_libraries(quickshell-wayland PRIVATE quickshell-wayland-sessionlock)
diff --git a/src/wayland/session_lock/session_lock.cpp b/src/wayland/session_lock/session_lock.cpp
index 4f5fdd58..c32dd90a 100644
--- a/src/wayland/session_lock/session_lock.cpp
+++ b/src/wayland/session_lock/session_lock.cpp
@@ -22,6 +22,8 @@ QSWaylandSessionLockManager* manager() {
 }
 } // namespace
 
+bool SessionLockManager::lockAvailable() { return manager()->isActive(); }
+
 bool SessionLockManager::lock() {
 	if (this->isLocked() || SessionLockManager::sessionLocked()) return false;
 	this->mLock = manager()->acquireLock();
@@ -63,8 +65,11 @@ LockWindowExtension* LockWindowExtension::get(QWindow* window) {
 	}
 }
 
+bool LockWindowExtension::isAttached() const { return this->surface != nullptr; }
+
 bool LockWindowExtension::attach(QWindow* window, SessionLockManager* manager) {
-	if (this->surface != nullptr) throw "Cannot change the attached window of a LockWindowExtension";
+	if (this->surface != nullptr)
+		qFatal() << "Cannot change the attached window of a LockWindowExtension";
 
 	auto* current = LockWindowExtension::get(window);
 	QtWaylandClient::QWaylandWindow* waylandWindow = nullptr;
diff --git a/src/wayland/session_lock/session_lock.hpp b/src/wayland/session_lock/session_lock.hpp
index 7e3968bd..5a558966 100644
--- a/src/wayland/session_lock/session_lock.hpp
+++ b/src/wayland/session_lock/session_lock.hpp
@@ -15,6 +15,8 @@ class SessionLockManager: public QObject {
 public:
 	explicit SessionLockManager(QObject* parent = nullptr): QObject(parent) {}
 
+	[[nodiscard]] static bool lockAvailable();
+
 	// Returns true if a lock was acquired.
 	// If true is returned the caller must watch the global screen list and create/destroy
 	// windows with an attached LockWindowExtension to match it.
@@ -61,6 +63,8 @@ public:
 	~LockWindowExtension() override;
 	Q_DISABLE_COPY_MOVE(LockWindowExtension);
 
+	[[nodiscard]] bool isAttached() const;
+
 	// Attach this lock extension to the given window.
 	// The extension is reparented to the window and replaces any existing lock extension.
 	// Returns false if the window cannot be used.
@@ -70,8 +74,6 @@ public:
 	// To make a window invisible, destroy it as it cannot be recovered.
 	void setVisible();
 
-	[[nodiscard]] bool isLocked() const;
-
 	static LockWindowExtension* get(QWindow* window);
 
 signals:
diff --git a/src/wayland/session_lock/shell_integration.cpp b/src/wayland/session_lock/shell_integration.cpp
index da0e1f1e..2b5fdbfa 100644
--- a/src/wayland/session_lock/shell_integration.cpp
+++ b/src/wayland/session_lock/shell_integration.cpp
@@ -13,7 +13,6 @@ QSWaylandSessionLockIntegration::createShellSurface(QtWaylandClient::QWaylandWin
 	if (lock == nullptr || lock->surface == nullptr || !lock->surface->isExposed()) {
 		qFatal() << "Visibility canary failed. A window with a LockWindowExtension MUST be set to "
 		            "visible via LockWindowExtension::setVisible";
-		throw nullptr;
 	}
 
 	return lock->surface;
diff --git a/src/wayland/session_lock/surface.cpp b/src/wayland/session_lock/surface.cpp
index 31b80991..bc0e75dd 100644
--- a/src/wayland/session_lock/surface.cpp
+++ b/src/wayland/session_lock/surface.cpp
@@ -2,11 +2,11 @@
 
 #include <private/qwaylandscreen_p.h>
 #include <private/qwaylandshellsurface_p.h>
-#include <private/qwaylandshmbackingstore_p.h>
 #include <private/qwaylandsurface_p.h>
 #include <private/qwaylandwindow_p.h>
 #include <qlogging.h>
 #include <qobject.h>
+#include <qtversionchecks.h>
 #include <qtypes.h>
 
 #include "lock.hpp"
@@ -19,12 +19,10 @@ QSWaylandSessionLockSurface::QSWaylandSessionLockSurface(QtWaylandClient::QWayla
 
 	if (this->ext == nullptr) {
 		qFatal() << "QSWaylandSessionLockSurface created with null LockWindowExtension";
-		throw nullptr;
 	}
 
 	if (this->ext->lock == nullptr) {
 		qFatal() << "QSWaylandSessionLock for QSWaylandSessionLockSurface died";
-		throw nullptr;
 	}
 
 	wl_output* output = nullptr; // NOLINT (include)
@@ -34,7 +32,6 @@ QSWaylandSessionLockSurface::QSWaylandSessionLockSurface(QtWaylandClient::QWayla
 		output = waylandScreen->output();
 	} else {
 		qFatal() << "Session lock screen does not corrospond to a real screen. Force closing window";
-		throw nullptr;
 	}
 
 	this->init(this->ext->lock->get_lock_surface(window->waylandSurface()->object(), output));
@@ -84,6 +81,8 @@ void QSWaylandSessionLockSurface::ext_session_lock_surface_v1_configure(
     quint32 width,
     quint32 height
 ) {
+	if (!this->window()) return;
+
 	this->ack_configure(serial);
 
 	this->size = QSize(static_cast<qint32>(width), static_cast<qint32>(height));
@@ -91,7 +90,13 @@ void QSWaylandSessionLockSurface::ext_session_lock_surface_v1_configure(
 		this->configured = true;
 
 		this->window()->resizeFromApplyConfigure(this->size);
+#if QT_VERSION < QT_VERSION_CHECK(6, 7, 0)
 		this->window()->handleExpose(QRect(QPoint(), this->size));
+#elif QT_VERSION < QT_VERSION_CHECK(6, 9, 0)
+		this->window()->sendRecursiveExposeEvent();
+#else
+		this->window()->updateExposure();
+#endif
 		if (this->visible) this->initVisible();
 	} else {
 		// applyConfigureWhenPossible runs too late and causes a protocol error on reconfigure.
@@ -99,6 +104,10 @@ void QSWaylandSessionLockSurface::ext_session_lock_surface_v1_configure(
 	}
 }
 
+#if QT_VERSION < QT_VERSION_CHECK(6, 9, 0)
+
+#include <private/qwaylandshmbackingstore_p.h>
+
 void QSWaylandSessionLockSurface::initVisible() {
 	this->visible = true;
 
@@ -113,3 +122,72 @@ void QSWaylandSessionLockSurface::initVisible() {
 	this->window()->waylandSurface()->attach(this->initBuf->buffer(), 0, 0);
 	this->window()->window()->setVisible(true);
 }
+
+#else
+
+#include <cmath>
+
+#include <private/qwayland-wayland.h>
+#include <private/qwaylanddisplay_p.h>
+#include <qscopedpointer.h>
+#include <qtclasshelpermacros.h>
+#include <qtdeprecationdefinitions.h>
+
+// As of Qt 6.9, a null buffer is unconditionally comitted to the surface. To avoid this, we
+// cast the window to a subclass with access to mSurface, then swap mSurface during
+// QWaylandWindow::initWindow to avoid the null commit.
+
+// Since QWaylandWindow::mSurface is protected and not private, we can just pretend our
+// QWaylandWindow is a subclass that can access it.
+class SurfaceAccessor: public QtWaylandClient::QWaylandWindow {
+public:
+	QScopedPointer<QtWaylandClient::QWaylandSurface>& surfacePointer() { return this->mSurface; }
+};
+
+// QWaylandSurface is not exported, meaning we can't link to its constructor or destructor.
+// As such, the best alternative is to create a class that can take its place during
+// QWaylandWindow::init.
+//
+// Fortunately, QWaylandSurface's superclasses are both exported, and are therefore identical
+// for the purpose of accepting calls during initWindow.
+class HackSurface
+    : public QObject
+    , public QtWayland::wl_surface {
+public:
+	HackSurface(QtWaylandClient::QWaylandDisplay* display)
+	    : wl_surface(display->createSurface(this)) {}
+	~HackSurface() override { this->destroy(); }
+	Q_DISABLE_COPY_MOVE(HackSurface);
+};
+
+void QSWaylandSessionLockSurface::initVisible() {
+	this->visible = true;
+
+	// See note above HackSurface.
+	auto* dummySurface = new HackSurface(this->window()->display());
+	auto* tempSurface =
+	    new QScopedPointer(reinterpret_cast<QtWaylandClient::QWaylandSurface*>(dummySurface));
+
+	auto& surfacePointer = reinterpret_cast<SurfaceAccessor*>(this->window())->surfacePointer();
+
+	// Swap out the surface for a dummy during initWindow.
+	QT_WARNING_PUSH
+	QT_WARNING_DISABLE_DEPRECATED // swap()
+	{
+		surfacePointer.swap(*tempSurface);
+		this->window()->window()->setVisible(true);
+		surfacePointer.swap(*tempSurface);
+	}
+	QT_WARNING_POP
+
+	// Cast to a HackSurface pointer so ~HackSurface is called instead of ~QWaylandSurface.
+	delete reinterpret_cast<QScopedPointer<HackSurface>*>(tempSurface);
+
+	// This would normally be run in QWaylandWindow::initWindow but isn't because we
+	// fed that a dummy surface.
+	if (surfacePointer->version() >= 3) {
+		surfacePointer->set_buffer_scale(std::ceil(this->window()->scale()));
+	}
+}
+
+#endif
diff --git a/src/wayland/toplevel_management/CMakeLists.txt b/src/wayland/toplevel_management/CMakeLists.txt
new file mode 100644
index 00000000..97f8c7a4
--- /dev/null
+++ b/src/wayland/toplevel_management/CMakeLists.txt
@@ -0,0 +1,28 @@
+qt_add_library(quickshell-wayland-toplevel-management STATIC
+	manager.cpp
+	handle.cpp
+	qml.cpp
+)
+
+qt_add_qml_module(quickshell-wayland-toplevel-management
+	URI Quickshell.Wayland._ToplevelManagement
+	VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+qs_add_module_deps_light(quickshell-wayland-toplevel-management
+	Quickshell Quickshell.Wayland
+)
+
+install_qml_module(quickshell-wayland-toplevel-management)
+
+wl_proto(wlp-foreign-toplevel wlr-foreign-toplevel-management-unstable-v1 "${CMAKE_CURRENT_SOURCE_DIR}")
+
+target_link_libraries(quickshell-wayland-toplevel-management PRIVATE
+	Qt::Quick Qt::WaylandClient Qt::WaylandClientPrivate wayland-client
+	wlp-foreign-toplevel
+)
+
+qs_module_pch(quickshell-wayland-toplevel-management SET large)
+
+target_link_libraries(quickshell PRIVATE quickshell-wayland-toplevel-managementplugin)
diff --git a/src/wayland/toplevel_management/handle.cpp b/src/wayland/toplevel_management/handle.cpp
new file mode 100644
index 00000000..914e44ec
--- /dev/null
+++ b/src/wayland/toplevel_management/handle.cpp
@@ -0,0 +1,218 @@
+#include "handle.hpp"
+#include <cstddef>
+
+#include <private/qwaylanddisplay_p.h>
+#include <private/qwaylandinputdevice_p.h>
+#include <private/qwaylandintegration_p.h>
+#include <private/qwaylandscreen_p.h>
+#include <private/qwaylandwindow_p.h>
+#include <qcontainerfwd.h>
+#include <qguiapplication.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qscreen.h>
+#include <qtmetamacros.h>
+#include <wayland-util.h>
+
+#include "manager.hpp"
+#include "qwayland-wlr-foreign-toplevel-management-unstable-v1.h"
+#include "wayland-wlr-foreign-toplevel-management-unstable-v1-client-protocol.h"
+
+namespace qs::wayland::toplevel_management::impl {
+
+QString ToplevelHandle::appId() const { return this->mAppId; }
+QString ToplevelHandle::title() const { return this->mTitle; }
+ToplevelHandle* ToplevelHandle::parent() const { return this->mParent; }
+bool ToplevelHandle::activated() const { return this->mActivated; }
+bool ToplevelHandle::maximized() const { return this->mMaximized; }
+bool ToplevelHandle::minimized() const { return this->mMinimized; }
+bool ToplevelHandle::fullscreen() const { return this->mFullscreen; }
+
+void ToplevelHandle::activate() {
+	auto* display = QtWaylandClient::QWaylandIntegration::instance()->display();
+	auto* inputDevice = display->lastInputDevice();
+	if (inputDevice == nullptr) return;
+	this->QtWayland::zwlr_foreign_toplevel_handle_v1::activate(inputDevice->object());
+}
+
+void ToplevelHandle::setMaximized(bool maximized) {
+	if (maximized) this->set_maximized();
+	else this->unset_maximized();
+}
+
+void ToplevelHandle::setMinimized(bool minimized) {
+	if (minimized) this->set_minimized();
+	else this->unset_minimized();
+}
+
+void ToplevelHandle::setFullscreen(bool fullscreen) {
+	if (fullscreen) this->set_fullscreen(nullptr);
+	else this->unset_fullscreen();
+}
+
+void ToplevelHandle::fullscreenOn(QScreen* screen) {
+	auto* waylandScreen = dynamic_cast<QtWaylandClient::QWaylandScreen*>(screen->handle());
+	this->set_fullscreen(waylandScreen != nullptr ? waylandScreen->output() : nullptr);
+}
+
+void ToplevelHandle::setRectangle(QWindow* window, QRect rect) {
+	if (window == nullptr) {
+		// will be cleared by the compositor if the surface is destroyed
+		if (this->rectWindow != nullptr) {
+			auto* waylandWindow =
+			    dynamic_cast<QtWaylandClient::QWaylandWindow*>(this->rectWindow->handle());
+
+			if (waylandWindow != nullptr) {
+				this->set_rectangle(waylandWindow->surface(), 0, 0, 0, 0);
+			}
+		}
+
+		QObject::disconnect(this->rectWindow, nullptr, this, nullptr);
+		this->rectWindow = nullptr;
+		return;
+	}
+
+	if (this->rectWindow != window) {
+		if (this->rectWindow != nullptr) {
+			QObject::disconnect(this->rectWindow, nullptr, this, nullptr);
+		}
+
+		this->rectWindow = window;
+		QObject::connect(window, &QObject::destroyed, this, &ToplevelHandle::onRectWindowDestroyed);
+	}
+
+	if (auto* waylandWindow = dynamic_cast<QtWaylandClient::QWaylandWindow*>(window->handle())) {
+		this->set_rectangle(waylandWindow->surface(), rect.x(), rect.y(), rect.width(), rect.height());
+	} else {
+		QObject::connect(window, &QWindow::visibleChanged, this, [this, window, rect]() {
+			if (window->isVisible()) {
+				if (window->handle() == nullptr) {
+					window->create();
+				}
+
+				auto* waylandWindow = dynamic_cast<QtWaylandClient::QWaylandWindow*>(window->handle());
+				this->set_rectangle(
+				    waylandWindow->surface(),
+				    rect.x(),
+				    rect.y(),
+				    rect.width(),
+				    rect.height()
+				);
+			}
+		});
+	}
+}
+
+void ToplevelHandle::onRectWindowDestroyed() { this->rectWindow = nullptr; }
+
+void ToplevelHandle::zwlr_foreign_toplevel_handle_v1_done() {
+	qCDebug(logToplevelManagement) << this << "got done";
+	auto wasReady = this->isReady;
+	this->isReady = true;
+
+	if (!wasReady) {
+		emit this->ready();
+	}
+}
+
+void ToplevelHandle::zwlr_foreign_toplevel_handle_v1_closed() {
+	qCDebug(logToplevelManagement) << this << "closed";
+	this->destroy();
+	emit this->closed();
+	delete this;
+}
+
+void ToplevelHandle::zwlr_foreign_toplevel_handle_v1_app_id(const QString& appId) {
+	qCDebug(logToplevelManagement) << this << "got appid" << appId;
+	this->mAppId = appId;
+	emit this->appIdChanged();
+}
+
+void ToplevelHandle::zwlr_foreign_toplevel_handle_v1_title(const QString& title) {
+	qCDebug(logToplevelManagement) << this << "got toplevel" << title;
+	this->mTitle = title;
+	emit this->titleChanged();
+}
+
+void ToplevelHandle::zwlr_foreign_toplevel_handle_v1_state(wl_array* stateArray) {
+	auto activated = false;
+	auto maximized = false;
+	auto minimized = false;
+	auto fullscreen = false;
+
+	// wl_array_for_each is illegal in C++ so it is manually expanded.
+	auto* state = static_cast<::zwlr_foreign_toplevel_handle_v1_state*>(stateArray->data);
+	auto size = stateArray->size / sizeof(::zwlr_foreign_toplevel_handle_v1_state);
+	for (size_t i = 0; i < size; i++) {
+		auto flag = state[i]; // NOLINT
+		switch (flag) {
+		case ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_ACTIVATED: activated = true; break;
+		case ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MAXIMIZED: maximized = true; break;
+		case ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MINIMIZED: minimized = true; break;
+		case ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_FULLSCREEN: fullscreen = true; break;
+		}
+	}
+
+	qCDebug(logToplevelManagement) << this << "got state update - activated:" << activated
+	                               << "maximized:" << maximized << "minimized:" << minimized
+	                               << "fullscreen:" << fullscreen;
+
+	if (activated != this->mActivated) {
+		this->mActivated = activated;
+		emit this->activatedChanged();
+	}
+
+	if (maximized != this->mMaximized) {
+		this->mMaximized = maximized;
+		emit this->maximizedChanged();
+	}
+
+	if (minimized != this->mMinimized) {
+		this->mMinimized = minimized;
+		emit this->minimizedChanged();
+	}
+
+	if (fullscreen != this->mFullscreen) {
+		this->mFullscreen = fullscreen;
+		emit this->fullscreenChanged();
+	}
+}
+
+void ToplevelHandle::zwlr_foreign_toplevel_handle_v1_output_enter(wl_output* output) {
+	qCDebug(logToplevelManagement) << this << "got output enter" << output;
+	this->visibleScreens.addOutput(output);
+}
+
+void ToplevelHandle::zwlr_foreign_toplevel_handle_v1_output_leave(wl_output* output) {
+	qCDebug(logToplevelManagement) << this << "got output leave" << output;
+	this->visibleScreens.removeOutput(output);
+}
+
+void ToplevelHandle::zwlr_foreign_toplevel_handle_v1_parent(
+    ::zwlr_foreign_toplevel_handle_v1* parent
+) {
+	auto* handle = ToplevelManager::instance()->handleFor(parent);
+	qCDebug(logToplevelManagement) << this << "got parent" << handle;
+
+	if (handle != this->mParent) {
+		if (this->mParent != nullptr) {
+			QObject::disconnect(this->mParent, nullptr, this, nullptr);
+		}
+
+		this->mParent = handle;
+
+		if (handle != nullptr) {
+			QObject::connect(handle, &ToplevelHandle::closed, this, &ToplevelHandle::onParentClosed);
+		}
+
+		emit this->parentChanged();
+	}
+}
+
+void ToplevelHandle::onParentClosed() {
+	this->mParent = nullptr;
+	emit this->parentChanged();
+}
+
+} // namespace qs::wayland::toplevel_management::impl
diff --git a/src/wayland/toplevel_management/handle.hpp b/src/wayland/toplevel_management/handle.hpp
new file mode 100644
index 00000000..92531a5a
--- /dev/null
+++ b/src/wayland/toplevel_management/handle.hpp
@@ -0,0 +1,76 @@
+#pragma once
+
+#include <qobject.h>
+#include <qscreen.h>
+#include <qtmetamacros.h>
+#include <qwayland-wlr-foreign-toplevel-management-unstable-v1.h>
+#include <qwindow.h>
+
+#include "../output_tracking.hpp"
+#include "wayland-wlr-foreign-toplevel-management-unstable-v1-client-protocol.h"
+
+namespace qs::wayland::toplevel_management::impl {
+
+class ToplevelHandle
+    : public QObject
+    , public QtWayland::zwlr_foreign_toplevel_handle_v1 {
+	Q_OBJECT;
+
+public:
+	[[nodiscard]] QString appId() const;
+	[[nodiscard]] QString title() const;
+	[[nodiscard]] ToplevelHandle* parent() const;
+	[[nodiscard]] bool activated() const;
+	[[nodiscard]] bool maximized() const;
+	[[nodiscard]] bool minimized() const;
+	[[nodiscard]] bool fullscreen() const;
+
+	void activate();
+	void setMaximized(bool maximized);
+	void setMinimized(bool minimized);
+	void setFullscreen(bool fullscreen);
+	void fullscreenOn(QScreen* screen);
+	void setRectangle(QWindow* window, QRect rect);
+
+	WlOutputTracker visibleScreens;
+
+signals:
+	// sent after the first done event.
+	void ready();
+	// sent right before delete this.
+	void closed();
+
+	void appIdChanged();
+	void titleChanged();
+	void parentChanged();
+	void activatedChanged();
+	void maximizedChanged();
+	void minimizedChanged();
+	void fullscreenChanged();
+
+private slots:
+	void onParentClosed();
+	void onRectWindowDestroyed();
+
+private:
+	void zwlr_foreign_toplevel_handle_v1_done() override;
+	void zwlr_foreign_toplevel_handle_v1_closed() override;
+	void zwlr_foreign_toplevel_handle_v1_app_id(const QString& appId) override;
+	void zwlr_foreign_toplevel_handle_v1_title(const QString& title) override;
+	void zwlr_foreign_toplevel_handle_v1_state(wl_array* stateArray) override;
+	void zwlr_foreign_toplevel_handle_v1_output_enter(wl_output* output) override;
+	void zwlr_foreign_toplevel_handle_v1_output_leave(wl_output* output) override;
+	void zwlr_foreign_toplevel_handle_v1_parent(::zwlr_foreign_toplevel_handle_v1* parent) override;
+
+	bool isReady = false;
+	QString mAppId;
+	QString mTitle;
+	ToplevelHandle* mParent = nullptr;
+	bool mActivated = false;
+	bool mMaximized = false;
+	bool mMinimized = false;
+	bool mFullscreen = false;
+	QWindow* rectWindow = nullptr;
+};
+
+} // namespace qs::wayland::toplevel_management::impl
diff --git a/src/wayland/toplevel_management/manager.cpp b/src/wayland/toplevel_management/manager.cpp
new file mode 100644
index 00000000..471d7e20
--- /dev/null
+++ b/src/wayland/toplevel_management/manager.cpp
@@ -0,0 +1,68 @@
+#include "manager.hpp"
+
+#include <qcontainerfwd.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+#include <qwaylandclientextension.h>
+
+#include "../../core/logcat.hpp"
+#include "handle.hpp"
+#include "wayland-wlr-foreign-toplevel-management-unstable-v1-client-protocol.h"
+
+namespace qs::wayland::toplevel_management::impl {
+
+QS_LOGGING_CATEGORY(logToplevelManagement, "quickshell.wayland.toplevelManagement", QtWarningMsg);
+
+ToplevelManager::ToplevelManager(): QWaylandClientExtensionTemplate(3) { this->initialize(); }
+
+bool ToplevelManager::available() const { return this->isActive(); }
+
+const QVector<ToplevelHandle*>& ToplevelManager::readyToplevels() const {
+	return this->mReadyToplevels;
+}
+
+ToplevelHandle* ToplevelManager::handleFor(::zwlr_foreign_toplevel_handle_v1* toplevel) {
+	if (toplevel == nullptr) return nullptr;
+
+	for (auto* other: this->mToplevels) {
+		if (other->object() == toplevel) return other;
+	}
+
+	return nullptr;
+}
+
+ToplevelManager* ToplevelManager::instance() {
+	static auto* instance = new ToplevelManager(); // NOLINT
+	return instance;
+}
+
+void ToplevelManager::zwlr_foreign_toplevel_manager_v1_toplevel(
+    ::zwlr_foreign_toplevel_handle_v1* toplevel
+) {
+	auto* handle = new ToplevelHandle();
+	QObject::connect(handle, &ToplevelHandle::closed, this, &ToplevelManager::onToplevelClosed);
+	QObject::connect(handle, &ToplevelHandle::ready, this, &ToplevelManager::onToplevelReady);
+
+	qCDebug(logToplevelManagement) << "Toplevel handle created" << handle;
+	this->mToplevels.push_back(handle);
+
+	// Not done in constructor as a close could technically be picked up immediately on init,
+	// making touching the handle a UAF.
+	handle->init(toplevel);
+}
+
+void ToplevelManager::onToplevelReady() {
+	auto* handle = qobject_cast<ToplevelHandle*>(this->sender());
+	this->mReadyToplevels.push_back(handle);
+	emit this->toplevelReady(handle);
+}
+
+void ToplevelManager::onToplevelClosed() {
+	auto* handle = qobject_cast<ToplevelHandle*>(this->sender());
+	this->mReadyToplevels.removeOne(handle);
+	this->mToplevels.removeOne(handle);
+}
+
+} // namespace qs::wayland::toplevel_management::impl
diff --git a/src/wayland/toplevel_management/manager.hpp b/src/wayland/toplevel_management/manager.hpp
new file mode 100644
index 00000000..4b906a59
--- /dev/null
+++ b/src/wayland/toplevel_management/manager.hpp
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qloggingcategory.h>
+#include <qtmetamacros.h>
+#include <qwayland-wlr-foreign-toplevel-management-unstable-v1.h>
+#include <qwaylandclientextension.h>
+
+#include "../../core/logcat.hpp"
+#include "wayland-wlr-foreign-toplevel-management-unstable-v1-client-protocol.h"
+
+namespace qs::wayland::toplevel_management::impl {
+
+class ToplevelHandle;
+
+QS_DECLARE_LOGGING_CATEGORY(logToplevelManagement);
+
+class ToplevelManager
+    : public QWaylandClientExtensionTemplate<ToplevelManager>
+    , public QtWayland::zwlr_foreign_toplevel_manager_v1 {
+	Q_OBJECT;
+
+public:
+	[[nodiscard]] bool available() const;
+	[[nodiscard]] const QVector<ToplevelHandle*>& readyToplevels() const;
+	[[nodiscard]] ToplevelHandle* handleFor(::zwlr_foreign_toplevel_handle_v1* toplevel);
+
+	static ToplevelManager* instance();
+
+signals:
+	void toplevelReady(ToplevelHandle* toplevel);
+
+protected:
+	explicit ToplevelManager();
+
+	void zwlr_foreign_toplevel_manager_v1_toplevel(::zwlr_foreign_toplevel_handle_v1* toplevel
+	) override;
+
+private slots:
+	void onToplevelReady();
+	void onToplevelClosed();
+
+private:
+	QVector<ToplevelHandle*> mToplevels;
+	QVector<ToplevelHandle*> mReadyToplevels;
+};
+
+} // namespace qs::wayland::toplevel_management::impl
diff --git a/src/wayland/toplevel_management/qml.cpp b/src/wayland/toplevel_management/qml.cpp
new file mode 100644
index 00000000..0eae3de6
--- /dev/null
+++ b/src/wayland/toplevel_management/qml.cpp
@@ -0,0 +1,197 @@
+#include "qml.hpp"
+
+#include <qlist.h>
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+#include "../../core/model.hpp"
+#include "../../core/qmlglobal.hpp"
+#include "../../core/qmlscreen.hpp"
+#include "../../core/util.hpp"
+#include "../../window/proxywindow.hpp"
+#include "../../window/windowinterface.hpp"
+#include "../output_tracking.hpp"
+#include "handle.hpp"
+#include "manager.hpp"
+
+namespace qs::wayland::toplevel_management {
+
+Toplevel::Toplevel(impl::ToplevelHandle* handle, QObject* parent): QObject(parent), handle(handle) {
+	// clang-format off
+	QObject::connect(handle, &impl::ToplevelHandle::closed, this, &Toplevel::onClosed);
+	QObject::connect(handle, &impl::ToplevelHandle::appIdChanged, this, &Toplevel::appIdChanged);
+	QObject::connect(handle, &impl::ToplevelHandle::titleChanged, this, &Toplevel::titleChanged);
+	QObject::connect(handle, &impl::ToplevelHandle::parentChanged, this, &Toplevel::parentChanged);
+	QObject::connect(handle, &impl::ToplevelHandle::activatedChanged, this, &Toplevel::activatedChanged);
+	QObject::connect(&handle->visibleScreens, &WlOutputTracker::screenAdded, this, &Toplevel::screensChanged);
+	QObject::connect(&handle->visibleScreens, &WlOutputTracker::screenRemoved, this, &Toplevel::screensChanged);
+	QObject::connect(handle, &impl::ToplevelHandle::maximizedChanged, this, &Toplevel::maximizedChanged);
+	QObject::connect(handle, &impl::ToplevelHandle::minimizedChanged, this, &Toplevel::minimizedChanged);
+	QObject::connect(handle, &impl::ToplevelHandle::fullscreenChanged, this, &Toplevel::fullscreenChanged);
+	// clang-format on
+}
+
+void Toplevel::onClosed() {
+	emit this->closed();
+	delete this;
+}
+
+void Toplevel::activate() { this->handle->activate(); }
+void Toplevel::close() { this->handle->close(); }
+
+QString Toplevel::appId() const { return this->handle->appId(); }
+QString Toplevel::title() const { return this->handle->title(); }
+
+Toplevel* Toplevel::parent() const {
+	return ToplevelManager::instance()->forImpl(this->handle->parent());
+}
+
+bool Toplevel::activated() const { return this->handle->activated(); }
+
+QList<QuickshellScreenInfo*> Toplevel::screens() const {
+	QList<QuickshellScreenInfo*> screens;
+
+	for (auto* screen: this->handle->visibleScreens.screens()) {
+		screens.push_back(QuickshellTracked::instance()->screenInfo(screen));
+	}
+
+	return screens;
+}
+
+bool Toplevel::maximized() const { return this->handle->maximized(); }
+void Toplevel::setMaximized(bool maximized) { this->handle->setMaximized(maximized); }
+
+bool Toplevel::minimized() const { return this->handle->minimized(); }
+void Toplevel::setMinimized(bool minimized) { this->handle->setMinimized(minimized); }
+
+bool Toplevel::fullscreen() const { return this->handle->fullscreen(); }
+void Toplevel::setFullscreen(bool fullscreen) { this->handle->setFullscreen(fullscreen); }
+
+void Toplevel::fullscreenOn(QuickshellScreenInfo* screen) {
+	auto* qscreen = screen != nullptr ? screen->screen : nullptr;
+	this->handle->fullscreenOn(qscreen);
+}
+
+void Toplevel::setRectangle(QObject* window, QRect rect) {
+	auto* proxyWindow = qobject_cast<ProxyWindowBase*>(window);
+
+	if (proxyWindow == nullptr) {
+		if (auto* iface = qobject_cast<WindowInterface*>(window)) {
+			proxyWindow = iface->proxyWindow();
+		}
+	}
+
+	if (proxyWindow != this->rectWindow) {
+		if (this->rectWindow != nullptr) {
+			QObject::disconnect(this->rectWindow, nullptr, this, nullptr);
+		}
+
+		this->rectWindow = proxyWindow;
+
+		if (proxyWindow != nullptr) {
+			QObject::connect(
+			    proxyWindow,
+			    &QObject::destroyed,
+			    this,
+			    &Toplevel::onRectangleProxyDestroyed
+			);
+
+			QObject::connect(
+			    proxyWindow,
+			    &ProxyWindowBase::windowConnected,
+			    this,
+			    &Toplevel::onRectangleProxyConnected
+			);
+		}
+	}
+
+	this->rectangle = rect;
+	this->handle->setRectangle(proxyWindow->backingWindow(), rect);
+}
+
+void Toplevel::unsetRectangle() { this->setRectangle(nullptr, QRect()); }
+
+void Toplevel::onRectangleProxyConnected() {
+	this->handle->setRectangle(this->rectWindow->backingWindow(), this->rectangle);
+}
+
+void Toplevel::onRectangleProxyDestroyed() {
+	this->rectWindow = nullptr;
+	this->rectangle = QRect();
+}
+
+ToplevelManager::ToplevelManager() {
+	auto* manager = impl::ToplevelManager::instance();
+
+	QObject::connect(
+	    manager,
+	    &impl::ToplevelManager::toplevelReady,
+	    this,
+	    &ToplevelManager::onToplevelReady
+	);
+
+	for (auto* handle: manager->readyToplevels()) {
+		this->onToplevelReady(handle);
+	}
+}
+
+Toplevel* ToplevelManager::forImpl(impl::ToplevelHandle* impl) const {
+	if (impl == nullptr) return nullptr;
+
+	for (auto* toplevel: this->mToplevels.valueList()) {
+		if (toplevel->handle == impl) return toplevel;
+	}
+
+	return nullptr;
+}
+
+ObjectModel<Toplevel>* ToplevelManager::toplevels() { return &this->mToplevels; }
+
+void ToplevelManager::onToplevelReady(impl::ToplevelHandle* handle) {
+	auto* toplevel = new Toplevel(handle, this);
+
+	// clang-format off
+	QObject::connect(toplevel, &Toplevel::closed, this, &ToplevelManager::onToplevelClosed);
+	QObject::connect(toplevel, &Toplevel::activatedChanged, this, &ToplevelManager::onToplevelActiveChanged);
+	// clang-format on
+
+	if (toplevel->activated()) this->setActiveToplevel(toplevel);
+	this->mToplevels.insertObject(toplevel);
+}
+
+void ToplevelManager::onToplevelActiveChanged() {
+	auto* toplevel = qobject_cast<Toplevel*>(this->sender());
+	if (toplevel->activated()) this->setActiveToplevel(toplevel);
+}
+
+void ToplevelManager::onToplevelClosed() {
+	auto* toplevel = qobject_cast<Toplevel*>(this->sender());
+	if (toplevel == this->mActiveToplevel) this->setActiveToplevel(nullptr);
+	this->mToplevels.removeObject(toplevel);
+}
+
+DEFINE_MEMBER_GETSET(ToplevelManager, activeToplevel, setActiveToplevel);
+
+ToplevelManager* ToplevelManager::instance() {
+	static auto* instance = new ToplevelManager(); // NOLINT
+	return instance;
+}
+
+ToplevelManagerQml::ToplevelManagerQml(QObject* parent): QObject(parent) {
+	QObject::connect(
+	    ToplevelManager::instance(),
+	    &ToplevelManager::activeToplevelChanged,
+	    this,
+	    &ToplevelManagerQml::activeToplevelChanged
+	);
+}
+
+ObjectModel<Toplevel>* ToplevelManagerQml::toplevels() {
+	return ToplevelManager::instance()->toplevels();
+}
+
+Toplevel* ToplevelManagerQml::activeToplevel() {
+	return ToplevelManager::instance()->activeToplevel();
+}
+
+} // namespace qs::wayland::toplevel_management
diff --git a/src/wayland/toplevel_management/qml.hpp b/src/wayland/toplevel_management/qml.hpp
new file mode 100644
index 00000000..5ca189bf
--- /dev/null
+++ b/src/wayland/toplevel_management/qml.hpp
@@ -0,0 +1,182 @@
+#pragma once
+
+#include <qlist.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+
+#include "../../core/doc.hpp"
+#include "../../core/model.hpp"
+#include "../../core/qmlscreen.hpp"
+#include "../../core/util.hpp"
+#include "../../window/proxywindow.hpp"
+
+namespace qs::wayland::toplevel_management {
+
+namespace impl {
+class ToplevelManager; // NOLINT
+class ToplevelHandle;
+} // namespace impl
+
+///! Window from another application.
+/// A window/toplevel from another application, retrievable from
+/// the @@ToplevelManager.
+class Toplevel: public QObject {
+	Q_OBJECT;
+	Q_PROPERTY(QString appId READ appId NOTIFY appIdChanged);
+	Q_PROPERTY(QString title READ title NOTIFY titleChanged);
+	/// Parent toplevel if this toplevel is a modal/dialog, otherwise null.
+	Q_PROPERTY(qs::wayland::toplevel_management::Toplevel* parent READ parent NOTIFY parentChanged);
+	/// If the window is currently activated or focused.
+	///
+	/// Activation can be requested with the @@activate() function.
+	Q_PROPERTY(bool activated READ activated NOTIFY activatedChanged);
+	/// Screens the toplevel is currently visible on.
+	/// Screens are listed in the order they have been added by the compositor.
+	///
+	/// > [!NOTE]	Some compositors only list a single screen, even if a window is visible on multiple.
+	Q_PROPERTY(QList<QuickshellScreenInfo*> screens READ screens NOTIFY screensChanged);
+	/// If the window is currently maximized.
+	///
+	/// Maximization can be requested by setting this property, though it may
+	/// be ignored by the compositor.
+	Q_PROPERTY(bool maximized READ maximized WRITE setMaximized NOTIFY maximizedChanged);
+	/// If the window is currently minimized.
+	///
+	/// Minimization can be requested by setting this property, though it may
+	/// be ignored by the compositor.
+	Q_PROPERTY(bool minimized READ minimized WRITE setMinimized NOTIFY minimizedChanged);
+	/// If the window is currently fullscreen.
+	///
+	/// Fullscreen can be requested by setting this property, though it may
+	/// be ignored by the compositor.
+	/// Fullscreen can be requested on a specific screen with the @@fullscreenOn() function.
+	Q_PROPERTY(bool fullscreen READ fullscreen WRITE setFullscreen NOTIFY fullscreenChanged);
+	QML_ELEMENT;
+	QML_UNCREATABLE("Toplevels must be acquired from the ToplevelManager.");
+
+public:
+	explicit Toplevel(impl::ToplevelHandle* handle, QObject* parent);
+
+	/// Request that this toplevel is activated.
+	/// The request may be ignored by the compositor.
+	Q_INVOKABLE void activate();
+
+	/// Request that this toplevel is closed.
+	/// The request may be ignored by the compositor or the application.
+	Q_INVOKABLE void close();
+
+	/// Request that this toplevel is fullscreened on a specific screen.
+	/// The request may be ignored by the compositor.
+	Q_INVOKABLE void fullscreenOn(QuickshellScreenInfo* screen);
+
+	/// Provide a hint to the compositor where the visual representation
+	/// of this toplevel is relative to a quickshell window.
+	/// This hint can be used visually in operations like minimization.
+	Q_INVOKABLE void setRectangle(QObject* window, QRect rect);
+	Q_INVOKABLE void unsetRectangle();
+
+	[[nodiscard]] QString appId() const;
+	[[nodiscard]] QString title() const;
+	[[nodiscard]] Toplevel* parent() const;
+	[[nodiscard]] bool activated() const;
+	[[nodiscard]] QList<QuickshellScreenInfo*> screens() const;
+
+	[[nodiscard]] bool maximized() const;
+	void setMaximized(bool maximized);
+
+	[[nodiscard]] bool minimized() const;
+	void setMinimized(bool minimized);
+
+	[[nodiscard]] bool fullscreen() const;
+	void setFullscreen(bool fullscreen);
+
+	[[nodiscard]] impl::ToplevelHandle* implHandle() const { return this->handle; }
+
+signals:
+	void closed();
+	void appIdChanged();
+	void titleChanged();
+	void parentChanged();
+	void activatedChanged();
+	void screensChanged();
+	void maximizedChanged();
+	void minimizedChanged();
+	void fullscreenChanged();
+
+private slots:
+	void onClosed();
+	void onRectangleProxyConnected();
+	void onRectangleProxyDestroyed();
+
+private:
+	impl::ToplevelHandle* handle;
+	ProxyWindowBase* rectWindow = nullptr;
+	QRect rectangle;
+
+	friend class ToplevelManager;
+};
+
+class ToplevelManager: public QObject {
+	Q_OBJECT;
+
+public:
+	Toplevel* forImpl(impl::ToplevelHandle* impl) const;
+
+	[[nodiscard]] ObjectModel<Toplevel>* toplevels();
+
+	static ToplevelManager* instance();
+
+signals:
+	void activeToplevelChanged();
+
+private slots:
+	void onToplevelReady(impl::ToplevelHandle* handle);
+	void onToplevelActiveChanged();
+	void onToplevelClosed();
+
+private:
+	explicit ToplevelManager();
+
+	ObjectModel<Toplevel> mToplevels {this};
+	Toplevel* mActiveToplevel = nullptr;
+
+	DECLARE_PRIVATE_MEMBER(
+	    ToplevelManager,
+	    activeToplevel,
+	    setActiveToplevel,
+	    mActiveToplevel,
+	    activeToplevelChanged
+	);
+};
+
+///! Exposes a list of Toplevels.
+/// Exposes a list of windows from other applications as @@Toplevel$s via the
+/// [zwlr-foreign-toplevel-management-v1](https://wayland.app/protocols/wlr-foreign-toplevel-management-unstable-v1)
+/// wayland protocol.
+class ToplevelManagerQml: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// All toplevel windows exposed by the compositor.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::wayland::toplevel_management::Toplevel>*);
+	Q_PROPERTY(UntypedObjectModel* toplevels READ toplevels CONSTANT);
+	/// Active toplevel or null.
+	///
+	/// > [!INFO] If multiple are active, this will be the most recently activated one.
+	/// > Usually compositors will not report more than one toplevel as active at a time.
+	Q_PROPERTY(qs::wayland::toplevel_management::Toplevel* activeToplevel READ activeToplevel NOTIFY activeToplevelChanged);
+	// clang-format on
+	QML_NAMED_ELEMENT(ToplevelManager);
+	QML_SINGLETON;
+
+public:
+	explicit ToplevelManagerQml(QObject* parent = nullptr);
+
+	[[nodiscard]] static ObjectModel<Toplevel>* toplevels();
+	[[nodiscard]] static Toplevel* activeToplevel();
+
+signals:
+	void activeToplevelChanged();
+};
+
+} // namespace qs::wayland::toplevel_management
diff --git a/src/wayland/toplevel_management/wlr-foreign-toplevel-management-unstable-v1.xml b/src/wayland/toplevel_management/wlr-foreign-toplevel-management-unstable-v1.xml
new file mode 100644
index 00000000..44505bbb
--- /dev/null
+++ b/src/wayland/toplevel_management/wlr-foreign-toplevel-management-unstable-v1.xml
@@ -0,0 +1,270 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wlr_foreign_toplevel_management_unstable_v1">
+  <copyright>
+    Copyright © 2018 Ilia Bozhinov
+
+    Permission to use, copy, modify, distribute, and sell this
+    software and its documentation for any purpose is hereby granted
+    without fee, provided that the above copyright notice appear in
+    all copies and that both that copyright notice and this permission
+    notice appear in supporting documentation, and that the name of
+    the copyright holders not be used in advertising or publicity
+    pertaining to distribution of the software without specific,
+    written prior permission.  The copyright holders make no
+    representations about the suitability of this software for any
+    purpose.  It is provided "as is" without express or implied
+    warranty.
+
+    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+    THIS SOFTWARE.
+  </copyright>
+
+  <interface name="zwlr_foreign_toplevel_manager_v1" version="3">
+    <description summary="list and control opened apps">
+      The purpose of this protocol is to enable the creation of taskbars
+      and docks by providing them with a list of opened applications and
+      letting them request certain actions on them, like maximizing, etc.
+
+      After a client binds the zwlr_foreign_toplevel_manager_v1, each opened
+      toplevel window will be sent via the toplevel event
+    </description>
+
+    <event name="toplevel">
+      <description summary="a toplevel has been created">
+        This event is emitted whenever a new toplevel window is created. It
+        is emitted for all toplevels, regardless of the app that has created
+        them.
+
+        All initial details of the toplevel(title, app_id, states, etc.) will
+        be sent immediately after this event via the corresponding events in
+        zwlr_foreign_toplevel_handle_v1.
+      </description>
+      <arg name="toplevel" type="new_id" interface="zwlr_foreign_toplevel_handle_v1"/>
+    </event>
+
+    <request name="stop">
+      <description summary="stop sending events">
+        Indicates the client no longer wishes to receive events for new toplevels.
+        However the compositor may emit further toplevel_created events, until
+        the finished event is emitted.
+
+        The client must not send any more requests after this one.
+      </description>
+    </request>
+
+    <event name="finished" type="destructor">
+      <description summary="the compositor has finished with the toplevel manager">
+        This event indicates that the compositor is done sending events to the
+        zwlr_foreign_toplevel_manager_v1. The server will destroy the object
+        immediately after sending this request, so it will become invalid and
+        the client should free any resources associated with it.
+      </description>
+    </event>
+  </interface>
+
+  <interface name="zwlr_foreign_toplevel_handle_v1" version="3">
+    <description summary="an opened toplevel">
+      A zwlr_foreign_toplevel_handle_v1 object represents an opened toplevel
+      window. Each app may have multiple opened toplevels.
+
+      Each toplevel has a list of outputs it is visible on, conveyed to the
+      client with the output_enter and output_leave events.
+    </description>
+
+    <event name="title">
+      <description summary="title change">
+        This event is emitted whenever the title of the toplevel changes.
+      </description>
+      <arg name="title" type="string"/>
+    </event>
+
+    <event name="app_id">
+      <description summary="app-id change">
+        This event is emitted whenever the app-id of the toplevel changes.
+      </description>
+      <arg name="app_id" type="string"/>
+    </event>
+
+    <event name="output_enter">
+      <description summary="toplevel entered an output">
+        This event is emitted whenever the toplevel becomes visible on
+        the given output. A toplevel may be visible on multiple outputs.
+      </description>
+      <arg name="output" type="object" interface="wl_output"/>
+    </event>
+
+    <event name="output_leave">
+      <description summary="toplevel left an output">
+        This event is emitted whenever the toplevel stops being visible on
+        the given output. It is guaranteed that an entered-output event
+        with the same output has been emitted before this event.
+      </description>
+      <arg name="output" type="object" interface="wl_output"/>
+    </event>
+
+    <request name="set_maximized">
+      <description summary="requests that the toplevel be maximized">
+        Requests that the toplevel be maximized. If the maximized state actually
+        changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <request name="unset_maximized">
+      <description summary="requests that the toplevel be unmaximized">
+        Requests that the toplevel be unmaximized. If the maximized state actually
+        changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <request name="set_minimized">
+      <description summary="requests that the toplevel be minimized">
+        Requests that the toplevel be minimized. If the minimized state actually
+        changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <request name="unset_minimized">
+      <description summary="requests that the toplevel be unminimized">
+        Requests that the toplevel be unminimized. If the minimized state actually
+        changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <request name="activate">
+      <description summary="activate the toplevel">
+        Request that this toplevel be activated on the given seat.
+        There is no guarantee the toplevel will be actually activated.
+      </description>
+      <arg name="seat" type="object" interface="wl_seat"/>
+    </request>
+
+    <enum name="state">
+      <description summary="types of states on the toplevel">
+        The different states that a toplevel can have. These have the same meaning
+        as the states with the same names defined in xdg-toplevel
+      </description>
+
+      <entry name="maximized"  value="0" summary="the toplevel is maximized"/>
+      <entry name="minimized"  value="1" summary="the toplevel is minimized"/>
+      <entry name="activated"  value="2" summary="the toplevel is active"/>
+      <entry name="fullscreen" value="3" summary="the toplevel is fullscreen" since="2"/>
+    </enum>
+
+    <event name="state">
+      <description summary="the toplevel state changed">
+        This event is emitted immediately after the zlw_foreign_toplevel_handle_v1
+        is created and each time the toplevel state changes, either because of a
+        compositor action or because of a request in this protocol.
+      </description>
+
+      <arg name="state" type="array"/>
+    </event>
+
+    <event name="done">
+      <description summary="all information about the toplevel has been sent">
+        This event is sent after all changes in the toplevel state have been
+        sent.
+
+        This allows changes to the zwlr_foreign_toplevel_handle_v1 properties
+        to be seen as atomic, even if they happen via multiple events.
+      </description>
+    </event>
+
+    <request name="close">
+      <description summary="request that the toplevel be closed">
+        Send a request to the toplevel to close itself. The compositor would
+        typically use a shell-specific method to carry out this request, for
+        example by sending the xdg_toplevel.close event. However, this gives
+        no guarantees the toplevel will actually be destroyed. If and when
+        this happens, the zwlr_foreign_toplevel_handle_v1.closed event will
+        be emitted.
+      </description>
+    </request>
+
+    <request name="set_rectangle">
+      <description summary="the rectangle which represents the toplevel">
+        The rectangle of the surface specified in this request corresponds to
+        the place where the app using this protocol represents the given toplevel.
+        It can be used by the compositor as a hint for some operations, e.g
+        minimizing. The client is however not required to set this, in which
+        case the compositor is free to decide some default value.
+
+        If the client specifies more than one rectangle, only the last one is
+        considered.
+
+        The dimensions are given in surface-local coordinates.
+        Setting width=height=0 removes the already-set rectangle.
+      </description>
+
+      <arg name="surface" type="object" interface="wl_surface"/>
+      <arg name="x" type="int"/>
+      <arg name="y" type="int"/>
+      <arg name="width" type="int"/>
+      <arg name="height" type="int"/>
+    </request>
+
+    <enum name="error">
+      <entry name="invalid_rectangle" value="0"
+        summary="the provided rectangle is invalid"/>
+    </enum>
+
+    <event name="closed">
+      <description summary="this toplevel has been destroyed">
+        This event means the toplevel has been destroyed. It is guaranteed there
+        won't be any more events for this zwlr_foreign_toplevel_handle_v1. The
+        toplevel itself becomes inert so any requests will be ignored except the
+        destroy request.
+      </description>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the zwlr_foreign_toplevel_handle_v1 object">
+        Destroys the zwlr_foreign_toplevel_handle_v1 object.
+
+        This request should be called either when the client does not want to
+        use the toplevel anymore or after the closed event to finalize the
+        destruction of the object.
+      </description>
+    </request>
+
+    <!-- Version 2 additions -->
+
+    <request name="set_fullscreen" since="2">
+      <description summary="request that the toplevel be fullscreened">
+        Requests that the toplevel be fullscreened on the given output. If the
+        fullscreen state and/or the outputs the toplevel is visible on actually
+        change, this will be indicated by the state and output_enter/leave
+        events.
+
+        The output parameter is only a hint to the compositor. Also, if output
+        is NULL, the compositor should decide which output the toplevel will be
+        fullscreened on, if at all.
+      </description>
+      <arg name="output" type="object" interface="wl_output" allow-null="true"/>
+    </request>
+
+    <request name="unset_fullscreen" since="2">
+      <description summary="request that the toplevel be unfullscreened">
+        Requests that the toplevel be unfullscreened. If the fullscreen state
+        actually changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <!-- Version 3 additions -->
+
+    <event name="parent" since="3">
+      <description summary="parent change">
+        This event is emitted whenever the parent of the toplevel changes.
+
+        No event is emitted when the parent handle is destroyed by the client.
+      </description>
+      <arg name="parent" type="object" interface="zwlr_foreign_toplevel_handle_v1" allow-null="true"/>
+    </event>
+  </interface>
+</protocol>
diff --git a/src/wayland/util.cpp b/src/wayland/util.cpp
new file mode 100644
index 00000000..abcf8a4d
--- /dev/null
+++ b/src/wayland/util.cpp
@@ -0,0 +1,9 @@
+#include "util.hpp"
+
+#include "../window/proxywindow.hpp"
+
+namespace qs::wayland::util {
+
+void scheduleCommit(ProxyWindowBase* window) { window->schedulePolish(); }
+
+} // namespace qs::wayland::util
diff --git a/src/wayland/util.hpp b/src/wayland/util.hpp
new file mode 100644
index 00000000..aadf44f1
--- /dev/null
+++ b/src/wayland/util.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "../window/proxywindow.hpp"
+
+namespace qs::wayland::util {
+
+void scheduleCommit(ProxyWindowBase* window);
+
+}
diff --git a/src/wayland/wlr_layershell.cpp b/src/wayland/wlr_layershell.cpp
deleted file mode 100644
index bc4fc5cd..00000000
--- a/src/wayland/wlr_layershell.cpp
+++ /dev/null
@@ -1,209 +0,0 @@
-#include "wlr_layershell.hpp"
-#include <utility>
-
-#include <qlogging.h>
-#include <qobject.h>
-#include <qqmllist.h>
-#include <qquickitem.h>
-#include <qquickwindow.h>
-#include <qtmetamacros.h>
-#include <qtypes.h>
-
-#include "../core/panelinterface.hpp"
-#include "../core/proxywindow.hpp"
-#include "../core/qmlscreen.hpp"
-#include "wlr_layershell/window.hpp"
-
-WlrLayershell::WlrLayershell(QObject* parent)
-    : ProxyWindowBase(parent)
-    , ext(new LayershellWindowExtension(this)) {}
-
-QQuickWindow* WlrLayershell::createWindow(QObject* oldInstance) {
-	auto* old = qobject_cast<WlrLayershell*>(oldInstance);
-	QQuickWindow* window = nullptr;
-
-	if (old == nullptr || old->window == nullptr) {
-		window = new QQuickWindow();
-	} else {
-		window = old->disownWindow();
-
-		if (this->ext->attach(window)) {
-			return window;
-		} else {
-			window->deleteLater();
-			window = new QQuickWindow();
-		}
-	}
-
-	if (!this->ext->attach(window)) {
-		qWarning() << "Could not attach Layershell extension to new QQUickWindow. Layer will not "
-		              "behave correctly.";
-	}
-
-	return window;
-}
-
-void WlrLayershell::setupWindow() {
-	this->ProxyWindowBase::setupWindow();
-
-	// clang-format off
-	QObject::connect(this->ext, &LayershellWindowExtension::layerChanged, this, &WlrLayershell::layerChanged);
-	QObject::connect(this->ext, &LayershellWindowExtension::keyboardFocusChanged, this, &WlrLayershell::keyboardFocusChanged);
-	QObject::connect(this->ext, &LayershellWindowExtension::anchorsChanged, this, &WlrLayershell::anchorsChanged);
-	QObject::connect(this->ext, &LayershellWindowExtension::exclusiveZoneChanged, this, &WlrLayershell::exclusiveZoneChanged);
-	QObject::connect(this->ext, &LayershellWindowExtension::marginsChanged, this, &WlrLayershell::marginsChanged);
-
-	QObject::connect(this, &ProxyWindowBase::widthChanged, this, &WlrLayershell::updateAutoExclusion);
-	QObject::connect(this, &ProxyWindowBase::heightChanged, this, &WlrLayershell::updateAutoExclusion);
-	QObject::connect(this, &WlrLayershell::anchorsChanged, this, &WlrLayershell::updateAutoExclusion);
-	// clang-format on
-
-	this->updateAutoExclusion();
-}
-
-void WlrLayershell::setWidth(qint32 width) {
-	this->mWidth = width;
-
-	// only update the actual size if not blocked by anchors
-	if (!this->ext->anchors().horizontalConstraint()) {
-		this->ProxyWindowBase::setWidth(width);
-	}
-}
-
-void WlrLayershell::setHeight(qint32 height) {
-	this->mHeight = height;
-
-	// only update the actual size if not blocked by anchors
-	if (!this->ext->anchors().verticalConstraint()) {
-		this->ProxyWindowBase::setHeight(height);
-	}
-}
-
-void WlrLayershell::setScreen(QuickshellScreenInfo* screen) {
-	this->ProxyWindowBase::setScreen(screen);
-	this->ext->setUseWindowScreen(screen != nullptr);
-}
-
-// NOLINTBEGIN
-#define extPair(type, get, set)                                                                    \
-	type WlrLayershell::get() const { return this->ext->get(); }                                     \
-	void WlrLayershell::set(type value) { this->ext->set(value); }
-
-extPair(Layer::Enum, layer, setLayer);
-extPair(KeyboardFocus::Enum, keyboardFocus, setKeyboardFocus);
-extPair(Margins, margins, setMargins);
-// NOLINTEND
-
-Anchors WlrLayershell::anchors() const { return this->ext->anchors(); }
-
-void WlrLayershell::setAnchors(Anchors anchors) {
-	this->ext->setAnchors(anchors);
-
-	// explicitly set width values are tracked so the entire screen isn't covered if an anchor is removed.
-	if (!anchors.horizontalConstraint()) this->ProxyWindowBase::setWidth(this->mWidth);
-	if (!anchors.verticalConstraint()) this->ProxyWindowBase::setHeight(this->mHeight);
-}
-
-QString WlrLayershell::ns() const { return this->ext->ns(); }
-
-void WlrLayershell::setNamespace(QString ns) {
-	this->ext->setNamespace(std::move(ns));
-	emit this->namespaceChanged();
-}
-
-qint32 WlrLayershell::exclusiveZone() const { return this->ext->exclusiveZone(); }
-
-void WlrLayershell::setExclusiveZone(qint32 exclusiveZone) {
-	this->mExclusiveZone = exclusiveZone;
-	this->setExclusionMode(ExclusionMode::Normal);
-	this->ext->setExclusiveZone(exclusiveZone);
-}
-
-ExclusionMode::Enum WlrLayershell::exclusionMode() const { return this->mExclusionMode; }
-
-void WlrLayershell::setExclusionMode(ExclusionMode::Enum exclusionMode) {
-	if (exclusionMode == this->mExclusionMode) return;
-	this->mExclusionMode = exclusionMode;
-
-	if (exclusionMode == ExclusionMode::Normal) {
-		this->ext->setExclusiveZone(this->mExclusiveZone);
-	} else if (exclusionMode == ExclusionMode::Ignore) {
-		this->ext->setExclusiveZone(-1);
-	} else {
-		this->setAutoExclusion();
-	}
-}
-
-void WlrLayershell::setAutoExclusion() {
-	const auto anchors = this->anchors();
-	auto zone = 0;
-
-	if (anchors.horizontalConstraint()) zone = this->height();
-	else if (anchors.verticalConstraint()) zone = this->width();
-
-	this->ext->setExclusiveZone(zone);
-}
-
-void WlrLayershell::updateAutoExclusion() {
-	if (this->mExclusionMode == ExclusionMode::Auto) {
-		this->setAutoExclusion();
-	}
-}
-
-WlrLayershell* WlrLayershell::qmlAttachedProperties(QObject* object) {
-	if (auto* obj = qobject_cast<WaylandPanelInterface*>(object)) {
-		return obj->layer;
-	} else {
-		return nullptr;
-	}
-}
-
-// WaylandPanelInterface
-
-WaylandPanelInterface::WaylandPanelInterface(QObject* parent)
-    : PanelWindowInterface(parent)
-    , layer(new WlrLayershell(this)) {
-
-	// clang-format off
-	QObject::connect(this->layer, &ProxyWindowBase::windowConnected, this, &WaylandPanelInterface::windowConnected);
-	QObject::connect(this->layer, &ProxyWindowBase::visibleChanged, this, &WaylandPanelInterface::visibleChanged);
-	QObject::connect(this->layer, &ProxyWindowBase::heightChanged, this, &WaylandPanelInterface::heightChanged);
-	QObject::connect(this->layer, &ProxyWindowBase::widthChanged, this, &WaylandPanelInterface::widthChanged);
-	QObject::connect(this->layer, &ProxyWindowBase::screenChanged, this, &WaylandPanelInterface::screenChanged);
-	QObject::connect(this->layer, &ProxyWindowBase::colorChanged, this, &WaylandPanelInterface::colorChanged);
-	QObject::connect(this->layer, &ProxyWindowBase::maskChanged, this, &WaylandPanelInterface::maskChanged);
-
-	// panel specific
-	QObject::connect(this->layer, &WlrLayershell::anchorsChanged, this, &WaylandPanelInterface::anchorsChanged);
-	QObject::connect(this->layer, &WlrLayershell::marginsChanged, this, &WaylandPanelInterface::marginsChanged);
-	QObject::connect(this->layer, &WlrLayershell::exclusiveZoneChanged, this, &WaylandPanelInterface::exclusiveZoneChanged);
-	QObject::connect(this->layer, &WlrLayershell::exclusionModeChanged, this, &WaylandPanelInterface::exclusionModeChanged);
-	// clang-format on
-}
-
-void WaylandPanelInterface::onReload(QObject* oldInstance) {
-	auto* old = qobject_cast<WaylandPanelInterface*>(oldInstance);
-	this->layer->onReload(old != nullptr ? old->layer : nullptr);
-}
-
-QQmlListProperty<QObject> WaylandPanelInterface::data() { return this->layer->data(); }
-QQuickItem* WaylandPanelInterface::contentItem() const { return this->layer->contentItem(); }
-
-// NOLINTBEGIN
-#define proxyPair(type, get, set)                                                                  \
-	type WaylandPanelInterface::get() const { return this->layer->get(); }                           \
-	void WaylandPanelInterface::set(type value) { this->layer->set(value); }
-
-proxyPair(bool, isVisible, setVisible);
-proxyPair(qint32, width, setWidth);
-proxyPair(qint32, height, setHeight);
-proxyPair(QuickshellScreenInfo*, screen, setScreen);
-proxyPair(QColor, color, setColor);
-proxyPair(PendingRegion*, mask, setMask);
-
-// panel specific
-proxyPair(Anchors, anchors, setAnchors);
-proxyPair(Margins, margins, setMargins);
-proxyPair(qint32, exclusiveZone, setExclusiveZone);
-proxyPair(ExclusionMode::Enum, exclusionMode, setExclusionMode);
-// NOLINTEND
diff --git a/src/wayland/wlr_layershell.hpp b/src/wayland/wlr_layershell.hpp
deleted file mode 100644
index f86d5135..00000000
--- a/src/wayland/wlr_layershell.hpp
+++ /dev/null
@@ -1,166 +0,0 @@
-#pragma once
-
-#include <qobject.h>
-#include <qqmlintegration.h>
-#include <qquickitem.h>
-#include <qquickwindow.h>
-#include <qtmetamacros.h>
-#include <qtypes.h>
-
-#include "../core/doc.hpp"
-#include "../core/proxywindow.hpp"
-#include "wlr_layershell/window.hpp"
-
-///! Wlroots layershell window
-/// Decorationless window that can be attached to the screen edges using the [zwlr_layer_shell_v1] protocol.
-///
-/// #### Attached property
-/// `WlrLayershell` works as an attached property of [PanelWindow] which you should use instead if you can,
-/// as it is platform independent.
-/// ```qml
-/// PanelWindow {
-///   // When PanelWindow is backed with WlrLayershell this will work
-///   WlrLayershell.layer: Layer.Bottom
-/// }
-/// ```
-///
-/// To maintain platform compatibility you can dynamically set layershell specific properties.
-/// ```qml
-/// PanelWindow {
-///   Component.onCompleted: {
-///     if (this.WlrLayershell != null) {
-///       this.WlrLayershell.layer = Layer.Bottom;
-///     }
-///   }
-/// }
-/// ```
-///
-/// [zwlr_layer_shell_v1]: https://wayland.app/protocols/wlr-layer-shell-unstable-v1
-/// [PanelWindow]: ../../quickshell/panelwindow
-class WlrLayershell: public ProxyWindowBase {
-	QSDOC_BASECLASS(PanelWindowInterface);
-	// clang-format off
-	Q_OBJECT;
-	/// The shell layer the window sits in. Defaults to `Layer.Top`.
-	Q_PROPERTY(Layer::Enum layer READ layer WRITE setLayer NOTIFY layerChanged);
-	/// Similar to the class property of windows. Can be used to identify the window to external tools.
-	///
-	/// Cannot be set after windowConnected.
-	Q_PROPERTY(QString namespace READ ns WRITE setNamespace NOTIFY namespaceChanged);
-	/// The degree of keyboard focus taken. Defaults to `KeyboardFocus.None`.
-	Q_PROPERTY(KeyboardFocus::Enum keyboardFocus READ keyboardFocus WRITE setKeyboardFocus NOTIFY keyboardFocusChanged);
-
-	QSDOC_HIDE Q_PROPERTY(Anchors anchors READ anchors WRITE setAnchors NOTIFY anchorsChanged);
-	QSDOC_HIDE Q_PROPERTY(qint32 exclusiveZone READ exclusiveZone WRITE setExclusiveZone NOTIFY exclusiveZoneChanged);
-	QSDOC_HIDE Q_PROPERTY(ExclusionMode::Enum exclusionMode READ exclusionMode WRITE setExclusionMode NOTIFY exclusionModeChanged);
-	QSDOC_HIDE Q_PROPERTY(Margins margins READ margins WRITE setMargins NOTIFY marginsChanged);
-	QML_ATTACHED(WlrLayershell);
-	QML_ELEMENT;
-	// clang-format on
-
-public:
-	explicit WlrLayershell(QObject* parent = nullptr);
-
-	QQuickWindow* createWindow(QObject* oldInstance) override;
-	void setupWindow() override;
-
-	void setWidth(qint32 width) override;
-	void setHeight(qint32 height) override;
-
-	void setScreen(QuickshellScreenInfo* screen) override;
-
-	[[nodiscard]] Layer::Enum layer() const;
-	void setLayer(Layer::Enum layer); // NOLINT
-
-	[[nodiscard]] QString ns() const;
-	void setNamespace(QString ns);
-
-	[[nodiscard]] KeyboardFocus::Enum keyboardFocus() const;
-	void setKeyboardFocus(KeyboardFocus::Enum focus); // NOLINT
-
-	[[nodiscard]] Anchors anchors() const;
-	void setAnchors(Anchors anchors);
-
-	[[nodiscard]] qint32 exclusiveZone() const;
-	void setExclusiveZone(qint32 exclusiveZone);
-
-	[[nodiscard]] ExclusionMode::Enum exclusionMode() const;
-	void setExclusionMode(ExclusionMode::Enum exclusionMode);
-
-	[[nodiscard]] Margins margins() const;
-	void setMargins(Margins margins); // NOLINT
-
-	static WlrLayershell* qmlAttachedProperties(QObject* object);
-
-signals:
-	void layerChanged();
-	void namespaceChanged();
-	void keyboardFocusChanged();
-	QSDOC_HIDE void anchorsChanged();
-	QSDOC_HIDE void exclusiveZoneChanged();
-	QSDOC_HIDE void exclusionModeChanged();
-	QSDOC_HIDE void marginsChanged();
-
-private slots:
-	void updateAutoExclusion();
-
-private:
-	void setAutoExclusion();
-
-	LayershellWindowExtension* ext;
-
-	ExclusionMode::Enum mExclusionMode = ExclusionMode::Auto;
-	qint32 mExclusiveZone = 0;
-};
-
-class WaylandPanelInterface: public PanelWindowInterface {
-	Q_OBJECT;
-
-public:
-	explicit WaylandPanelInterface(QObject* parent = nullptr);
-
-	void onReload(QObject* oldInstance) override;
-
-	[[nodiscard]] QQuickItem* contentItem() const override;
-
-	// NOLINTBEGIN
-	[[nodiscard]] bool isVisible() const override;
-	void setVisible(bool visible) override;
-
-	[[nodiscard]] qint32 width() const override;
-	void setWidth(qint32 width) override;
-
-	[[nodiscard]] qint32 height() const override;
-	void setHeight(qint32 height) override;
-
-	[[nodiscard]] QuickshellScreenInfo* screen() const override;
-	void setScreen(QuickshellScreenInfo* screen) override;
-
-	[[nodiscard]] QColor color() const override;
-	void setColor(QColor color) override;
-
-	[[nodiscard]] PendingRegion* mask() const override;
-	void setMask(PendingRegion* mask) override;
-
-	[[nodiscard]] QQmlListProperty<QObject> data() override;
-
-	// panel specific
-
-	[[nodiscard]] Anchors anchors() const override;
-	void setAnchors(Anchors anchors) override;
-
-	[[nodiscard]] Margins margins() const override;
-	void setMargins(Margins margins) override;
-
-	[[nodiscard]] qint32 exclusiveZone() const override;
-	void setExclusiveZone(qint32 exclusiveZone) override;
-
-	[[nodiscard]] ExclusionMode::Enum exclusionMode() const override;
-	void setExclusionMode(ExclusionMode::Enum exclusionMode) override;
-	// NOLINTEND
-
-private:
-	WlrLayershell* layer;
-
-	friend class WlrLayershell;
-};
diff --git a/src/wayland/wlr_layershell/CMakeLists.txt b/src/wayland/wlr_layershell/CMakeLists.txt
index 27a85ca0..444f512b 100644
--- a/src/wayland/wlr_layershell/CMakeLists.txt
+++ b/src/wayland/wlr_layershell/CMakeLists.txt
@@ -1,12 +1,29 @@
 qt_add_library(quickshell-wayland-layershell STATIC
+	wlr_layershell.cpp
 	shell_integration.cpp
 	surface.cpp
-	window.cpp
 )
 
-qt_add_qml_module(quickshell-wayland-layershell URI Quickshell.Wayland._WlrLayerShell VERSION 0.1)
+qt_add_qml_module(quickshell-wayland-layershell
+	URI Quickshell.Wayland._WlrLayerShell
+	VERSION 0.1
+	DEPENDENCIES QtQuick
+)
 
-wl_proto(quickshell-wayland-layershell wlr-layer-shell-unstable-v1 "${CMAKE_CURRENT_SOURCE_DIR}/wlr-layer-shell-unstable-v1.xml")
-target_link_libraries(quickshell-wayland-layershell PRIVATE ${QT_DEPS} wayland-client)
+qs_add_module_deps_light(quickshell-wayland-layershell Quickshell Quickshell.Wayland)
+
+install_qml_module(quickshell-wayland-layershell)
+
+wl_proto(wlp-layer-shell wlr-layer-shell-unstable-v1 "${CMAKE_CURRENT_SOURCE_DIR}")
+
+# link dependency of wlr-layer-shell's codegen
+wl_proto(wlp-xdg-shell xdg-shell "${WAYLAND_PROTOCOLS}/stable/xdg-shell")
+
+target_link_libraries(quickshell-wayland-layershell PRIVATE
+	Qt::Quick Qt::WaylandClient Qt::WaylandClientPrivate wayland-client
+	wlp-layer-shell wlp-xdg-shell
+)
+
+qs_module_pch(quickshell-wayland-layershell SET large)
 
 target_link_libraries(quickshell-wayland PRIVATE quickshell-wayland-layershellplugin)
diff --git a/src/wayland/wlr_layershell/shell_integration.cpp b/src/wayland/wlr_layershell/shell_integration.cpp
index 8c7bce70..8abfefa5 100644
--- a/src/wayland/wlr_layershell/shell_integration.cpp
+++ b/src/wayland/wlr_layershell/shell_integration.cpp
@@ -6,16 +6,20 @@
 
 #include "surface.hpp"
 
-QSWaylandLayerShellIntegration::QSWaylandLayerShellIntegration()
-    : QtWaylandClient::QWaylandShellIntegrationTemplate<QSWaylandLayerShellIntegration>(4) {}
+namespace qs::wayland::layershell {
 
-QSWaylandLayerShellIntegration::~QSWaylandLayerShellIntegration() {
+LayerShellIntegration::LayerShellIntegration()
+    : QtWaylandClient::QWaylandShellIntegrationTemplate<LayerShellIntegration>(4) {}
+
+LayerShellIntegration::~LayerShellIntegration() {
 	if (this->isInitialized()) {
 		this->destroy();
 	}
 }
 
 QtWaylandClient::QWaylandShellSurface*
-QSWaylandLayerShellIntegration::createShellSurface(QtWaylandClient::QWaylandWindow* window) {
-	return new QSWaylandLayerSurface(this, window);
+LayerShellIntegration::createShellSurface(QtWaylandClient::QWaylandWindow* window) {
+	return new LayerSurface(this, window);
 }
+
+} // namespace qs::wayland::layershell
diff --git a/src/wayland/wlr_layershell/shell_integration.hpp b/src/wayland/wlr_layershell/shell_integration.hpp
index 132b0d7a..e92b7c62 100644
--- a/src/wayland/wlr_layershell/shell_integration.hpp
+++ b/src/wayland/wlr_layershell/shell_integration.hpp
@@ -5,14 +5,18 @@
 #include <qtclasshelpermacros.h>
 #include <qwayland-wlr-layer-shell-unstable-v1.h>
 
-class QSWaylandLayerShellIntegration
-    : public QtWaylandClient::QWaylandShellIntegrationTemplate<QSWaylandLayerShellIntegration>
+namespace qs::wayland::layershell {
+
+class LayerShellIntegration
+    : public QtWaylandClient::QWaylandShellIntegrationTemplate<LayerShellIntegration>
     , public QtWayland::zwlr_layer_shell_v1 {
 public:
-	QSWaylandLayerShellIntegration();
-	~QSWaylandLayerShellIntegration() override;
-	Q_DISABLE_COPY_MOVE(QSWaylandLayerShellIntegration);
+	LayerShellIntegration();
+	~LayerShellIntegration() override;
+	Q_DISABLE_COPY_MOVE(LayerShellIntegration);
 
 	QtWaylandClient::QWaylandShellSurface* createShellSurface(QtWaylandClient::QWaylandWindow* window
 	) override;
 };
+
+} // namespace qs::wayland::layershell
diff --git a/src/wayland/wlr_layershell/surface.cpp b/src/wayland/wlr_layershell/surface.cpp
index d9a60405..26d75587 100644
--- a/src/wayland/wlr_layershell/surface.cpp
+++ b/src/wayland/wlr_layershell/surface.cpp
@@ -1,43 +1,145 @@
 #include "surface.hpp"
+#include <algorithm>
+#include <any>
+#include <utility>
 
+#include <private/qhighdpiscaling_p.h>
 #include <private/qwaylanddisplay_p.h>
 #include <private/qwaylandscreen_p.h>
 #include <private/qwaylandshellsurface_p.h>
 #include <private/qwaylandsurface_p.h>
 #include <private/qwaylandwindow_p.h>
 #include <qlogging.h>
-#include <qpoint.h>
 #include <qrect.h>
 #include <qsize.h>
+#include <qtversionchecks.h>
 #include <qtypes.h>
+#include <qvariant.h>
 #include <qwayland-wlr-layer-shell-unstable-v1.h>
+#include <qwindow.h>
 
-#include "../../core/panelinterface.hpp"
+#include "../../window/panelinterface.hpp"
 #include "shell_integration.hpp"
-#include "window.hpp"
+#include "wlr_layershell.hpp"
 
-// clang-format off
-[[nodiscard]] QtWayland::zwlr_layer_shell_v1::layer toWaylandLayer(const Layer::Enum& layer) noexcept;
-[[nodiscard]] QtWayland::zwlr_layer_surface_v1::anchor toWaylandAnchors(const Anchors& anchors) noexcept;
-[[nodiscard]] QtWayland::zwlr_layer_surface_v1::keyboard_interactivity toWaylandKeyboardFocus(const KeyboardFocus::Enum& focus) noexcept;
-[[nodiscard]] QSize constrainedSize(const Anchors& anchors, const QSize& size) noexcept;
-// clang-format on
+#if QT_VERSION < QT_VERSION_CHECK(6, 7, 0)
+#include <qpoint.h>
+#endif
 
-QSWaylandLayerSurface::QSWaylandLayerSurface(
-    QSWaylandLayerShellIntegration* shell,
-    QtWaylandClient::QWaylandWindow* window
-)
+namespace qs::wayland::layershell {
+
+namespace {
+
+[[nodiscard]] QtWayland::zwlr_layer_shell_v1::layer toWaylandLayer(const WlrLayer::Enum& layer
+) noexcept {
+	switch (layer) {
+	case WlrLayer::Background: return QtWayland::zwlr_layer_shell_v1::layer_background;
+	case WlrLayer::Bottom: return QtWayland::zwlr_layer_shell_v1::layer_bottom;
+	case WlrLayer::Top: return QtWayland::zwlr_layer_shell_v1::layer_top;
+	case WlrLayer::Overlay: return QtWayland::zwlr_layer_shell_v1::layer_overlay;
+	}
+
+	return QtWayland::zwlr_layer_shell_v1::layer_top;
+}
+
+[[nodiscard]] QtWayland::zwlr_layer_surface_v1::anchor toWaylandAnchors(const Anchors& anchors
+) noexcept {
+	quint32 wl = 0;
+	if (anchors.mLeft) wl |= QtWayland::zwlr_layer_surface_v1::anchor_left;
+	if (anchors.mRight) wl |= QtWayland::zwlr_layer_surface_v1::anchor_right;
+	if (anchors.mTop) wl |= QtWayland::zwlr_layer_surface_v1::anchor_top;
+	if (anchors.mBottom) wl |= QtWayland::zwlr_layer_surface_v1::anchor_bottom;
+	return static_cast<QtWayland::zwlr_layer_surface_v1::anchor>(wl);
+}
+
+[[nodiscard]] QtWayland::zwlr_layer_surface_v1::keyboard_interactivity
+toWaylandKeyboardFocus(const WlrKeyboardFocus::Enum& focus) noexcept {
+	switch (focus) {
+	case WlrKeyboardFocus::None: return QtWayland::zwlr_layer_surface_v1::keyboard_interactivity_none;
+	case WlrKeyboardFocus::Exclusive:
+		return QtWayland::zwlr_layer_surface_v1::keyboard_interactivity_exclusive;
+	case WlrKeyboardFocus::OnDemand:
+		return QtWayland::zwlr_layer_surface_v1::keyboard_interactivity_on_demand;
+	}
+
+	return QtWayland::zwlr_layer_surface_v1::keyboard_interactivity_none;
+}
+
+[[nodiscard]] QSize constrainedSize(const Anchors& anchors, const QSize& size) noexcept {
+	return QSize(
+	    anchors.horizontalConstraint() ? 0 : std::max(1, size.width()),
+	    anchors.verticalConstraint() ? 0 : std::max(1, size.height())
+	);
+}
+
+} // namespace
+
+void LayerSurfaceBridge::commitState() {
+	if (this->surface) this->surface->commit();
+}
+
+LayerSurfaceBridge* LayerSurfaceBridge::get(QWindow* window) {
+	auto v = window->property("layershell_bridge");
+
+	if (v.canConvert<LayerSurfaceBridge*>()) {
+		return v.value<LayerSurfaceBridge*>();
+	}
+
+	return nullptr;
+}
+
+LayerSurfaceBridge* LayerSurfaceBridge::init(QWindow* window, LayerSurfaceState state) {
+	auto* bridge = LayerSurfaceBridge::get(window);
+
+	if (!bridge) {
+		bridge = new LayerSurfaceBridge(window);
+		window->setProperty("layershell_bridge", QVariant::fromValue(bridge));
+	} else if (!bridge->state.isCompatible(state)) {
+		return nullptr;
+	}
+
+	if (!bridge->surface) {
+		// Qt appears to be resetting the window's screen on creation on some systems. This works around it.
+		auto* screen = window->screen();
+		window->create();
+		window->setScreen(screen);
+
+		auto* waylandWindow = dynamic_cast<QtWaylandClient::QWaylandWindow*>(window->handle());
+		if (waylandWindow == nullptr) {
+			qWarning() << window << "is not a wayland window. Cannot create layershell surface.";
+			return nullptr;
+		}
+
+		static LayerShellIntegration* layershellIntegration = nullptr; // NOLINT
+		if (layershellIntegration == nullptr) {
+			layershellIntegration = new LayerShellIntegration();
+			if (!layershellIntegration->initialize(waylandWindow->display())) {
+				delete layershellIntegration;
+				layershellIntegration = nullptr;
+				qWarning() << "Failed to initialize layershell integration";
+			}
+		}
+
+		waylandWindow->setShellIntegration(layershellIntegration);
+	}
+
+	bridge->state = std::move(state);
+	bridge->commitState();
+
+	return bridge;
+}
+
+LayerSurface::LayerSurface(LayerShellIntegration* shell, QtWaylandClient::QWaylandWindow* window)
     : QtWaylandClient::QWaylandShellSurface(window) {
 
 	auto* qwindow = window->window();
-	this->ext = LayershellWindowExtension::get(qwindow);
 
-	if (this->ext == nullptr) {
-		throw "QSWaylandLayerSurface created with null LayershellWindowExtension";
-	}
+	this->bridge = LayerSurfaceBridge::get(qwindow);
+	if (this->bridge == nullptr) qFatal() << "LayerSurface created with null bridge";
+	const auto& s = this->bridge->state;
 
 	wl_output* output = nullptr; // NOLINT (include)
-	if (this->ext->useWindowScreen) {
+	if (!s.compositorPickesScreen) {
 		auto* waylandScreen =
 		    dynamic_cast<QtWaylandClient::QWaylandScreen*>(qwindow->screen()->handle());
 
@@ -52,116 +154,107 @@ QSWaylandLayerSurface::QSWaylandLayerSurface(
 	this->init(shell->get_layer_surface(
 	    window->waylandSurface()->object(),
 	    output,
-	    toWaylandLayer(this->ext->mLayer),
-	    this->ext->mNamespace
+	    toWaylandLayer(s.layer),
+	    s.mNamespace
 	));
 
-	this->updateAnchors();
-	this->updateLayer();
-	this->updateMargins();
-	this->updateExclusiveZone();
-	this->updateKeyboardFocus();
-
-	// new updates will be sent from the extension
-	this->ext->surface = this;
-
-	auto size = constrainedSize(this->ext->mAnchors, qwindow->size());
+	auto size = constrainedSize(s.anchors, QHighDpi::toNativePixels(s.implicitSize, qwindow));
 	this->set_size(size.width(), size.height());
+	this->set_anchor(toWaylandAnchors(s.anchors));
+	this->set_margin(
+	    QHighDpi::toNativePixels(s.margins.top, qwindow),
+	    QHighDpi::toNativePixels(s.margins.right, qwindow),
+	    QHighDpi::toNativePixels(s.margins.bottom, qwindow),
+	    QHighDpi::toNativePixels(s.margins.left, qwindow)
+	);
+	this->set_exclusive_zone(QHighDpi::toNativePixels(s.exclusiveZone, qwindow));
+	this->set_keyboard_interactivity(toWaylandKeyboardFocus(s.keyboardFocus));
+
+	this->bridge->surface = this;
 }
 
-QSWaylandLayerSurface::~QSWaylandLayerSurface() {
-	this->ext->surface = nullptr;
+LayerSurface::~LayerSurface() {
+	if (this->bridge && this->bridge->surface == this) {
+		this->bridge->surface = nullptr;
+	}
+
 	this->destroy();
 }
 
-void QSWaylandLayerSurface::zwlr_layer_surface_v1_configure(
-    quint32 serial,
-    quint32 width,
-    quint32 height
-) {
+void LayerSurface::zwlr_layer_surface_v1_configure(quint32 serial, quint32 width, quint32 height) {
 	this->ack_configure(serial);
 
 	this->size = QSize(static_cast<qint32>(width), static_cast<qint32>(height));
 	if (!this->configured) {
 		this->configured = true;
 		this->window()->resizeFromApplyConfigure(this->size);
+#if QT_VERSION < QT_VERSION_CHECK(6, 7, 0)
 		this->window()->handleExpose(QRect(QPoint(), this->size));
+#elif QT_VERSION < QT_VERSION_CHECK(6, 9, 0)
+		this->window()->sendRecursiveExposeEvent();
+#else
+		this->window()->updateExposure();
+#endif
 	} else {
 		this->window()->applyConfigureWhenPossible();
 	}
 }
 
-void QSWaylandLayerSurface::zwlr_layer_surface_v1_closed() { this->window()->window()->close(); }
+void LayerSurface::zwlr_layer_surface_v1_closed() { this->window()->window()->close(); }
 
-bool QSWaylandLayerSurface::isExposed() const { return this->configured; }
+bool LayerSurface::isExposed() const { return this->configured; }
 
-void QSWaylandLayerSurface::applyConfigure() {
-	this->window()->resizeFromApplyConfigure(this->size);
-}
+void LayerSurface::applyConfigure() { this->window()->resizeFromApplyConfigure(this->size); }
 
-void QSWaylandLayerSurface::setWindowGeometry(const QRect& geometry) {
-	auto size = constrainedSize(this->ext->mAnchors, geometry.size());
-	this->set_size(size.width(), size.height());
-}
+QWindow* LayerSurface::qwindow() { return this->window()->window(); }
 
-QWindow* QSWaylandLayerSurface::qwindow() { return this->window()->window(); }
+void LayerSurface::commit() {
+	const auto& p = this->bridge->state;
+	auto& c = this->committed;
 
-void QSWaylandLayerSurface::updateLayer() { this->set_layer(toWaylandLayer(this->ext->mLayer)); }
-
-void QSWaylandLayerSurface::updateAnchors() {
-	this->set_anchor(toWaylandAnchors(this->ext->mAnchors));
-	this->setWindowGeometry(this->window()->windowContentGeometry());
-}
-
-void QSWaylandLayerSurface::updateMargins() {
-	auto& margins = this->ext->mMargins;
-	this->set_margin(margins.mTop, margins.mRight, margins.mBottom, margins.mLeft);
-}
-
-void QSWaylandLayerSurface::updateExclusiveZone() {
-	this->set_exclusive_zone(this->ext->mExclusiveZone);
-}
-
-void QSWaylandLayerSurface::updateKeyboardFocus() {
-	this->set_keyboard_interactivity(toWaylandKeyboardFocus(this->ext->mKeyboardFocus));
-}
-
-QtWayland::zwlr_layer_shell_v1::layer toWaylandLayer(const Layer::Enum& layer) noexcept {
-	switch (layer) {
-	case Layer::Background: return QtWayland::zwlr_layer_shell_v1::layer_background;
-	case Layer::Bottom: return QtWayland::zwlr_layer_shell_v1::layer_bottom;
-	case Layer::Top: return QtWayland::zwlr_layer_shell_v1::layer_top;
-	case Layer::Overlay: return QtWayland::zwlr_layer_shell_v1::layer_overlay;
+	if (p.implicitSize != c.implicitSize || p.anchors != c.anchors) {
+		auto size =
+		    constrainedSize(p.anchors, QHighDpi::toNativePixels(p.implicitSize, this->qwindow()));
+		this->set_size(size.width(), size.height());
 	}
 
-	return QtWayland::zwlr_layer_shell_v1::layer_top;
-}
-
-QtWayland::zwlr_layer_surface_v1::anchor toWaylandAnchors(const Anchors& anchors) noexcept {
-	quint32 wl = 0;
-	if (anchors.mLeft) wl |= QtWayland::zwlr_layer_surface_v1::anchor_left;
-	if (anchors.mRight) wl |= QtWayland::zwlr_layer_surface_v1::anchor_right;
-	if (anchors.mTop) wl |= QtWayland::zwlr_layer_surface_v1::anchor_top;
-	if (anchors.mBottom) wl |= QtWayland::zwlr_layer_surface_v1::anchor_bottom;
-	return static_cast<QtWayland::zwlr_layer_surface_v1::anchor>(wl);
-}
-
-QtWayland::zwlr_layer_surface_v1::keyboard_interactivity
-toWaylandKeyboardFocus(const KeyboardFocus::Enum& focus) noexcept {
-	switch (focus) {
-	case KeyboardFocus::None: return QtWayland::zwlr_layer_surface_v1::keyboard_interactivity_none;
-	case KeyboardFocus::Exclusive:
-		return QtWayland::zwlr_layer_surface_v1::keyboard_interactivity_exclusive;
-	case KeyboardFocus::OnDemand:
-		return QtWayland::zwlr_layer_surface_v1::keyboard_interactivity_on_demand;
+	if (p.anchors != c.anchors) {
+		this->set_anchor(toWaylandAnchors(p.anchors));
 	}
 
-	return QtWayland::zwlr_layer_surface_v1::keyboard_interactivity_none;
+	if (p.margins != c.margins) {
+		this->set_margin(
+		    QHighDpi::toNativePixels(p.margins.top, this->qwindow()),
+		    QHighDpi::toNativePixels(p.margins.right, this->qwindow()),
+		    QHighDpi::toNativePixels(p.margins.bottom, this->qwindow()),
+		    QHighDpi::toNativePixels(p.margins.left, this->qwindow())
+		);
+	}
+
+	if (p.layer != c.layer) {
+		this->set_layer(p.layer);
+	}
+
+	if (p.exclusiveZone != c.exclusiveZone) {
+		this->set_exclusive_zone(QHighDpi::toNativePixels(p.exclusiveZone, this->qwindow()));
+	}
+
+	if (p.keyboardFocus != c.keyboardFocus) {
+		this->set_keyboard_interactivity(toWaylandKeyboardFocus(p.keyboardFocus));
+	}
+
+	c = p;
 }
 
-QSize constrainedSize(const Anchors& anchors, const QSize& size) noexcept {
-	return QSize(
-	    anchors.horizontalConstraint() ? 0 : size.width(),
-	    anchors.verticalConstraint() ? 0 : size.height()
-	);
+void LayerSurface::attachPopup(QtWaylandClient::QWaylandShellSurface* popup) {
+	std::any role = popup->surfaceRole();
+
+	if (auto* popupRole = std::any_cast<::xdg_popup*>(&role)) { // NOLINT
+		this->get_popup(*popupRole);
+	} else {
+		qWarning() << "Cannot attach popup" << popup << "to shell surface" << this
+		           << "as the popup is not an xdg_popup.";
+	}
 }
+
+} // namespace qs::wayland::layershell
diff --git a/src/wayland/wlr_layershell/surface.hpp b/src/wayland/wlr_layershell/surface.hpp
index e3a8d9b4..d782d713 100644
--- a/src/wayland/wlr_layershell/surface.hpp
+++ b/src/wayland/wlr_layershell/surface.hpp
@@ -2,6 +2,8 @@
 
 #include <private/qwaylandshellsurface_p.h>
 #include <private/qwaylandwindow_p.h>
+#include <qobject.h>
+#include <qsize.h>
 #include <qtclasshelpermacros.h>
 #include <qtwaylandclientexports.h>
 #include <qtypes.h>
@@ -9,38 +11,76 @@
 #include <qwindow.h>
 
 #include "shell_integration.hpp"
-#include "window.hpp"
+#include "wlr_layershell.hpp"
 
-class QSWaylandLayerSurface
+namespace qs::wayland::layershell {
+
+struct LayerSurfaceState {
+	QSize implicitSize;
+	Anchors anchors;
+	Margins margins;
+	WlrLayer::Enum layer = WlrLayer::Top;
+	qint32 exclusiveZone = 0;
+	WlrKeyboardFocus::Enum keyboardFocus = WlrKeyboardFocus::None;
+
+	bool compositorPickesScreen = true;
+	QString mNamespace = "quickshell";
+
+	[[nodiscard]] bool isCompatible(const LayerSurfaceState& other) const {
+		return other.mNamespace == this->mNamespace;
+	}
+};
+
+class LayerSurface;
+
+class LayerSurfaceBridge: public QObject {
+public:
+	LayerSurfaceState state;
+
+	void commitState();
+
+	// Returns a bridge if attached, otherwise nullptr.
+	static LayerSurfaceBridge* get(QWindow* window);
+
+	// Creates or reuses a bridge on the given window and returns if it compatible, otherwise nullptr.
+	static LayerSurfaceBridge* init(QWindow* window, LayerSurfaceState state);
+
+private:
+	explicit LayerSurfaceBridge(QWindow* parent): QObject(parent) {}
+
+	LayerSurface* surface = nullptr;
+
+	friend class LayerSurface;
+};
+
+class LayerSurface
     : public QtWaylandClient::QWaylandShellSurface
     , public QtWayland::zwlr_layer_surface_v1 {
 public:
-	QSWaylandLayerSurface(
-	    QSWaylandLayerShellIntegration* shell,
-	    QtWaylandClient::QWaylandWindow* window
-	);
+	LayerSurface(LayerShellIntegration* shell, QtWaylandClient::QWaylandWindow* window);
 
-	~QSWaylandLayerSurface() override;
-	Q_DISABLE_COPY_MOVE(QSWaylandLayerSurface);
+	~LayerSurface() override;
+	Q_DISABLE_COPY_MOVE(LayerSurface);
 
 	[[nodiscard]] bool isExposed() const override;
 	void applyConfigure() override;
-	void setWindowGeometry(const QRect& geometry) override;
+	void setWindowGeometry(const QRect& /*geometry*/) override {}
+
+	void attachPopup(QtWaylandClient::QWaylandShellSurface* popup) override;
+
+	void commit();
 
 private:
 	void zwlr_layer_surface_v1_configure(quint32 serial, quint32 width, quint32 height) override;
 	void zwlr_layer_surface_v1_closed() override;
 
 	QWindow* qwindow();
-	void updateLayer();
-	void updateAnchors();
-	void updateMargins();
-	void updateExclusiveZone();
-	void updateKeyboardFocus();
 
-	LayershellWindowExtension* ext;
-	QSize size;
+	LayerSurfaceBridge* bridge;
 	bool configured = false;
+	QSize size;
 
-	friend class LayershellWindowExtension;
+	LayerSurfaceState committed;
 };
+
+} // namespace qs::wayland::layershell
diff --git a/src/wayland/wlr_layershell/window.cpp b/src/wayland/wlr_layershell/window.cpp
deleted file mode 100644
index b48ecff9..00000000
--- a/src/wayland/wlr_layershell/window.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-#include "window.hpp"
-#include <utility>
-
-#include <private/qwaylandwindow_p.h>
-#include <qlogging.h>
-#include <qobject.h>
-#include <qtmetamacros.h>
-#include <qtypes.h>
-#include <qvariant.h>
-#include <qwindow.h>
-
-#include "../../core/panelinterface.hpp"
-#include "shell_integration.hpp"
-#include "surface.hpp"
-
-LayershellWindowExtension* LayershellWindowExtension::get(QWindow* window) {
-	auto v = window->property("layershell_ext");
-
-	if (v.canConvert<LayershellWindowExtension*>()) {
-		return v.value<LayershellWindowExtension*>();
-	} else {
-		return nullptr;
-	}
-}
-
-bool LayershellWindowExtension::attach(QWindow* window) {
-	if (this->surface != nullptr)
-		throw "Cannot change the attached window of a LayershellWindowExtension";
-
-	auto* current = LayershellWindowExtension::get(window);
-
-	bool hasSurface = false;
-
-	if (current != nullptr) {
-		if (current->mNamespace != this->mNamespace) return false;
-
-		if (current->surface != nullptr) {
-			if (current->surface->qwindow()->screen() != window->screen()) return false;
-			this->surface = current->surface;
-
-			// update window with current settings, leveraging old extension's cached values
-			current->setAnchors(this->mAnchors);
-			current->setMargins(this->mMargins);
-			current->setExclusiveZone(this->mExclusiveZone);
-			current->setLayer(this->mLayer);
-			current->setKeyboardFocus(this->mKeyboardFocus);
-
-			this->surface->ext = this;
-			current->surface = nullptr;
-			current->deleteLater();
-
-			hasSurface = true;
-		}
-	}
-
-	if (!hasSurface) {
-		// Qt appears to be resetting the window's screen on creation on some systems. This works around it.
-		auto* screen = window->screen();
-		window->create();
-		window->setScreen(screen);
-
-		auto* waylandWindow = dynamic_cast<QtWaylandClient::QWaylandWindow*>(window->handle());
-		if (waylandWindow == nullptr) {
-			qWarning() << window << "is not a wayland window. Cannot create layershell surface.";
-			return false;
-		}
-
-		static QSWaylandLayerShellIntegration* layershellIntegration = nullptr; // NOLINT
-		if (layershellIntegration == nullptr) {
-			layershellIntegration = new QSWaylandLayerShellIntegration();
-			if (!layershellIntegration->initialize(waylandWindow->display())) {
-				delete layershellIntegration;
-				layershellIntegration = nullptr;
-				qWarning() << "Failed to initialize layershell integration";
-			}
-		}
-
-		waylandWindow->setShellIntegration(layershellIntegration);
-	}
-
-	this->setParent(window);
-	window->setProperty("layershell_ext", QVariant::fromValue(this));
-	return true;
-}
-
-void LayershellWindowExtension::setAnchors(Anchors anchors) {
-	if (anchors != this->mAnchors) {
-		this->mAnchors = anchors;
-		if (this->surface != nullptr) this->surface->updateAnchors();
-		emit this->anchorsChanged();
-	}
-}
-
-Anchors LayershellWindowExtension::anchors() const { return this->mAnchors; }
-
-void LayershellWindowExtension::setMargins(Margins margins) {
-	if (margins != this->mMargins) {
-		this->mMargins = margins;
-		if (this->surface != nullptr) this->surface->updateMargins();
-		emit this->marginsChanged();
-	}
-}
-
-Margins LayershellWindowExtension::margins() const { return this->mMargins; }
-
-void LayershellWindowExtension::setExclusiveZone(qint32 exclusiveZone) {
-	if (exclusiveZone != this->mExclusiveZone) {
-		this->mExclusiveZone = exclusiveZone;
-		if (this->surface != nullptr) this->surface->updateExclusiveZone();
-		emit this->exclusiveZoneChanged();
-	}
-}
-
-qint32 LayershellWindowExtension::exclusiveZone() const { return this->mExclusiveZone; }
-
-void LayershellWindowExtension::setLayer(Layer::Enum layer) {
-	if (layer != this->mLayer) {
-		this->mLayer = layer;
-		if (this->surface != nullptr) this->surface->updateLayer();
-		emit this->layerChanged();
-	}
-}
-
-Layer::Enum LayershellWindowExtension::layer() const { return this->mLayer; }
-
-void LayershellWindowExtension::setKeyboardFocus(KeyboardFocus::Enum focus) {
-	if (focus != this->mKeyboardFocus) {
-		this->mKeyboardFocus = focus;
-		if (this->surface != nullptr) this->surface->updateKeyboardFocus();
-		emit this->keyboardFocusChanged();
-	}
-}
-
-KeyboardFocus::Enum LayershellWindowExtension::keyboardFocus() const {
-	return this->mKeyboardFocus;
-}
-
-void LayershellWindowExtension::setUseWindowScreen(bool value) {
-	this->useWindowScreen = value; // has no effect post configure
-}
-
-void LayershellWindowExtension::setNamespace(QString ns) {
-	if (!this->isConfigured()) this->mNamespace = std::move(ns);
-}
-
-QString LayershellWindowExtension::ns() const { return this->mNamespace; }
-
-bool LayershellWindowExtension::isConfigured() const { return this->surface != nullptr; }
diff --git a/src/wayland/wlr_layershell/window.hpp b/src/wayland/wlr_layershell/window.hpp
deleted file mode 100644
index 59de5c95..00000000
--- a/src/wayland/wlr_layershell/window.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#pragma once
-
-#include <qobject.h>
-#include <qscreen.h>
-#include <qtmetamacros.h>
-#include <qtypes.h>
-#include <qwindow.h>
-
-#include "../../core/panelinterface.hpp"
-
-///! WlrLayershell layer
-namespace Layer { // NOLINT
-Q_NAMESPACE;
-QML_ELEMENT;
-
-enum Enum {
-	/// Below bottom
-	Background = 0,
-	/// Above background, usually below windows
-	Bottom = 1,
-	/// Commonly used for panels, app launchers, and docks.
-	/// Usually renders over normal windows and below fullscreen windows.
-	Top = 2,
-	/// Usually renders over fullscreen windows
-	Overlay = 3,
-};
-Q_ENUM_NS(Enum);
-
-} // namespace Layer
-
-///! WlrLayershell keyboard focus mode
-namespace KeyboardFocus { // NOLINT
-Q_NAMESPACE;
-QML_ELEMENT;
-
-enum Enum {
-	/// No keyboard input will be accepted.
-	None = 0,
-	/// Exclusive access to the keyboard, locking out all other windows.
-	Exclusive = 1,
-	/// Access to the keyboard as determined by the operating system.
-	///
-	/// > [!WARNING] On some systems, `OnDemand` may cause the shell window to
-	/// > retain focus over another window unexpectedly.
-	/// > You should try `None` if you experience issues.
-	OnDemand = 2,
-};
-Q_ENUM_NS(Enum);
-
-} // namespace KeyboardFocus
-
-class QSWaylandLayerSurface;
-
-class LayershellWindowExtension: public QObject {
-	Q_OBJECT;
-
-public:
-	LayershellWindowExtension(QObject* parent = nullptr): QObject(parent) {}
-
-	// returns the layershell extension if attached, otherwise nullptr
-	static LayershellWindowExtension* get(QWindow* window);
-
-	// Attach this layershell extension to the given window.
-	// The extension is reparented to the window and replaces any existing layershell extension.
-	// Returns false if the window cannot be used.
-	bool attach(QWindow* window);
-
-	void setAnchors(Anchors anchors);
-	[[nodiscard]] Anchors anchors() const;
-
-	void setMargins(Margins margins);
-	[[nodiscard]] Margins margins() const;
-
-	void setExclusiveZone(qint32 exclusiveZone);
-	[[nodiscard]] qint32 exclusiveZone() const;
-
-	void setLayer(Layer::Enum layer);
-	[[nodiscard]] Layer::Enum layer() const;
-
-	void setKeyboardFocus(KeyboardFocus::Enum focus);
-	[[nodiscard]] KeyboardFocus::Enum keyboardFocus() const;
-
-	// no effect if configured
-	void setUseWindowScreen(bool value);
-	void setNamespace(QString ns);
-	[[nodiscard]] QString ns() const;
-	[[nodiscard]] bool isConfigured() const;
-
-signals:
-	void anchorsChanged();
-	void marginsChanged();
-	void exclusiveZoneChanged();
-	void layerChanged();
-	void keyboardFocusChanged();
-
-private:
-	// if configured the screen cannot be changed
-	QSWaylandLayerSurface* surface = nullptr;
-
-	bool useWindowScreen = false;
-	Anchors mAnchors;
-	Margins mMargins;
-	qint32 mExclusiveZone = 0;
-	Layer::Enum mLayer = Layer::Top;
-	QString mNamespace = "quickshell";
-	KeyboardFocus::Enum mKeyboardFocus = KeyboardFocus::None;
-
-	friend class QSWaylandLayerSurface;
-};
diff --git a/src/wayland/wlr_layershell/wlr_layershell.cpp b/src/wayland/wlr_layershell/wlr_layershell.cpp
new file mode 100644
index 00000000..2b77690a
--- /dev/null
+++ b/src/wayland/wlr_layershell/wlr_layershell.cpp
@@ -0,0 +1,211 @@
+#include "wlr_layershell.hpp"
+
+#include <qlogging.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qqmllist.h>
+#include <qquickitem.h>
+#include <qtypes.h>
+
+#include "../../core/qmlscreen.hpp"
+#include "../../window/panelinterface.hpp"
+#include "../../window/proxywindow.hpp"
+#include "surface.hpp"
+
+namespace qs::wayland::layershell {
+
+WlrLayershell::WlrLayershell(QObject* parent): ProxyWindowBase(parent) {
+	this->bcExclusiveZone.setBinding([this]() -> qint32 {
+		switch (this->bExclusionMode.value()) {
+		case ExclusionMode::Ignore: return -1;
+		case ExclusionMode::Normal: return this->bExclusiveZone;
+		case ExclusionMode::Auto:
+			const auto margins = this->bMargins.value();
+
+			// add reverse edge margins which are ignored by wlr-layer-shell
+			switch (this->bcExclusionEdge.value()) {
+			case Qt::TopEdge: return this->bImplicitHeight + margins.bottom;
+			case Qt::BottomEdge: return this->bImplicitHeight + margins.top;
+			case Qt::LeftEdge: return this->bImplicitWidth + margins.right;
+			case Qt::RightEdge: return this->bImplicitWidth + margins.left;
+			default: return 0;
+			}
+		}
+	});
+
+	this->bcExclusionEdge.setBinding([this] { return this->bAnchors.value().exclusionEdge(); });
+}
+
+ProxiedWindow* WlrLayershell::retrieveWindow(QObject* oldInstance) {
+	auto* old = qobject_cast<WlrLayershell*>(oldInstance);
+	auto* window = old == nullptr ? nullptr : old->disownWindow();
+
+	if (window != nullptr) {
+		this->connectBridge(LayerSurfaceBridge::init(window, this->computeState()));
+
+		if (this->bridge) {
+			return window;
+		} else {
+			window->deleteLater();
+		}
+	}
+
+	return this->createQQuickWindow();
+}
+
+ProxiedWindow* WlrLayershell::createQQuickWindow() {
+	auto* window = this->ProxyWindowBase::createQQuickWindow();
+
+	this->connectBridge(LayerSurfaceBridge::init(window, this->computeState()));
+	if (!this->bridge) {
+		qWarning() << "Could not attach Layershell extension to new QQuickWindow. Layer will not "
+		              "behave correctly.";
+	}
+
+	return window;
+}
+
+void WlrLayershell::connectWindow() {
+	this->ProxyWindowBase::connectWindow();
+
+	QObject::connect(this, &ProxyWindowBase::widthChanged, this, &WlrLayershell::updateAutoExclusion);
+
+	QObject::connect(
+	    this,
+	    &ProxyWindowBase::heightChanged,
+	    this,
+	    &WlrLayershell::updateAutoExclusion
+	);
+
+	this->updateAutoExclusion();
+}
+
+ProxiedWindow* WlrLayershell::disownWindow(bool keepItemOwnership) {
+	auto* window = this->ProxyWindowBase::disownWindow(keepItemOwnership);
+
+	if (this->bridge) {
+		this->connectBridge(nullptr);
+	}
+
+	return window;
+}
+
+void WlrLayershell::connectBridge(LayerSurfaceBridge* bridge) {
+	if (this->bridge) {
+		QObject::disconnect(this->bridge, nullptr, this, nullptr);
+	}
+
+	this->bridge = bridge;
+
+	if (bridge) {
+		QObject::connect(this->bridge, &QObject::destroyed, this, &WlrLayershell::onBridgeDestroyed);
+	}
+}
+
+void WlrLayershell::onBridgeDestroyed() { this->bridge = nullptr; }
+
+bool WlrLayershell::deleteOnInvisible() const {
+	// Qt windows behave weirdly when geometry is modified and setVisible(false)
+	// is subsequently called in the same frame.
+	// It will attach buffers to the wayland surface unconditionally before
+	// the surface recieves a configure event, causing a protocol error.
+	// To remedy this we forcibly disallow window reuse.
+	return true;
+}
+
+void WlrLayershell::onPolished() {
+	if (this->bridge) {
+		this->bridge->state = this->computeState();
+		this->bridge->commitState();
+	}
+
+	this->ProxyWindowBase::onPolished();
+}
+
+void WlrLayershell::trySetWidth(qint32 /*implicitWidth*/) { this->onStateChanged(); }
+void WlrLayershell::trySetHeight(qint32 /*implicitHeight*/) { this->onStateChanged(); }
+
+void WlrLayershell::setScreen(QuickshellScreenInfo* screen) {
+	this->compositorPicksScreen = screen == nullptr;
+	this->ProxyWindowBase::setScreen(screen);
+}
+
+void WlrLayershell::onStateChanged() { this->schedulePolish(); }
+
+bool WlrLayershell::aboveWindows() const { return this->layer() > WlrLayer::Bottom; }
+
+void WlrLayershell::setAboveWindows(bool aboveWindows) {
+	this->setLayer(aboveWindows ? WlrLayer::Top : WlrLayer::Bottom);
+}
+
+bool WlrLayershell::focusable() const { return this->keyboardFocus() != WlrKeyboardFocus::None; }
+
+void WlrLayershell::setFocusable(bool focusable) {
+	this->setKeyboardFocus(focusable ? WlrKeyboardFocus::OnDemand : WlrKeyboardFocus::None);
+}
+
+LayerSurfaceState WlrLayershell::computeState() const {
+	return LayerSurfaceState {
+	    .implicitSize = QSize(this->implicitWidth(), this->implicitHeight()),
+	    .anchors = this->bAnchors,
+	    .margins = this->bMargins,
+	    .layer = this->bLayer,
+	    .exclusiveZone = this->bcExclusiveZone,
+	    .keyboardFocus = this->bKeyboardFocus,
+	    .compositorPickesScreen = this->compositorPicksScreen,
+	    .mNamespace = this->bNamespace,
+	};
+}
+
+void WlrLayershell::updateAutoExclusion() { this->bcExclusiveZone.notify(); }
+
+WlrLayershell* WlrLayershell::qmlAttachedProperties(QObject* object) {
+	if (auto* obj = qobject_cast<WaylandPanelInterface*>(object)) {
+		return obj->layer;
+	} else {
+		return nullptr;
+	}
+}
+
+// WaylandPanelInterface
+
+WaylandPanelInterface::WaylandPanelInterface(QObject* parent)
+    : PanelWindowInterface(parent)
+    , layer(new WlrLayershell(this)) {
+	this->connectSignals();
+
+	// clang-format off
+	QObject::connect(this->layer, &WlrLayershell::anchorsChanged, this, &WaylandPanelInterface::anchorsChanged);
+	QObject::connect(this->layer, &WlrLayershell::marginsChanged, this, &WaylandPanelInterface::marginsChanged);
+	QObject::connect(this->layer, &WlrLayershell::exclusiveZoneChanged, this, &WaylandPanelInterface::exclusiveZoneChanged);
+	QObject::connect(this->layer, &WlrLayershell::exclusionModeChanged, this, &WaylandPanelInterface::exclusionModeChanged);
+	QObject::connect(this->layer, &WlrLayershell::layerChanged, this, &WaylandPanelInterface::aboveWindowsChanged);
+	QObject::connect(this->layer, &WlrLayershell::keyboardFocusChanged, this, &WaylandPanelInterface::focusableChanged);
+	// clang-format on
+}
+
+void WaylandPanelInterface::onReload(QObject* oldInstance) {
+	QQmlEngine::setContextForObject(this->layer, QQmlEngine::contextForObject(this));
+
+	auto* old = qobject_cast<WaylandPanelInterface*>(oldInstance);
+	this->layer->reload(old != nullptr ? old->layer : nullptr);
+}
+
+ProxyWindowBase* WaylandPanelInterface::proxyWindow() const { return this->layer; }
+
+// NOLINTBEGIN
+#define proxyPair(type, get, set)                                                                  \
+	type WaylandPanelInterface::get() const { return this->layer->get(); }                           \
+	void WaylandPanelInterface::set(type value) { this->layer->set(value); }
+
+proxyPair(Anchors, anchors, setAnchors);
+proxyPair(Margins, margins, setMargins);
+proxyPair(qint32, exclusiveZone, setExclusiveZone);
+proxyPair(ExclusionMode::Enum, exclusionMode, setExclusionMode);
+proxyPair(bool, focusable, setFocusable);
+proxyPair(bool, aboveWindows, setAboveWindows);
+
+#undef proxyPair
+// NOLINTEND
+
+} // namespace qs::wayland::layershell
diff --git a/src/wayland/wlr_layershell/wlr_layershell.hpp b/src/wayland/wlr_layershell/wlr_layershell.hpp
new file mode 100644
index 00000000..0f5617f7
--- /dev/null
+++ b/src/wayland/wlr_layershell/wlr_layershell.hpp
@@ -0,0 +1,246 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qquickitem.h>
+#include <qquickwindow.h>
+#include <qsize.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../core/doc.hpp"
+#include "../../core/util.hpp"
+#include "../../window/panelinterface.hpp"
+#include "../../window/proxywindow.hpp"
+
+namespace qs::wayland::layershell {
+
+struct LayerSurfaceState;
+class LayerSurfaceBridge;
+
+///! WlrLayershell layer.
+/// See @@WlrLayershell.layer.
+namespace WlrLayer { // NOLINT
+Q_NAMESPACE;
+QML_ELEMENT;
+
+enum Enum : quint8 {
+	/// Below bottom
+	Background = 0,
+	/// Above background, usually below windows
+	Bottom = 1,
+	/// Commonly used for panels, app launchers, and docks.
+	/// Usually renders over normal windows and below fullscreen windows.
+	Top = 2,
+	/// Usually renders over fullscreen windows
+	Overlay = 3,
+};
+Q_ENUM_NS(Enum);
+
+} // namespace WlrLayer
+
+///! WlrLayershell keyboard focus mode
+/// See @@WlrLayershell.keyboardFocus.
+namespace WlrKeyboardFocus { // NOLINT
+Q_NAMESPACE;
+QML_ELEMENT;
+
+enum Enum : quint8 {
+	/// No keyboard input will be accepted.
+	None = 0,
+	/// Exclusive access to the keyboard, locking out all other windows.
+	///
+	/// > [!WARNING] You **CANNOT** use this to make a secure lock screen.
+	/// >
+	/// > If you want to make a lock screen, use @@WlSessionLock.
+	Exclusive = 1,
+	/// Access to the keyboard as determined by the operating system.
+	///
+	/// > [!WARNING] On some systems, `OnDemand` may cause the shell window to
+	/// > retain focus over another window unexpectedly.
+	/// > You should try `None` if you experience issues.
+	OnDemand = 2,
+};
+Q_ENUM_NS(Enum);
+
+} // namespace WlrKeyboardFocus
+
+///! Wlroots layershell window
+/// Decorationless window that can be attached to the screen edges using the [zwlr_layer_shell_v1] protocol.
+///
+/// #### Attached object
+/// `WlrLayershell` works as an attached object of @@Quickshell.PanelWindow which you should use instead if you can,
+/// as it is platform independent.
+///
+/// ```qml
+/// PanelWindow {
+///   // When PanelWindow is backed with WlrLayershell this will work
+///   WlrLayershell.layer: WlrLayer.Bottom
+/// }
+/// ```
+///
+/// To maintain platform compatibility you can dynamically set layershell specific properties.
+/// ```qml
+/// PanelWindow {
+///   Component.onCompleted: {
+///     if (this.WlrLayershell != null) {
+///       this.WlrLayershell.layer = WlrLayer.Bottom;
+///     }
+///   }
+/// }
+/// ```
+///
+/// [zwlr_layer_shell_v1]: https://wayland.app/protocols/wlr-layer-shell-unstable-v1
+class WlrLayershell: public ProxyWindowBase {
+	QSDOC_BASECLASS(PanelWindowInterface);
+	// clang-format off
+	Q_OBJECT;
+	/// The shell layer the window sits in. Defaults to `WlrLayer.Top`.
+	Q_PROPERTY(qs::wayland::layershell::WlrLayer::Enum layer READ layer WRITE setLayer NOTIFY layerChanged);
+	/// Similar to the class property of windows. Can be used to identify the window to external tools.
+	///
+	/// Cannot be set after windowConnected.
+	Q_PROPERTY(QString namespace READ ns WRITE setNamespace NOTIFY namespaceChanged);
+	/// The degree of keyboard focus taken. Defaults to `KeyboardFocus.None`.
+	Q_PROPERTY(qs::wayland::layershell::WlrKeyboardFocus::Enum keyboardFocus READ keyboardFocus WRITE setKeyboardFocus NOTIFY keyboardFocusChanged);
+
+	QSDOC_HIDE Q_PROPERTY(Anchors anchors READ anchors WRITE setAnchors NOTIFY anchorsChanged);
+	QSDOC_HIDE Q_PROPERTY(qint32 exclusiveZone READ exclusiveZone WRITE setExclusiveZone NOTIFY exclusiveZoneChanged);
+	QSDOC_HIDE Q_PROPERTY(ExclusionMode::Enum exclusionMode READ exclusionMode WRITE setExclusionMode NOTIFY exclusionModeChanged);
+	QSDOC_HIDE Q_PROPERTY(Margins margins READ margins WRITE setMargins NOTIFY marginsChanged);
+	QSDOC_HIDE Q_PROPERTY(bool aboveWindows READ aboveWindows WRITE setAboveWindows NOTIFY layerChanged);
+	QSDOC_HIDE Q_PROPERTY(bool focusable READ focusable WRITE setFocusable NOTIFY keyboardFocusChanged);
+	QML_ATTACHED(WlrLayershell);
+	QML_ELEMENT;
+	// clang-format on
+
+public:
+	explicit WlrLayershell(QObject* parent = nullptr);
+
+	ProxiedWindow* retrieveWindow(QObject* oldInstance) override;
+	ProxiedWindow* createQQuickWindow() override;
+	void connectWindow() override;
+	ProxiedWindow* disownWindow(bool keepItemOwnership = false) override;
+	[[nodiscard]] bool deleteOnInvisible() const override;
+
+	void onPolished() override;
+	void trySetWidth(qint32 implicitWidth) override;
+	void trySetHeight(qint32 implicitHeight) override;
+
+	void setScreen(QuickshellScreenInfo* screen) override;
+
+	[[nodiscard]] WlrLayer::Enum layer() const { return this->bLayer; }
+	void setLayer(WlrLayer::Enum layer) { this->bLayer = layer; }
+
+	[[nodiscard]] QString ns() const { return this->bNamespace; }
+	void setNamespace(const QString& ns) { this->bNamespace = ns; }
+
+	[[nodiscard]] WlrKeyboardFocus::Enum keyboardFocus() const { return this->bKeyboardFocus; }
+	void setKeyboardFocus(WlrKeyboardFocus::Enum focus) { this->bKeyboardFocus = focus; }
+
+	[[nodiscard]] Anchors anchors() const { return this->bAnchors; }
+	void setAnchors(Anchors anchors) { this->bAnchors = anchors; }
+
+	[[nodiscard]] qint32 exclusiveZone() const { return this->bExclusiveZone; }
+	void setExclusiveZone(qint32 exclusiveZone) {
+		Qt::beginPropertyUpdateGroup();
+		this->bExclusiveZone = exclusiveZone;
+		this->bExclusionMode = ExclusionMode::Normal;
+		Qt::endPropertyUpdateGroup();
+	}
+
+	[[nodiscard]] ExclusionMode::Enum exclusionMode() const { return this->bExclusionMode; }
+	void setExclusionMode(ExclusionMode::Enum exclusionMode) { this->bExclusionMode = exclusionMode; }
+
+	[[nodiscard]] Margins margins() const { return this->bMargins; }
+	void setMargins(Margins margins) { this->bMargins = margins; }
+
+	[[nodiscard]] bool aboveWindows() const;
+	void setAboveWindows(bool aboveWindows);
+
+	[[nodiscard]] bool focusable() const;
+	void setFocusable(bool focusable);
+
+	static WlrLayershell* qmlAttachedProperties(QObject* object);
+
+signals:
+	void layerChanged();
+	void namespaceChanged();
+	void keyboardFocusChanged();
+	QSDOC_HIDE void anchorsChanged();
+	QSDOC_HIDE void exclusiveZoneChanged();
+	QSDOC_HIDE void exclusionModeChanged();
+	QSDOC_HIDE void marginsChanged();
+
+private slots:
+	void updateAutoExclusion();
+	void onBridgeDestroyed();
+
+private:
+	[[nodiscard]] LayerSurfaceState computeState() const;
+
+	void connectBridge(LayerSurfaceBridge* bridge);
+	void onStateChanged();
+
+	bool compositorPicksScreen = true;
+	LayerSurfaceBridge* bridge = nullptr;
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(WlrLayershell, WlrLayer::Enum, bLayer, WlrLayer::Top, &WlrLayershell::layerChanged);
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(WlrLayershell, QString, bNamespace, "quickshell", &WlrLayershell::namespaceChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(WlrLayershell, Anchors, bAnchors, &WlrLayershell::anchorsChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(WlrLayershell, Margins, bMargins, &WlrLayershell::marginsChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(WlrLayershell, qint32, bExclusiveZone, &WlrLayershell::exclusiveZoneChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(WlrLayershell, WlrKeyboardFocus::Enum, bKeyboardFocus, &WlrLayershell::keyboardFocusChanged);
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(WlrLayershell, ExclusionMode::Enum, bExclusionMode, ExclusionMode::Auto, &WlrLayershell::exclusionModeChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(WlrLayershell, qint32, bcExclusiveZone);
+	Q_OBJECT_BINDABLE_PROPERTY(WlrLayershell, Qt::Edge, bcExclusionEdge);
+
+	QS_BINDING_SUBSCRIBE_METHOD(WlrLayershell, bLayer, onStateChanged, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(WlrLayershell, bAnchors, onStateChanged, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(WlrLayershell, bMargins, onStateChanged, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(WlrLayershell, bcExclusiveZone, onStateChanged, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(WlrLayershell, bKeyboardFocus, onStateChanged, onValueChanged);
+	// clang-format on
+};
+
+class WaylandPanelInterface: public PanelWindowInterface {
+	Q_OBJECT;
+
+public:
+	explicit WaylandPanelInterface(QObject* parent = nullptr);
+
+	void onReload(QObject* oldInstance) override;
+
+	[[nodiscard]] ProxyWindowBase* proxyWindow() const override;
+
+	// NOLINTBEGIN
+	[[nodiscard]] Anchors anchors() const override;
+	void setAnchors(Anchors anchors) override;
+
+	[[nodiscard]] Margins margins() const override;
+	void setMargins(Margins margins) override;
+
+	[[nodiscard]] qint32 exclusiveZone() const override;
+	void setExclusiveZone(qint32 exclusiveZone) override;
+
+	[[nodiscard]] ExclusionMode::Enum exclusionMode() const override;
+	void setExclusionMode(ExclusionMode::Enum exclusionMode) override;
+
+	[[nodiscard]] bool aboveWindows() const override;
+	void setAboveWindows(bool aboveWindows) override;
+
+	[[nodiscard]] bool focusable() const override;
+	void setFocusable(bool focusable) override;
+	// NOLINTEND
+
+private:
+	WlrLayershell* layer;
+
+	friend class WlrLayershell;
+};
+
+} // namespace qs::wayland::layershell
diff --git a/src/wayland/xdgshell.cpp b/src/wayland/xdgshell.cpp
new file mode 100644
index 00000000..8677d1b5
--- /dev/null
+++ b/src/wayland/xdgshell.cpp
@@ -0,0 +1,14 @@
+#include "xdgshell.hpp"
+
+#include <qwaylandclientextension.h>
+
+namespace qs::wayland::xdg_shell {
+
+XdgWmBase::XdgWmBase(): QWaylandClientExtensionTemplate(6) { this->initialize(); }
+
+XdgWmBase* XdgWmBase::instance() {
+	static auto* instance = new XdgWmBase(); // NOLINT
+	return instance;
+}
+
+} // namespace qs::wayland::xdg_shell
diff --git a/src/wayland/xdgshell.hpp b/src/wayland/xdgshell.hpp
new file mode 100644
index 00000000..735ba679
--- /dev/null
+++ b/src/wayland/xdgshell.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <private/qwayland-xdg-shell.h>
+#include <qwaylandclientextension.h>
+
+namespace qs::wayland::xdg_shell {
+
+// Hack that binds xdg_wm_base twice as QtWaylandXdgShell headers are not exported anywhere.
+
+class XdgWmBase
+    : public QWaylandClientExtensionTemplate<XdgWmBase>
+    , public QtWayland::xdg_wm_base {
+public:
+	static XdgWmBase* instance();
+
+private:
+	explicit XdgWmBase();
+};
+
+} // namespace qs::wayland::xdg_shell
diff --git a/src/widgets/CMakeLists.txt b/src/widgets/CMakeLists.txt
new file mode 100644
index 00000000..ec1dd4f0
--- /dev/null
+++ b/src/widgets/CMakeLists.txt
@@ -0,0 +1,40 @@
+qt_add_library(quickshell-widgets STATIC
+	cliprect.cpp
+	wrapper.cpp
+	marginwrapper.cpp
+)
+
+qt_add_qml_module(quickshell-widgets
+	URI Quickshell.Widgets
+	VERSION 0.1
+	QML_FILES
+		IconImage.qml
+		ClippingRectangle.qml
+		WrapperItem.qml
+		WrapperMouseArea.qml
+		WrapperRectangle.qml
+		ClippingWrapperRectangle.qml
+		ClippingWrapperRectangleInternal.qml
+)
+
+qt6_add_shaders(quickshell-widgets "widgets-cliprect"
+	NOHLSL NOMSL BATCHABLE PRECOMPILE OPTIMIZED QUIET
+	PREFIX "/Quickshell/Widgets"
+	FILES shaders/cliprect.frag
+	OUTPUTS shaders/cliprect.frag.qsb
+)
+
+qt6_add_shaders(quickshell-widgets "widgets-cliprect-ub"
+	NOHLSL NOMSL BATCHABLE PRECOMPILE OPTIMIZED QUIET
+	PREFIX "/Quickshell/Widgets"
+	FILES shaders/cliprect.frag
+	OUTPUTS shaders/cliprect-ub.frag.qsb
+	DEFINES CONTENT_UNDER_BORDER
+)
+
+install_qml_module(quickshell-widgets)
+
+qs_module_pch(quickshell-widgets)
+
+target_link_libraries(quickshell-widgets PRIVATE Qt::Quick)
+target_link_libraries(quickshell PRIVATE quickshell-widgetsplugin)
diff --git a/src/widgets/ClippingRectangle.qml b/src/widgets/ClippingRectangle.qml
new file mode 100644
index 00000000..86fe6019
--- /dev/null
+++ b/src/widgets/ClippingRectangle.qml
@@ -0,0 +1,88 @@
+import QtQuick
+
+///! Rectangle capable of clipping content inside its border.
+/// > [!WARNING] This type requires at least Qt 6.7.
+///
+/// This is a specialized version of @@QtQuick.Rectangle that clips content
+/// inside of its border, including rounded rectangles. It costs more than
+/// @@QtQuick.Rectangle, so it should not be used unless you need to clip
+/// items inside of it to the border.
+Item {
+	id: root
+
+	/// If content should be displayed underneath the border.
+	///
+	/// Defaults to false, does nothing if the border is opaque.
+	property bool contentUnderBorder: false
+	/// If the content item should be resized to fit inside the border.
+	///
+	/// Defaults to `!contentUnderBorder`. Most useful when combined with
+	/// `anchors.fill: parent` on an item passed to the ClippingRectangle.
+	property bool contentInsideBorder: !root.contentUnderBorder
+	/// If the rectangle should be antialiased.
+	///
+	/// Defaults to true if any corner has a non-zero radius, otherwise false.
+	property /*bool*/alias antialiasing: rectangle.antialiasing
+	/// The background color of the rectangle, which goes under its content.
+	property /*color*/alias color: shader.backgroundColor
+	/// See @@QtQuick.Rectangle.border.
+	property clippingRectangleBorder border
+	/// Radius of all corners. Defaults to 0.
+	property /*real*/alias radius: rectangle.radius
+	/// Radius of the top left corner. Defaults to @@radius.
+	property /*real*/alias topLeftRadius: rectangle.topLeftRadius
+	/// Radius of the top right corner. Defaults to @@radius.
+	property /*real*/alias topRightRadius: rectangle.topRightRadius
+	/// Radius of the bottom left corner. Defaults to @@radius.
+	property /*real*/alias bottomLeftRadius: rectangle.bottomLeftRadius
+	/// Radius of the bottom right corner. Defaults to @@radius.
+	property /*real*/alias bottomRightRadius: rectangle.bottomRightRadius
+
+	/// Data of the ClippingRectangle's @@contentItem. (`list<QtObject>`).
+	///
+	/// See @@QtQuick.Item.data for details.
+	default property alias data: contentItem.data
+	/// Visual children of the ClippingRectangle's @@contentItem. (`list<Item>`).
+	///
+	/// See @@QtQuick.Item.children for details.
+	property alias children: contentItem.children
+	/// The item containing the rectangle's content.
+	/// There is usually no reason to use this directly.
+	readonly property alias contentItem: contentItem
+
+	Rectangle {
+		id: rectangle
+		anchors.fill: root
+		color: "#ffff0000"
+		border.color: "#ff00ff00"
+		border.pixelAligned: root.border.pixelAligned
+		border.width: root.border.width
+		layer.enabled: true
+		visible: false
+	}
+
+	Item {
+		id: contentItemContainer
+		anchors.fill: root
+
+		Item {
+			id: contentItem
+			anchors.fill: parent
+			anchors.margins: root.contentInsideBorder ? root.border.width : 0
+		}
+	}
+
+	ShaderEffect {
+		id: shader
+		anchors.fill: root
+		fragmentShader: `qrc:/Quickshell/Widgets/shaders/cliprect${root.contentUnderBorder ? "-ub" : ""}.frag.qsb`
+		property Rectangle rect: rectangle
+		property color backgroundColor: "white"
+		property color borderColor: root.border.color
+
+		property ShaderEffectSource content: ShaderEffectSource {
+			hideSource: true
+			sourceItem: contentItemContainer
+		}
+	}
+}
diff --git a/src/widgets/ClippingWrapperRectangle.qml b/src/widgets/ClippingWrapperRectangle.qml
new file mode 100644
index 00000000..d12bd156
--- /dev/null
+++ b/src/widgets/ClippingWrapperRectangle.qml
@@ -0,0 +1,63 @@
+import QtQuick
+
+///! ClippingRectangle that handles sizes and positioning for a single visual child.
+/// This component is useful for adding a clipping border or background rectangle to
+/// a child item. If you don't need clipping, use @@WrapperRectangle.
+///
+/// > [!NOTE] ClippingWrapperRectangle is a @@MarginWrapperManager based component.
+/// > See its documentation for information on how margins and sizes are calculated.
+///
+/// > [!WARNING] You should not set @@Item.x, @@Item.y, @@Item.width,
+/// > @@Item.height or @@Item.anchors on the child item, as they are used
+/// > by WrapperItem to position it. Instead set @@Item.implicitWidth and
+/// > @@Item.implicitHeight.
+ClippingWrapperRectangleInternal {
+	id: root
+
+	/// The default for @@topMargin, @@bottomMargin, @@leftMargin and @@rightMargin.
+	/// Defaults to 0.
+	property /*real*/alias margin: manager.margin
+	/// An extra margin applied in addition to @@topMargin, @@bottomMargin,
+	/// @@leftMargin, and @@rightMargin.
+	/// If @@contentInsideBorder is true, the rectangle's border width will be added
+	/// to this property. Defaults to 0.
+	property /*real*/alias extraMargin: manager.extraMargin
+	/// The requested top margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias topMargin: manager.topMargin
+	/// The requested bottom margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias bottomMargin: manager.bottomMargin
+	/// The requested left margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias leftMargin: manager.leftMargin
+	/// The requested right margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias rightMargin: manager.rightMargin
+	/// Determines if child item should be resized larger than its implicit size if
+	/// the parent is resized larger than its implicit size. Defaults to true.
+	property /*bool*/alias resizeChild: manager.resizeChild
+	/// Overrides the implicit width of the wrapper.
+	///
+	/// Defaults to the implicit width of the content item plus its left and right margin,
+	/// and may be reset by assigning `undefined`.
+	property /*real*/alias implicitWidth: manager.implicitWidth
+	/// Overrides the implicit height of the wrapper.
+	///
+	/// Defaults to the implicit width of the content item plus its top and bottom margin,
+	/// and may be reset by assigning `undefined`.
+	property /*real*/alias implicitHeight: manager.implicitHeight
+	/// See @@WrapperManager.child for details.
+	property alias child: manager.child
+
+	border.width: 0
+
+	__implicitWidthInternal: root.contentItem.implicitWidth + (root.contentInsideBorder ? root.border.width * 2 : 0)
+	__implicitHeightInternal: root.contentItem.implicitHeight + (root.contentInsideBorder ? root.border.width * 2 : 0)
+
+	MarginWrapperManager { id: manager }
+}
diff --git a/src/widgets/ClippingWrapperRectangleInternal.qml b/src/widgets/ClippingWrapperRectangleInternal.qml
new file mode 100644
index 00000000..4bd67873
--- /dev/null
+++ b/src/widgets/ClippingWrapperRectangleInternal.qml
@@ -0,0 +1,7 @@
+import QtQuick
+
+ClippingRectangle {
+	id: root
+	property alias __implicitWidthInternal: root.implicitWidth
+	property alias __implicitHeightInternal: root.implicitHeight
+}
diff --git a/src/widgets/IconImage.qml b/src/widgets/IconImage.qml
new file mode 100644
index 00000000..dd8a5f11
--- /dev/null
+++ b/src/widgets/IconImage.qml
@@ -0,0 +1,67 @@
+import QtQuick
+
+///! Image component for displaying widget/icon style images.
+/// This is a specialization of @@QtQuick.Image configured for icon-style images,
+/// designed to make it easier to use correctly. If you need more control, use
+/// @@QtQuick.Image directly.
+///
+/// The image's aspect raito is assumed to be 1:1. If it is not 1:1, padding
+/// will be added to make it 1:1. This is currently applied before the actual
+/// aspect ratio of the image is taken into account, and may change in a future
+/// release.
+///
+/// You should use it for:
+/// - Icons for custom buttons
+/// - Status indicator icons
+/// - System tray icons
+/// - Things similar to the above.
+///
+/// Do not use it for:
+/// - Big images
+/// - Images that change size frequently
+/// - Anything that doesn't feel like an icon.
+///
+/// > [!INFO] More information about many of these properties can be found in
+/// > the documentation for @@QtQuick.Image.
+Item {
+	id: root
+
+	/// URL of the image. Defaults to an empty string.
+	/// See @@QtQuick.Image.source.
+	property /*string*/alias source: image.source
+	/// If the image should be loaded asynchronously. Defaults to false.
+	/// See @@QtQuick.Image.asynchronous.
+	property /*bool*/alias asynchronous: image.asynchronous
+	/// The load status of the image. See @@QtQuick.Image.status.
+	property alias status: image.status
+	/// If the image should be mipmap filtered. Defaults to false.
+	/// See @@QtQuick.Image.mipmap.
+	///
+	/// Try enabling this if your image is significantly scaled down
+	/// and looks bad because of it.
+	property /*bool*/alias mipmap: image.mipmap
+	/// The @@QtQuick.Image backing this object.
+	///
+	/// This is useful if you need to access more functionality than
+	/// exposed by IconImage.
+	property /*Image*/alias backer: image
+
+	/// The suggested size of the image. This is used as a defualt
+	/// for @@QtQuick.Item.implicitWidth and @@QtQuick.Item.implicitHeight.
+	property real implicitSize: 0
+
+	/// The actual size the image will be displayed at.
+	readonly property real actualSize: Math.min(root.width, root.height)
+
+	implicitWidth: root.implicitSize
+	implicitHeight: root.implicitSize
+
+	Image {
+		id: image
+		anchors.fill: parent
+		fillMode: Image.PreserveAspectFit
+
+		sourceSize.width: root.actualSize
+		sourceSize.height: root.actualSize
+	}
+}
diff --git a/src/widgets/WrapperItem.qml b/src/widgets/WrapperItem.qml
new file mode 100644
index 00000000..5a1093e8
--- /dev/null
+++ b/src/widgets/WrapperItem.qml
@@ -0,0 +1,72 @@
+import QtQuick
+
+///! Item that handles sizes and positioning for a single visual child.
+/// This component is useful when you need to wrap a single component in
+/// an item, or give a single component a margin. See [QtQuick.Layouts]
+/// for positioning multiple items.
+///
+/// > [!NOTE] WrapperItem is a @@MarginWrapperManager based component.
+/// > See its documentation for information on how margins and sizes are calculated.
+///
+/// ### Example: Adding a margin to an item
+/// The snippet below adds a 10px margin to all sides of the @@QtQuick.Text item.
+///
+/// ```qml
+/// WrapperItem {
+///   margin: 10
+///
+///   @@QtQuick.Text { text: "Hello!" }
+/// }
+/// ```
+///
+/// > [!NOTE] The child item can be specified by writing it inline in the wrapper,
+/// > as in the example above, or by using the @@child property. See
+/// > @@WrapperManager.child for details.
+///
+/// > [!WARNING] You should not set @@Item.x, @@Item.y, @@Item.width,
+/// > @@Item.height or @@Item.anchors on the child item, as they are used
+/// > by WrapperItem to position it. Instead set @@Item.implicitWidth and
+/// > @@Item.implicitHeight.
+///
+/// [QtQuick.Layouts]: https://doc.qt.io/qt-6/qtquicklayouts-index.html
+Item {
+	/// The default for @@topMargin, @@bottomMargin, @@leftMargin and @@rightMargin.
+	/// Defaults to 0.
+	property /*real*/alias margin: manager.margin
+	/// An extra margin applied in addition to @@topMargin, @@bottomMargin,
+	/// @@leftMargin, and @@rightMargin. Defaults to 0.
+	property /*real*/alias extraMargin: manager.extraMargin
+	/// The requested top margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias topMargin: manager.topMargin
+	/// The requested bottom margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias bottomMargin: manager.bottomMargin
+	/// The requested left margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias leftMargin: manager.leftMargin
+	/// The requested right margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias rightMargin: manager.rightMargin
+	/// Determines if child item should be resized larger than its implicit size if
+	/// the parent is resized larger than its implicit size. Defaults to true.
+	property /*bool*/alias resizeChild: manager.resizeChild
+	/// Overrides the implicit width of the wrapper.
+	///
+	/// Defaults to the implicit width of the content item plus its left and right margin,
+	/// and may be reset by assigning `undefined`.
+	property /*real*/alias implicitWidth: manager.implicitWidth
+	/// Overrides the implicit height of the wrapper.
+	///
+	/// Defaults to the implicit width of the content item plus its top and bottom margin,
+	/// and may be reset by assigning `undefined`.
+	property /*real*/alias implicitHeight: manager.implicitHeight
+	/// See @@WrapperManager.child for details.
+	property /*Item*/alias child: manager.child
+
+	MarginWrapperManager { id: manager }
+}
diff --git a/src/widgets/WrapperMouseArea.qml b/src/widgets/WrapperMouseArea.qml
new file mode 100644
index 00000000..67f3a592
--- /dev/null
+++ b/src/widgets/WrapperMouseArea.qml
@@ -0,0 +1,60 @@
+import QtQuick
+
+///! MouseArea wrapper item.
+/// This component is useful for wrapping a single component in
+/// a mouse area. It works the same as @@WrapperItem, but with a @@QtQuick.MouseArea.
+///
+/// > [!NOTE] WrapperMouseArea is a @@MarginWrapperManager based component.
+/// > See its documentation for information on how margins and sizes are calculated.
+///
+/// > [!NOTE] The child item can be specified by writing it inline in the wrapper,
+/// > as in the example above, or by using the @@child property. See
+/// > @@WrapperManager.child for details.
+///
+/// > [!WARNING] You should not set @@Item.x, @@Item.y, @@Item.width,
+/// > @@Item.height or @@Item.anchors on the child item, as they are used
+/// > by WrapperItem to position it. Instead set @@Item.implicitWidth and
+/// > @@Item.implicitHeight.
+///
+/// [QtQuick.Layouts]: https://doc.qt.io/qt-6/qtquicklayouts-index.html
+MouseArea {
+	/// The default for @@topMargin, @@bottomMargin, @@leftMargin and @@rightMargin.
+	/// Defaults to 0.
+	property /*real*/alias margin: manager.margin
+	/// An extra margin applied in addition to @@topMargin, @@bottomMargin,
+	/// @@leftMargin, and @@rightMargin. Defaults to 0.
+	property /*real*/alias extraMargin: manager.extraMargin
+	/// The requested top margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias topMargin: manager.topMargin
+	/// The requested bottom margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias bottomMargin: manager.bottomMargin
+	/// The requested left margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias leftMargin: manager.leftMargin
+	/// The requested right margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias rightMargin: manager.rightMargin
+	/// Determines if child item should be resized larger than its implicit size if
+	/// the parent is resized larger than its implicit size. Defaults to true.
+	property /*bool*/alias resizeChild: manager.resizeChild
+	/// Overrides the implicit width of the wrapper.
+	///
+	/// Defaults to the implicit width of the content item plus its left and right margin,
+	/// and may be reset by assigning `undefined`.
+	property /*real*/alias implicitWidth: manager.implicitWidth
+	/// Overrides the implicit height of the wrapper.
+	///
+	/// Defaults to the implicit width of the content item plus its top and bottom margin,
+	/// and may be reset by assigning `undefined`.
+	property /*real*/alias implicitHeight: manager.implicitHeight
+	/// See @@WrapperManager.child for details.
+	property /*Item*/alias child: manager.child
+
+	MarginWrapperManager { id: manager }
+}
diff --git a/src/widgets/WrapperRectangle.qml b/src/widgets/WrapperRectangle.qml
new file mode 100644
index 00000000..a08a2a05
--- /dev/null
+++ b/src/widgets/WrapperRectangle.qml
@@ -0,0 +1,71 @@
+import QtQuick
+
+///! Rectangle that handles sizes and positioning for a single visual child.
+/// This component is useful for adding a border or background rectangle to
+/// a child item. If you need to clip the child item to the rectangle's
+/// border, see @@ClippingWrapperRectangle.
+///
+/// > [!NOTE] WrapperRectangle is a @@MarginWrapperManager based component.
+/// > See its documentation for information on how margins and sizes are calculated.
+///
+/// > [!WARNING] You should not set @@Item.x, @@Item.y, @@Item.width,
+/// > @@Item.height or @@Item.anchors on the child item, as they are used
+/// > by WrapperItem to position it. Instead set @@Item.implicitWidth and
+/// > @@Item.implicitHeight.
+Rectangle {
+	id: root
+
+	/// If true (default), the rectangle's border width will be added
+	/// to @@extraMargin.
+	property bool contentInsideBorder: true
+	/// The default for @@topMargin, @@bottomMargin, @@leftMargin and @@rightMargin.
+	/// Defaults to 0.
+	property /*real*/alias margin: manager.margin
+	/// An extra margin applied in addition to @@topMargin, @@bottomMargin,
+	/// @@leftMargin, and @@rightMargin.
+	/// If @@contentInsideBorder is true, the rectangle's border width will be added
+	/// to this property. Defaults to 0.
+	property real extraMargin: 0
+	/// The requested top margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias topMargin: manager.topMargin
+	/// The requested bottom margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias bottomMargin: manager.bottomMargin
+	/// The requested left margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias leftMargin: manager.leftMargin
+	/// The requested right margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	property /*real*/alias rightMargin: manager.rightMargin
+	/// Determines if child item should be resized larger than its implicit size if
+	/// the parent is resized larger than its implicit size. Defaults to true.
+	property /*bool*/alias resizeChild: manager.resizeChild
+	/// Overrides the implicit width of the wrapper.
+	///
+	/// Defaults to the implicit width of the content item plus its left and right margin,
+	/// and may be reset by assigning `undefined`.
+	property /*real*/alias implicitWidth: manager.implicitWidth
+	/// Overrides the implicit height of the wrapper.
+	///
+	/// Defaults to the implicit width of the content item plus its top and bottom margin,
+	/// and may be reset by assigning `undefined`.
+	property /*real*/alias implicitHeight: manager.implicitHeight
+	/// See @@WrapperManager.child for details.
+	property alias child: manager.child
+
+	// Reading the border property implicitly sets border width to 1.
+	// Setting it to 0 here means the user will also have to set border.width
+	// even if they just want 1, but it prevents adding unexpected padding
+	// and works around QTBUG-137166 otherwise.
+	border.width: 0
+
+	MarginWrapperManager {
+		id: manager
+		extraMargin: (root.contentInsideBorder ? root.border.width : 0) + root.extraMargin
+	}
+}
diff --git a/src/widgets/cliprect.cpp b/src/widgets/cliprect.cpp
new file mode 100644
index 00000000..a66147ea
--- /dev/null
+++ b/src/widgets/cliprect.cpp
@@ -0,0 +1 @@
+#include "cliprect.hpp" // NOLINT
diff --git a/src/widgets/cliprect.hpp b/src/widgets/cliprect.hpp
new file mode 100644
index 00000000..adc1381a
--- /dev/null
+++ b/src/widgets/cliprect.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <qcolor.h>
+#include <qmetaobject.h>
+#include <qnamespace.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+
+class ClippingRectangleBorder {
+	Q_GADGET;
+	Q_PROPERTY(QColor color MEMBER color);
+	Q_PROPERTY(bool pixelAligned MEMBER pixelAligned);
+	Q_PROPERTY(int width MEMBER width);
+	QML_VALUE_TYPE(clippingRectangleBorder);
+
+public:
+	QColor color = Qt::black;
+	bool pixelAligned = true;
+	int width = 0;
+};
diff --git a/src/widgets/marginwrapper.cpp b/src/widgets/marginwrapper.cpp
new file mode 100644
index 00000000..9960bba9
--- /dev/null
+++ b/src/widgets/marginwrapper.cpp
@@ -0,0 +1,149 @@
+#include "marginwrapper.hpp"
+#include <cmath>
+
+#include <qobject.h>
+#include <qquickitem.h>
+#include <qtmetamacros.h>
+
+#include "wrapper.hpp"
+
+namespace qs::widgets {
+
+MarginWrapperManager::MarginWrapperManager(QObject* parent): WrapperManager(parent) {
+	this->bTopMargin.setBinding([this] {
+		return this->bExtraMargin
+		     + (this->bOverrides.value().testFlag(TopMargin) ? this->bTopMarginOverride : this->bMargin
+		     );
+	});
+
+	this->bBottomMargin.setBinding([this] {
+		return this->bExtraMargin
+		     + (this->bOverrides.value().testFlag(BottomMargin) ? this->bBottomMarginOverride
+		                                                        : this->bMargin);
+	});
+
+	this->bLeftMargin.setBinding([this] {
+		return this->bExtraMargin
+		     + (this->bOverrides.value().testFlag(LeftMargin) ? this->bLeftMarginOverride
+		                                                      : this->bMargin);
+	});
+
+	this->bRightMargin.setBinding([this] {
+		return this->bExtraMargin
+		     + (this->bOverrides.value().testFlag(RightMargin) ? this->bRightMarginOverride
+		                                                       : this->bMargin);
+	});
+
+	this->bChildX.setBinding([this] {
+		if (this->bResizeChild) return this->bLeftMargin.value();
+
+		auto total = this->bLeftMargin + this->bRightMargin;
+		auto mul = total == 0 ? 0.5 : this->bLeftMargin / total;
+		auto margin = this->bWrapperWidth - this->bChildImplicitWidth;
+		return std::round(margin * mul);
+	});
+
+	this->bChildY.setBinding([this] {
+		if (this->bResizeChild) return this->bTopMargin.value();
+
+		auto total = this->bTopMargin + this->bBottomMargin;
+		auto mul = total == 0 ? 0.5 : this->bTopMargin / total;
+		auto margin = this->bWrapperHeight - this->bChildImplicitHeight;
+		return std::round(margin * mul);
+	});
+
+	this->bChildWidth.setBinding([this] {
+		if (this->bResizeChild) {
+			return this->bWrapperWidth - (this->bLeftMargin + this->bRightMargin);
+		} else {
+			return this->bChildImplicitWidth.value();
+		}
+	});
+
+	this->bChildHeight.setBinding([this] {
+		if (this->bResizeChild) {
+			return this->bWrapperHeight - (this->bTopMargin + this->bBottomMargin);
+		} else {
+			return this->bChildImplicitHeight.value();
+		}
+	});
+
+	this->bWrapperImplicitWidth.setBinding([this] {
+		if (this->bOverrides.value().testFlag(ImplicitWidth)) {
+			return this->bImplicitWidthOverride.value();
+		} else {
+			return this->bChildImplicitWidth.value() + this->bLeftMargin + this->bRightMargin;
+		}
+	});
+
+	this->bWrapperImplicitHeight.setBinding([this] {
+		if (this->bOverrides.value().testFlag(ImplicitHeight)) {
+			return this->bImplicitHeightOverride.value();
+		} else {
+			return this->bChildImplicitHeight.value() + this->bTopMargin + this->bBottomMargin;
+		}
+	});
+}
+
+void MarginWrapperManager::componentComplete() {
+	this->WrapperManager::componentComplete();
+
+	if (this->mWrapper) {
+		this->bWrapperWidth.setBinding([this] { return this->mWrapper->bindableWidth().value(); });
+		this->bWrapperHeight.setBinding([this] { return this->mWrapper->bindableHeight().value(); });
+		this->setWrapperImplicitWidth();
+		this->setWrapperImplicitHeight();
+	}
+}
+
+void MarginWrapperManager::disconnectChild() {
+	this->mChild->bindableX().setValue(0);
+	this->mChild->bindableY().setValue(0);
+	this->mChild->bindableWidth().setValue(0);
+	this->mChild->bindableHeight().setValue(0);
+}
+
+void MarginWrapperManager::connectChild() {
+	// QObject::disconnect in MarginWrapper handles disconnecting old item
+	this->mChild->bindableX().setBinding([this] { return this->bChildX.value(); });
+	this->mChild->bindableY().setBinding([this] { return this->bChildY.value(); });
+	this->mChild->bindableWidth().setBinding([this] { return this->bChildWidth.value(); });
+	this->mChild->bindableHeight().setBinding([this] { return this->bChildHeight.value(); });
+
+	QObject::connect(
+	    this->mChild,
+	    &QQuickItem::implicitWidthChanged,
+	    this,
+	    &MarginWrapperManager::onChildImplicitWidthChanged
+	);
+
+	QObject::connect(
+	    this->mChild,
+	    &QQuickItem::implicitHeightChanged,
+	    this,
+	    &MarginWrapperManager::onChildImplicitHeightChanged
+	);
+
+	this->onChildImplicitWidthChanged();
+	this->onChildImplicitHeightChanged();
+}
+
+void MarginWrapperManager::onChildImplicitWidthChanged() {
+	this->bChildImplicitWidth = this->mChild->implicitWidth();
+}
+
+void MarginWrapperManager::onChildImplicitHeightChanged() {
+	this->bChildImplicitHeight = this->mChild->implicitHeight();
+}
+
+void MarginWrapperManager::setWrapperImplicitWidth() {
+	if (this->mWrapper) this->mWrapper->setImplicitWidth(this->bWrapperImplicitWidth);
+	emit this->implicitWidthChanged();
+}
+
+void MarginWrapperManager::setWrapperImplicitHeight() {
+	if (this->mWrapper) this->mWrapper->setImplicitHeight(this->bWrapperImplicitHeight);
+	emit this->implicitHeightChanged();
+}
+
+} // namespace qs::widgets
diff --git a/src/widgets/marginwrapper.hpp b/src/widgets/marginwrapper.hpp
new file mode 100644
index 00000000..ac925b92
--- /dev/null
+++ b/src/widgets/marginwrapper.hpp
@@ -0,0 +1,210 @@
+#pragma once
+
+#include <qflags.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "wrapper.hpp"
+
+namespace qs::widgets {
+
+///! Helper object for applying sizes and margins to a single child item.
+/// > [!NOTE] MarginWrapperManager is an extension of @@WrapperManager.
+/// > You should read its documentation to understand wrapper types.
+///
+/// MarginWrapperManager can be used to apply margins to a child item,
+/// in addition to handling the size / implicit size relationship
+/// between the parent and the child. @@WrapperItem and @@WrapperRectangle
+/// exist for Item and Rectangle implementations respectively.
+///
+/// > [!WARNING] MarginWrapperManager based types set the child item's
+/// > @@QtQuick.Item.x, @@QtQuick.Item.y, @@QtQuick.Item.width, @@QtQuick.Item.height
+/// > or @@QtQuick.Item.anchors properties. Do not set them yourself,
+/// > instead set @@Item.implicitWidth and @@Item.implicitHeight.
+///
+/// ### Implementing a margin wrapper type
+/// Follow the directions in @@WrapperManager$'s documentation, and or
+/// alias the @@margin property if you wish to expose it.
+///
+/// ## Margin calculation
+/// The margin of the content item is calculated based on @@topMargin, @@bottomMargin,
+/// @@leftMargin, @@rightMargin, @@extraMargin and @@resizeChild.
+///
+/// If @@resizeChild is `true`, each side's margin will be the value of `<side>Margin`
+/// plus @@extraMargin, and the content item will be stretched to match the given margin
+/// if the wrapper is not at its implicit size.
+///
+/// If @@resizeChild is `false`, the `<side>Margin` properties will be interpreted as a
+/// ratio and the content item will not be stretched if the wrapper is not at its implicit side.
+///
+/// The implicit size of the wrapper is the implicit size of the content item
+/// plus all margins.
+class MarginWrapperManager: public WrapperManager {
+	Q_OBJECT;
+	// clang-format off
+	/// The default for @@topMargin, @@bottomMargin, @@leftMargin and @@rightMargin.
+	/// Defaults to 0.
+	Q_PROPERTY(qreal margin READ default WRITE default BINDABLE bindableMargin NOTIFY marginChanged FINAL);
+	/// An extra margin applied in addition to @@topMargin, @@bottomMargin,
+  /// @@leftMargin, and @@rightMargin. Defaults to 0.
+	Q_PROPERTY(qreal extraMargin READ default WRITE default BINDABLE bindableExtraMargin NOTIFY baseMarginChanged FINAL);
+	/// The requested top margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	Q_PROPERTY(qreal topMargin READ topMargin WRITE setTopMargin RESET resetTopMargin NOTIFY topMarginChanged FINAL);
+	/// The requested bottom margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	Q_PROPERTY(qreal bottomMargin READ bottomMargin WRITE setBottomMargin RESET resetBottomMargin NOTIFY bottomMarginChanged FINAL);
+	/// The requested left margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	Q_PROPERTY(qreal leftMargin READ leftMargin WRITE setLeftMargin RESET resetLeftMargin NOTIFY leftMarginChanged FINAL);
+	/// The requested right margin of the content item, not counting @@extraMargin.
+	///
+	/// Defaults to @@margin, and may be reset by assigning `undefined`.
+	Q_PROPERTY(qreal rightMargin READ rightMargin WRITE setRightMargin RESET resetRightMargin NOTIFY rightMarginChanged FINAL);
+	/// Determines if child item should be resized larger than its implicit size if
+	/// the parent is resized larger than its implicit size. Defaults to true.
+	Q_PROPERTY(bool resizeChild READ default WRITE default BINDABLE bindableResizeChild NOTIFY resizeChildChanged FINAL);
+	/// Overrides the implicit width of the wrapper.
+	///
+	/// Defaults to the implicit width of the content item plus its left and right margin,
+	/// and may be reset by assigning `undefined`.
+	Q_PROPERTY(qreal implicitWidth READ implicitWidth WRITE setImplicitWidth RESET resetImplicitWidth NOTIFY implicitWidthChanged FINAL);
+	/// Overrides the implicit height of the wrapper.
+	///
+	/// Defaults to the implicit width of the content item plus its top and bottom margin,
+	/// and may be reset by assigning `undefined`.
+	Q_PROPERTY(qreal implicitHeight READ implicitHeight WRITE setImplicitHeight RESET resetImplicitHeight NOTIFY implicitHeightChanged FINAL);
+	// clang-format on
+	QML_ELEMENT;
+
+public:
+	explicit MarginWrapperManager(QObject* parent = nullptr);
+
+	void componentComplete() override;
+
+	[[nodiscard]] QBindable<qreal> bindableMargin() { return &this->bMargin; }
+	[[nodiscard]] QBindable<qreal> bindableExtraMargin() { return &this->bExtraMargin; }
+
+	[[nodiscard]] qreal topMargin() const { return this->bTopMargin.value(); }
+	void resetTopMargin() { this->bOverrides = this->bOverrides.value() & ~TopMargin; }
+	void setTopMargin(qreal topMargin) {
+		this->bTopMarginOverride = topMargin;
+		this->bOverrides = this->bOverrides.value() | TopMargin;
+	}
+
+	[[nodiscard]] qreal bottomMargin() const { return this->bBottomMargin.value(); }
+	void resetBottomMargin() { this->bOverrides = this->bOverrides.value() & ~BottomMargin; }
+	void setBottomMargin(qreal bottomMargin) {
+		this->bBottomMarginOverride = bottomMargin;
+		this->bOverrides = this->bOverrides.value() | BottomMargin;
+	}
+
+	[[nodiscard]] qreal leftMargin() const { return this->bLeftMargin.value(); }
+	void resetLeftMargin() { this->bOverrides = this->bOverrides.value() & ~LeftMargin; }
+	void setLeftMargin(qreal leftMargin) {
+		this->bLeftMarginOverride = leftMargin;
+		this->bOverrides = this->bOverrides.value() | LeftMargin;
+	}
+
+	[[nodiscard]] qreal rightMargin() const { return this->bRightMargin.value(); }
+	void resetRightMargin() { this->bOverrides = this->bOverrides.value() & ~RightMargin; }
+	void setRightMargin(qreal rightMargin) {
+		this->bRightMarginOverride = rightMargin;
+		this->bOverrides = this->bOverrides.value() | RightMargin;
+	}
+
+	[[nodiscard]] QBindable<bool> bindableResizeChild() { return &this->bResizeChild; }
+
+	[[nodiscard]] qreal implicitWidth() const { return this->bWrapperImplicitWidth.value(); }
+	void resetImplicitWidth() { this->bOverrides = this->bOverrides.value() & ~ImplicitWidth; }
+	void setImplicitWidth(qreal implicitWidth) {
+		this->bImplicitWidthOverride = implicitWidth;
+		this->bOverrides = this->bOverrides.value() | ImplicitWidth;
+	}
+
+	[[nodiscard]] qreal implicitHeight() const { return this->bWrapperImplicitHeight.value(); }
+	void resetImplicitHeight() { this->bOverrides = this->bOverrides.value() & ~ImplicitHeight; }
+	void setImplicitHeight(qreal implicitHeight) {
+		this->bImplicitHeightOverride = implicitHeight;
+		this->bOverrides = this->bOverrides.value() | ImplicitHeight;
+	}
+
+	// has to be public for flag operator definitions
+	enum OverrideFlag : quint8 {
+		ImplicitWidth = 0b1,
+		ImplicitHeight = 0b10,
+		TopMargin = 0b100,
+		BottomMargin = 0b1000,
+		LeftMargin = 0b10000,
+		RightMargin = 0b100000,
+	};
+
+	Q_DECLARE_FLAGS(OverrideFlags, OverrideFlag);
+
+signals:
+	void marginChanged();
+	void baseMarginChanged();
+	void topMarginChanged();
+	void bottomMarginChanged();
+	void leftMarginChanged();
+	void rightMarginChanged();
+	void resizeChildChanged();
+	void implicitWidthChanged();
+	void implicitHeightChanged();
+
+private slots:
+	void onChildImplicitWidthChanged();
+	void onChildImplicitHeightChanged();
+	void setWrapperImplicitWidth();
+	void setWrapperImplicitHeight();
+
+protected:
+	void disconnectChild() override;
+	void connectChild() override;
+
+private:
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(MarginWrapperManager, bool, bResizeChild, true);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bMargin, &MarginWrapperManager::marginChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bExtraMargin, &MarginWrapperManager::baseMarginChanged);
+
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, OverrideFlags, bOverrides);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bImplicitWidthOverride);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bImplicitHeightOverride);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bTopMarginOverride);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bBottomMarginOverride);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bLeftMarginOverride);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bRightMarginOverride);
+
+	// computed
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bTopMargin, &MarginWrapperManager::topMarginChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bBottomMargin, &MarginWrapperManager::bottomMarginChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bLeftMargin, &MarginWrapperManager::leftMarginChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bRightMargin, &MarginWrapperManager::rightMarginChanged);
+
+	// bound
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bWrapperWidth);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bWrapperHeight);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bChildImplicitWidth);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bChildImplicitHeight);
+
+	// computed
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bChildX);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bChildY);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bChildWidth);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bChildHeight);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bWrapperImplicitWidth, &MarginWrapperManager::setWrapperImplicitWidth);
+	Q_OBJECT_BINDABLE_PROPERTY(MarginWrapperManager, qreal, bWrapperImplicitHeight, &MarginWrapperManager::setWrapperImplicitHeight);
+
+	// clang-format on
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(MarginWrapperManager::OverrideFlags);
+
+} // namespace qs::widgets
diff --git a/src/widgets/module.md b/src/widgets/module.md
new file mode 100644
index 00000000..923dc536
--- /dev/null
+++ b/src/widgets/module.md
@@ -0,0 +1,17 @@
+name = "Quickshell.Widgets"
+description = "Bundled widgets"
+
+headers = [
+	"wrapper.hpp",
+	"marginwrapper.hpp",
+]
+
+qml_files = [
+	"IconImage.qml",
+	"ClippingRectangle.qml",
+	"WrapperItem.qml",
+	"WrapperMouseArea.qml",
+	"WrapperRectangle.qml",
+	"ClippingWrapperRectangle.qml",
+]
+-----
diff --git a/src/widgets/shaders/cliprect.frag b/src/widgets/shaders/cliprect.frag
new file mode 100644
index 00000000..2b8db2a8
--- /dev/null
+++ b/src/widgets/shaders/cliprect.frag
@@ -0,0 +1,41 @@
+#version 440
+layout(location = 0) in vec2 qt_TexCoord0;
+layout(location = 0) out vec4 fragColor;
+
+layout(std140, binding = 0) uniform buf {
+	mat4 qt_Matrix;
+	float qt_Opacity;
+	vec4 backgroundColor;
+	vec4 borderColor;
+};
+
+layout(binding = 1) uniform sampler2D rect;
+layout(binding = 2) uniform sampler2D content;
+
+vec4 overlay(vec4 base, vec4 overlay) {
+	if (overlay.a == 0.0) return base;
+	if (base.a == 0.0) return overlay;
+
+	vec3 rgb = overlay.rgb + base.rgb * (1.0 - overlay.a);
+	float a = overlay.a + base.a * (1.0 - overlay.a);
+
+	return vec4(rgb, a);
+}
+
+void main() {
+	vec4 contentColor = texture(content, qt_TexCoord0.xy);
+	vec4 rectColor = texture(rect, qt_TexCoord0.xy);
+
+#ifdef CONTENT_UNDER_BORDER
+	float contentAlpha = rectColor.a;
+#else
+	float contentAlpha = rectColor.r;
+#endif
+
+	float borderAlpha = rectColor.g;
+
+	vec4 innerColor = overlay(backgroundColor, contentColor) * contentAlpha;
+	vec4 borderColor = borderColor * borderAlpha;
+
+	fragColor = (innerColor * (1.0 - borderColor.a) + borderColor) * qt_Opacity;
+}
diff --git a/src/widgets/test/manual/marginwrapper.qml b/src/widgets/test/manual/marginwrapper.qml
new file mode 100644
index 00000000..d70ca97f
--- /dev/null
+++ b/src/widgets/test/manual/marginwrapper.qml
@@ -0,0 +1,175 @@
+import QtQuick
+import QtQuick.Layouts
+import QtQuick.Controls
+import Quickshell
+import Quickshell.Widgets
+
+FloatingWindow {
+	color: contentItem.palette.window
+
+	ColumnLayout {
+		anchors.fill: parent
+
+		Item {
+			Layout.fillWidth: true
+			Layout.fillHeight: true
+
+			Rectangle {
+				anchors.centerIn: parent
+				width: stretchCb.checked ? wrapperWidthSlider.value : implicitWidth
+				height: stretchCb.checked ? wrapperHeightSlider.value : implicitHeight
+				border.color: "black"
+
+				MarginWrapperManager {
+					margin: marginSlider.value
+					extraMargin: extraMarginSlider.value
+					resizeChild: resizeCb.checked
+					topMargin: separateMarginsCb.checked ? topMarginSlider.value : undefined
+					bottomMargin: separateMarginsCb.checked ? bottomMarginSlider.value : undefined
+					leftMargin: separateMarginsCb.checked ? leftMarginSlider.value : undefined
+					rightMargin: separateMarginsCb.checked ? rightMarginSlider.value : undefined
+					implicitWidth: parentImplicitSizeCb.checked ? parentImplicitWidthSlider.value : undefined
+					implicitHeight: parentImplicitSizeCb.checked ? parentImplicitHeightSlider.value : undefined
+				}
+
+				Rectangle {
+					color: "green"
+					implicitWidth: implicitWidthSlider.value
+					implicitHeight: implicitHeightSlider.value
+				}
+			}
+		}
+
+		RowLayout {
+			Layout.fillWidth: true
+
+			CheckBox {
+				id: stretchCb
+				text: "Stretch"
+			}
+
+			CheckBox {
+				id: resizeCb
+				text: "Resize Child"
+			}
+
+			CheckBox {
+				id: separateMarginsCb
+				text: "Individual Margins"
+			}
+
+			CheckBox {
+				id: parentImplicitSizeCb
+				text: "Parent Implicit Size"
+			}
+		}
+
+		RowLayout {
+			Layout.fillWidth: true
+
+			Label { text: "Stretch Width" }
+			Slider {
+				id: wrapperWidthSlider
+				Layout.fillWidth: true
+				from: 0; to: 300; value: 200
+			}
+
+			Label { text: "Stretch Height" }
+			Slider {
+				id: wrapperHeightSlider
+				Layout.fillWidth: true
+				from: 0; to: 300; value: 200
+			}
+		}
+
+		RowLayout {
+			Layout.fillWidth: true
+
+			Label { text: "Implicit Width" }
+			Slider {
+				id: implicitWidthSlider
+				Layout.fillWidth: true
+				from: 0; to: 200; value: 100
+			}
+
+			Label { text: "Implicit Height" }
+			Slider {
+				id: implicitHeightSlider
+				Layout.fillWidth: true
+				from: 0; to: 200; value: 100
+			}
+		}
+
+		RowLayout {
+			Layout.fillWidth: true
+
+			Label { text: "Parent Implicit Width" }
+			Slider {
+				id: parentImplicitWidthSlider
+				Layout.fillWidth: true
+				from: 0; to: 300; value: 200
+			}
+
+			Label { text: "Parent Implicit Height" }
+			Slider {
+				id: parentImplicitHeightSlider
+				Layout.fillWidth: true
+				from: 0; to: 300; value: 200
+			}
+		}
+
+		RowLayout {
+			Layout.fillWidth: true
+
+			Label { text: "Margin" }
+			Slider {
+				id: marginSlider
+				Layout.fillWidth: true
+				from: -100; to: 200; value: 50
+			}
+
+			Label { text: "Extra" }
+			Slider {
+				id: extraMarginSlider
+				Layout.fillWidth: true
+				from: -100; to: 200; value: 0
+			}
+		}
+
+		RowLayout {
+			Layout.fillWidth: true
+
+			Label { text: "Top Margin" }
+			Slider {
+				id: topMarginSlider
+				Layout.fillWidth: true
+				from: -100; to: 200; value: 50
+			}
+
+			Label { text: "Bottom Margin" }
+			Slider {
+				id: bottomMarginSlider
+				Layout.fillWidth: true
+				from: -100; to: 200; value: 50
+			}
+		}
+
+		RowLayout {
+			Layout.fillWidth: true
+
+			Label { text: "Left Margin" }
+			Slider {
+				id: leftMarginSlider
+				Layout.fillWidth: true
+				from: -100; to: 200; value: 50
+			}
+
+			Label { text: "Right Margin" }
+			Slider {
+				id: rightMarginSlider
+				Layout.fillWidth: true
+				from: -100; to: 200; value: 50
+			}
+		}
+	}
+}
diff --git a/src/widgets/wrapper.cpp b/src/widgets/wrapper.cpp
new file mode 100644
index 00000000..ee18da4e
--- /dev/null
+++ b/src/widgets/wrapper.cpp
@@ -0,0 +1,146 @@
+#include "wrapper.hpp"
+
+#include <QtQml/qqmlinfo.h>
+#include <QtQml/qqmllist.h>
+#include <qlogging.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qquickitem.h>
+#include <qtmetamacros.h>
+
+namespace qs::widgets {
+
+void WrapperManager::componentComplete() {
+	if (this->mAssignedWrapper) {
+		this->mWrapper = this->mAssignedWrapper;
+	} else {
+		this->mWrapper = qobject_cast<QQuickItem*>(this->parent());
+	}
+
+	if (!this->mWrapper) {
+		QString pstr;
+		QDebug(&pstr) << this->parent();
+
+		qmlWarning(this) << "Parent of WrapperManager is not a QQuickItem. Parent: " << pstr;
+		return;
+	}
+
+	QQuickItem* child = this->mChild;
+	this->mChild = nullptr; // avoids checks for the old item in setChild.
+
+	const auto& childItems = this->mWrapper->childItems();
+
+	if (childItems.length() == 1) {
+		this->mDefaultChild = childItems.first();
+		if (!child) child = this->mDefaultChild;
+	} else if (!childItems.empty()) {
+		this->flags.setFlag(WrapperManager::HasMultipleChildren);
+
+		if (!child && !this->flags.testFlags(WrapperManager::NullChild)) {
+			this->printChildCountWarning();
+		}
+	}
+
+	for (auto* item: childItems) {
+		if (item != child) item->setParentItem(nullptr);
+	}
+
+	if (child && !this->flags.testFlag(WrapperManager::NullChild)) {
+		this->setChild(child);
+	}
+}
+
+QQuickItem* WrapperManager::child() const { return this->mChild; }
+
+void WrapperManager::setChild(QQuickItem* child) {
+	if (child && child == this->mChild) return;
+
+	if (this->mChild != nullptr) {
+		QObject::disconnect(this->mChild, nullptr, this, nullptr);
+
+		if (this->mChild->parentItem() == this->mWrapper) {
+			this->mChild->setParentItem(nullptr);
+		}
+		this->disconnectChild();
+	}
+
+	this->mChild = child;
+	this->flags.setFlag(WrapperManager::NullChild, child == nullptr);
+
+	if (child) {
+		QObject::connect(
+		    child,
+		    &QObject::destroyed,
+		    this,
+		    &WrapperManager::onChildDestroyed,
+		    Qt::UniqueConnection
+		);
+
+		if (auto* wrapper = this->mWrapper) {
+			child->setParentItem(wrapper);
+		}
+
+		this->connectChild();
+	}
+
+	emit this->initializedChildChanged();
+	emit this->childChanged();
+}
+
+void WrapperManager::setProspectiveChild(QQuickItem* child) {
+	if (child && child == this->mChild) return;
+
+	if (!this->mWrapper) {
+		if (this->mChild) {
+			QObject::disconnect(this->mChild, nullptr, this, nullptr);
+		}
+
+		this->mChild = child;
+		this->flags.setFlag(WrapperManager::NullChild, child == nullptr);
+
+		if (child) {
+			QObject::connect(child, &QObject::destroyed, this, &WrapperManager::onChildDestroyed);
+		}
+	} else {
+		this->setChild(child);
+	}
+}
+
+void WrapperManager::unsetChild() {
+	if (!this->mWrapper) {
+		this->setProspectiveChild(nullptr);
+	} else {
+		this->setChild(this->mDefaultChild);
+
+		if (!this->mDefaultChild && this->flags.testFlag(WrapperManager::HasMultipleChildren)) {
+			this->printChildCountWarning();
+		}
+	}
+
+	this->flags.setFlag(WrapperManager::NullChild, false);
+}
+
+void WrapperManager::onChildDestroyed() {
+	this->mChild = nullptr;
+	this->unsetChild();
+	emit this->childChanged();
+}
+
+QQuickItem* WrapperManager::wrapper() const { return this->mWrapper; }
+
+void WrapperManager::setWrapper(QQuickItem* wrapper) {
+	if (this->mWrapper) {
+		qmlWarning(this) << "Cannot set wrapper after WrapperManager initialization.";
+		return;
+	}
+
+	this->mAssignedWrapper = wrapper;
+}
+
+void WrapperManager::printChildCountWarning() const {
+	qmlWarning(this->mWrapper) << "Wrapper component cannot have more than one visual child.";
+	qmlWarning(this->mWrapper) << "Remove all additional children, or pick a specific component "
+	                              "to wrap using the child property.";
+}
+
+} // namespace qs::widgets
diff --git a/src/widgets/wrapper.hpp b/src/widgets/wrapper.hpp
new file mode 100644
index 00000000..aca41727
--- /dev/null
+++ b/src/widgets/wrapper.hpp
@@ -0,0 +1,152 @@
+#pragma once
+
+#include <qflags.h>
+#include <qobject.h>
+#include <qpointer.h>
+#include <qqmlintegration.h>
+#include <qqmllist.h>
+#include <qqmlparserstatus.h>
+#include <qquickitem.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../core/doc.hpp"
+
+namespace qs::widgets {
+
+///! Helper object for creating components with a single visual child.
+/// WrapperManager determines which child of an Item should be its visual
+/// child, and exposes it for further operations. See @@MarginWrapperManager
+/// for a subclass that implements automatic sizing and margins.
+///
+/// ### Using wrapper types
+/// WrapperManager based types have a single visual child item.
+/// You can specify the child item using the default property, or by
+/// setting the @@child property. You must use the @@child property if
+/// the widget has more than one @@QtQuick.Item based child.
+///
+/// #### Example using the default property
+/// ```qml
+/// WrapperWidget { // a widget that uses WrapperManager
+///   // Putting the item inline uses the default property of WrapperWidget.
+///   @@QtQuick.Text { text: "Hello" }
+///
+///   // Scope does not extend Item, so it can be placed in the
+///   // default property without issue.
+///   @@Quickshell.Scope {}
+/// }
+/// ```
+///
+/// #### Example using the child property
+/// ```qml
+/// WrapperWidget {
+///   @@QtQuick.Text {
+///     id: text
+///     text: "Hello"
+///   }
+///
+///   @@QtQuick.Text {
+///     id: otherText
+///     text: "Other Text"
+///   }
+///
+///   // Both text and otherText extend Item, so one must be specified.
+///   child: text
+/// }
+/// ```
+///
+/// See @@child for more details on how the child property can be used.
+///
+/// ### Implementing wrapper types
+/// In addition to the bundled wrapper types, you can make your own using
+/// WrapperManager. To implement a wrapper, create a WrapperManager inside
+/// your wrapper component 's default property, then alias a new property
+/// to the WrapperManager's @@child property.
+///
+/// #### Example
+/// ```qml
+/// Item { // your wrapper component
+///   WrapperManager { id: wrapperManager }
+///
+///   // Allows consumers of your wrapper component to use the child property.
+///   property alias child: wrapperManager.child
+///
+///   // The rest of your component logic. You can use
+///   // `wrapperManager.child` or `this.child` to refer to the selected child.
+/// }
+/// ```
+///
+/// ### See also
+/// - @@WrapperItem - A @@MarginWrapperManager based component that sizes itself
+///   to its child.
+/// - @@WrapperRectangle - A @@MarginWrapperManager based component that sizes
+///   itself to its child, and provides an option to use its border as an inset.
+class WrapperManager
+    : public QObject
+    , public QQmlParserStatus {
+	Q_OBJECT;
+	QML_ELEMENT;
+	Q_INTERFACES(QQmlParserStatus);
+
+	// clang-format off
+	/// The wrapper component's selected child.
+	///
+	/// Setting this property override's WrapperManager's default selection,
+	/// and resolve ambiguity when more than one visual child is present.
+	/// The property can additionally be defined inline or reference a component
+	/// that is not already a child of the wrapper, in which case it will be
+	/// reparented to the wrapper. Setting child to `null` will select no child,
+	/// and `undefined` will restore the default child.
+	///
+	/// When read, `child` will always return the (potentially null) selected child,
+	/// and not `undefined`.
+	Q_PROPERTY(QQuickItem* child READ child WRITE setProspectiveChild RESET unsetChild NOTIFY childChanged FINAL);
+	/// The wrapper managed by this manager. Defaults to the manager's parent.
+	/// This property may not be changed after Component.onCompleted.
+	Q_PROPERTY(QQuickItem* wrapper READ wrapper WRITE setWrapper NOTIFY wrapperChanged FINAL);
+	// clang-format on
+
+public:
+	explicit WrapperManager(QObject* parent = nullptr): QObject(parent) {}
+
+	void classBegin() override {}
+	void componentComplete() override;
+
+	[[nodiscard]] QQuickItem* child() const;
+	void setChild(QQuickItem* child);
+	void setProspectiveChild(QQuickItem* child);
+	void unsetChild();
+
+	[[nodiscard]] QQuickItem* wrapper() const;
+	void setWrapper(QQuickItem* wrapper);
+
+signals:
+	void childChanged();
+	void wrapperChanged();
+	QSDOC_HIDE void initializedChildChanged();
+
+private slots:
+	void onChildDestroyed();
+
+protected:
+	enum Flag : quint8 {
+		NoFlags = 0x0,
+		NullChild = 0x1,
+		HasMultipleChildren = 0x2,
+	};
+	Q_DECLARE_FLAGS(Flags, Flag);
+
+	void printChildCountWarning() const;
+	void updateGeometry();
+
+	virtual void disconnectChild() {}
+	virtual void connectChild() {}
+
+	QQuickItem* mWrapper = nullptr;
+	QQuickItem* mAssignedWrapper = nullptr;
+	QPointer<QQuickItem> mDefaultChild;
+	QQuickItem* mChild = nullptr;
+	Flags flags;
+};
+
+} // namespace qs::widgets
diff --git a/src/window/CMakeLists.txt b/src/window/CMakeLists.txt
new file mode 100644
index 00000000..47b546d4
--- /dev/null
+++ b/src/window/CMakeLists.txt
@@ -0,0 +1,35 @@
+qt_add_library(quickshell-window STATIC
+	proxywindow.cpp
+	windowinterface.cpp
+	panelinterface.cpp
+	floatingwindow.cpp
+	popupwindow.cpp
+)
+
+qt_add_qml_module(quickshell-window
+	URI Quickshell._Window
+	VERSION 0.1
+	DEPENDENCIES QtQuick
+)
+
+qs_add_module_deps_light(quickshell-window Quickshell)
+
+install_qml_module(quickshell-window)
+
+add_library(quickshell-window-init OBJECT init.cpp)
+
+target_link_libraries(quickshell-window PRIVATE
+	Qt::Core Qt::Gui Qt::Quick Qt6::QuickPrivate
+)
+
+qs_add_link_dependencies(quickshell-window quickshell-debug)
+
+target_link_libraries(quickshell-window-init PRIVATE Qt::Qml)
+
+qs_module_pch(quickshell-window SET large)
+
+target_link_libraries(quickshell PRIVATE quickshell-windowplugin quickshell-window-init)
+
+if (BUILD_TESTING)
+	add_subdirectory(test)
+endif()
diff --git a/src/window/floatingwindow.cpp b/src/window/floatingwindow.cpp
new file mode 100644
index 00000000..0b9e9b1c
--- /dev/null
+++ b/src/window/floatingwindow.cpp
@@ -0,0 +1,68 @@
+#include "floatingwindow.hpp"
+
+#include <qobject.h>
+#include <qqmlengine.h>
+#include <qqmllist.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "proxywindow.hpp"
+#include "windowinterface.hpp"
+
+void ProxyFloatingWindow::connectWindow() {
+	this->ProxyWindowBase::connectWindow();
+
+	this->window->setTitle(this->bTitle);
+	this->window->setMinimumSize(this->bMinimumSize);
+	this->window->setMaximumSize(this->bMaximumSize);
+}
+
+void ProxyFloatingWindow::trySetWidth(qint32 implicitWidth) {
+	if (!this->window->isVisible()) {
+		this->ProxyWindowBase::trySetWidth(implicitWidth);
+	}
+}
+
+void ProxyFloatingWindow::trySetHeight(qint32 implicitHeight) {
+	if (!this->window->isVisible()) {
+		this->ProxyWindowBase::trySetHeight(implicitHeight);
+	}
+}
+
+void ProxyFloatingWindow::onTitleChanged() {
+	if (this->window) this->window->setTitle(this->bTitle);
+	emit this->titleChanged();
+}
+
+void ProxyFloatingWindow::onMinimumSizeChanged() {
+	if (this->window) this->window->setMinimumSize(this->bMinimumSize);
+	emit this->minimumSizeChanged();
+}
+
+void ProxyFloatingWindow::onMaximumSizeChanged() {
+	if (this->window) this->window->setMaximumSize(this->bMaximumSize);
+	emit this->maximumSizeChanged();
+}
+
+// FloatingWindowInterface
+
+FloatingWindowInterface::FloatingWindowInterface(QObject* parent)
+    : WindowInterface(parent)
+    , window(new ProxyFloatingWindow(this)) {
+	this->connectSignals();
+
+	// clang-format off
+	QObject::connect(this->window, &ProxyFloatingWindow::titleChanged, this, &FloatingWindowInterface::titleChanged);
+	QObject::connect(this->window, &ProxyFloatingWindow::minimumSizeChanged, this, &FloatingWindowInterface::minimumSizeChanged);
+	QObject::connect(this->window, &ProxyFloatingWindow::maximumSizeChanged, this, &FloatingWindowInterface::maximumSizeChanged);
+	// clang-format on
+}
+
+void FloatingWindowInterface::onReload(QObject* oldInstance) {
+	QQmlEngine::setContextForObject(this->window, QQmlEngine::contextForObject(this));
+
+	auto* old = qobject_cast<FloatingWindowInterface*>(oldInstance);
+	this->window->reload(old != nullptr ? old->window : nullptr);
+}
+
+ProxyWindowBase* FloatingWindowInterface::proxyWindow() const { return this->window; }
diff --git a/src/window/floatingwindow.hpp b/src/window/floatingwindow.hpp
new file mode 100644
index 00000000..f9cd5ced
--- /dev/null
+++ b/src/window/floatingwindow.hpp
@@ -0,0 +1,92 @@
+#pragma once
+
+#include <qobject.h>
+#include <qproperty.h>
+#include <qsize.h>
+#include <qtmetamacros.h>
+
+#include "proxywindow.hpp"
+#include "windowinterface.hpp"
+
+// see #include <qpa/qplatformwindow.h>
+static const int QWINDOWSIZE_MAX = ((1 << 24) - 1);
+
+class ProxyFloatingWindow: public ProxyWindowBase {
+	Q_OBJECT;
+
+public:
+	explicit ProxyFloatingWindow(QObject* parent = nullptr): ProxyWindowBase(parent) {}
+
+	void connectWindow() override;
+
+	// Setting geometry while the window is visible makes the content item shrink but not the window
+	// which is awful so we disable it for floating windows.
+	void trySetWidth(qint32 implicitWidth) override;
+	void trySetHeight(qint32 implicitHeight) override;
+
+signals:
+	void minimumSizeChanged();
+	void maximumSizeChanged();
+	void titleChanged();
+
+private:
+	void onMinimumSizeChanged();
+	void onMaximumSizeChanged();
+	void onTitleChanged();
+
+public:
+	Q_OBJECT_BINDABLE_PROPERTY(
+	    ProxyFloatingWindow,
+	    QString,
+	    bTitle,
+	    &ProxyFloatingWindow::onTitleChanged
+	);
+
+	Q_OBJECT_BINDABLE_PROPERTY(
+	    ProxyFloatingWindow,
+	    QSize,
+	    bMinimumSize,
+	    &ProxyFloatingWindow::onMinimumSizeChanged
+	);
+
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(
+	    ProxyFloatingWindow,
+	    QSize,
+	    bMaximumSize,
+	    QSize(QWINDOWSIZE_MAX, QWINDOWSIZE_MAX),
+	    &ProxyFloatingWindow::onMaximumSizeChanged
+	);
+};
+
+///! Standard toplevel operating system window that looks like any other application.
+class FloatingWindowInterface: public WindowInterface {
+	Q_OBJECT;
+	// clang-format off
+	/// Window title.
+	Q_PROPERTY(QString title READ default WRITE default NOTIFY titleChanged BINDABLE bindableTitle);
+	/// Minimum window size given to the window system.
+	Q_PROPERTY(QSize minimumSize READ default WRITE default NOTIFY minimumSizeChanged BINDABLE bindableMinimumSize);
+	/// Maximum window size given to the window system.
+	Q_PROPERTY(QSize maximumSize READ default WRITE default NOTIFY maximumSizeChanged BINDABLE bindableMaximumSize);
+	// clang-format on
+	QML_NAMED_ELEMENT(FloatingWindow);
+
+public:
+	explicit FloatingWindowInterface(QObject* parent = nullptr);
+
+	void onReload(QObject* oldInstance) override;
+
+	[[nodiscard]] ProxyWindowBase* proxyWindow() const override;
+
+	QBindable<QSize> bindableMinimumSize() { return &this->window->bMinimumSize; }
+	QBindable<QSize> bindableMaximumSize() { return &this->window->bMaximumSize; }
+	QBindable<QString> bindableTitle() { return &this->window->bTitle; }
+
+signals:
+	void minimumSizeChanged();
+	void maximumSizeChanged();
+	void titleChanged();
+
+private:
+	ProxyFloatingWindow* window;
+};
diff --git a/src/window/init.cpp b/src/window/init.cpp
new file mode 100644
index 00000000..47c03a4a
--- /dev/null
+++ b/src/window/init.cpp
@@ -0,0 +1,25 @@
+#include <qqml.h>
+#include <qstring.h>
+
+#include "../core/plugin.hpp"
+
+namespace {
+
+class WindowPlugin: public QsEnginePlugin {
+	// _Window has to be registered before wayland or x11 modules, otherwise module overlays
+	// will apply in the wrong order.
+	QString name() override { return "window"; }
+
+	void registerTypes() override {
+		qmlRegisterModuleImport(
+		    "Quickshell",
+		    QQmlModuleImportModuleAny,
+		    "Quickshell._Window",
+		    QQmlModuleImportLatest
+		);
+	}
+};
+
+QS_REGISTER_PLUGIN(WindowPlugin);
+
+} // namespace
diff --git a/src/core/panelinterface.cpp b/src/window/panelinterface.cpp
similarity index 100%
rename from src/core/panelinterface.cpp
rename to src/window/panelinterface.cpp
diff --git a/src/core/panelinterface.hpp b/src/window/panelinterface.hpp
similarity index 69%
rename from src/core/panelinterface.hpp
rename to src/window/panelinterface.hpp
index b46c25ca..64dff503 100644
--- a/src/core/panelinterface.hpp
+++ b/src/window/panelinterface.hpp
@@ -1,9 +1,12 @@
 #pragma once
 
+#include <qnamespace.h>
 #include <qqmlintegration.h>
 #include <qtmetamacros.h>
+#include <qtypes.h>
 
-#include "doc.hpp"
+#include "../core/doc.hpp"
+#include "../core/types.hpp"
 #include "windowinterface.hpp"
 
 class Anchors {
@@ -12,12 +15,28 @@ class Anchors {
 	Q_PROPERTY(bool right MEMBER mRight);
 	Q_PROPERTY(bool top MEMBER mTop);
 	Q_PROPERTY(bool bottom MEMBER mBottom);
-	QML_VALUE_TYPE(anchors);
+	QML_VALUE_TYPE(panelAnchors);
+	QML_STRUCTURED_VALUE;
 
 public:
 	[[nodiscard]] bool horizontalConstraint() const noexcept { return this->mLeft && this->mRight; }
 	[[nodiscard]] bool verticalConstraint() const noexcept { return this->mTop && this->mBottom; }
 
+	[[nodiscard]] Qt::Edge exclusionEdge() const noexcept {
+		auto hasHEdge = this->mLeft ^ this->mRight;
+		auto hasVEdge = this->mTop ^ this->mBottom;
+
+		if (hasVEdge && !hasHEdge) {
+			if (this->mTop) return Qt::TopEdge;
+			if (this->mBottom) return Qt::BottomEdge;
+		} else if (hasHEdge && !hasVEdge) {
+			if (this->mLeft) return Qt::LeftEdge;
+			if (this->mRight) return Qt::RightEdge;
+		}
+
+		return static_cast<Qt::Edge>(0);
+	}
+
 	[[nodiscard]] bool operator==(const Anchors& other) const noexcept {
 		// clang-format off
 		return this->mLeft == other.mLeft
@@ -33,35 +52,13 @@ public:
 	bool mBottom = false;
 };
 
-class Margins {
-	Q_GADGET;
-	Q_PROPERTY(qint32 left MEMBER mLeft);
-	Q_PROPERTY(qint32 right MEMBER mRight);
-	Q_PROPERTY(qint32 top MEMBER mTop);
-	Q_PROPERTY(qint32 bottom MEMBER mBottom);
-	QML_VALUE_TYPE(margins);
-
-public:
-	[[nodiscard]] bool operator==(const Margins& other) const noexcept {
-		// clang-format off
-		return this->mLeft == other.mLeft
-			&& this->mRight == other.mRight
-			&& this->mTop == other.mTop
-			&& this->mBottom == other.mBottom;
-		// clang-format on
-	}
-
-	qint32 mLeft = 0;
-	qint32 mRight = 0;
-	qint32 mTop = 0;
-	qint32 mBottom = 0;
-};
-
+///! Panel exclusion mode
+/// See @@PanelWindow.exclusionMode.
 namespace ExclusionMode { // NOLINT
 Q_NAMESPACE;
 QML_ELEMENT;
 
-enum Enum {
+enum Enum : quint8 {
 	/// Respect the exclusion zone of other shell layers and optionally set one
 	Normal = 0,
 	/// Ignore exclusion zones of other shell layers. You cannot set an exclusion zone in this mode.
@@ -111,14 +108,24 @@ class PanelWindowInterface: public WindowInterface {
 	/// > [!INFO] Only applies to edges with anchors
 	Q_PROPERTY(Margins margins READ margins WRITE setMargins NOTIFY marginsChanged);
 	/// The amount of space reserved for the shell layer relative to its anchors.
-	/// Setting this property sets `exclusionMode` to `Normal`.
+	/// Setting this property sets @@exclusionMode to `ExclusionMode.Normal`.
 	///
 	/// > [!INFO] Either 1 or 3 anchors are required for the zone to take effect.
 	Q_PROPERTY(qint32 exclusiveZone READ exclusiveZone WRITE setExclusiveZone NOTIFY exclusiveZoneChanged);
 	/// Defaults to `ExclusionMode.Auto`.
 	Q_PROPERTY(ExclusionMode::Enum exclusionMode READ exclusionMode WRITE setExclusionMode NOTIFY exclusionModeChanged);
+	/// If the panel should render above standard windows. Defaults to true.
+	///
+	/// Note: On Wayland this property corrosponds to @@Quickshell.Wayland.WlrLayershell.layer.
+	Q_PROPERTY(bool aboveWindows READ aboveWindows WRITE setAboveWindows NOTIFY aboveWindowsChanged);
+	/// If the panel should accept keyboard focus. Defaults to false.
+	///
+	/// Note: On Wayland this property corrosponds to @@Quickshell.Wayland.WlrLayershell.keyboardFocus.
+	Q_PROPERTY(bool focusable READ focusable WRITE setFocusable NOTIFY focusableChanged);
 	// clang-format on
-	QSDOC_NAMED_ELEMENT(PanelWindow);
+	QML_NAMED_ELEMENT(PanelWindow);
+	QML_UNCREATABLE("No PanelWindow backend loaded.");
+	QSDOC_CREATABLE;
 
 public:
 	explicit PanelWindowInterface(QObject* parent = nullptr): WindowInterface(parent) {}
@@ -135,9 +142,17 @@ public:
 	[[nodiscard]] virtual ExclusionMode::Enum exclusionMode() const = 0;
 	virtual void setExclusionMode(ExclusionMode::Enum exclusionMode) = 0;
 
+	[[nodiscard]] virtual bool aboveWindows() const = 0;
+	virtual void setAboveWindows(bool aboveWindows) = 0;
+
+	[[nodiscard]] virtual bool focusable() const = 0;
+	virtual void setFocusable(bool focusable) = 0;
+
 signals:
 	void anchorsChanged();
 	void marginsChanged();
 	void exclusiveZoneChanged();
 	void exclusionModeChanged();
+	void aboveWindowsChanged();
+	void focusableChanged();
 };
diff --git a/src/window/popupwindow.cpp b/src/window/popupwindow.cpp
new file mode 100644
index 00000000..ec2be7ed
--- /dev/null
+++ b/src/window/popupwindow.cpp
@@ -0,0 +1,145 @@
+#include "popupwindow.hpp"
+
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qqmlinfo.h>
+#include <qtypes.h>
+#include <qwindow.h>
+
+#include "../core/popupanchor.hpp"
+#include "../core/qmlscreen.hpp"
+#include "windowinterface.hpp"
+
+ProxyPopupWindow::ProxyPopupWindow(QObject* parent): ProxyWindowBase(parent) {
+	this->mVisible = false;
+	// clang-format off
+	QObject::connect(&this->mAnchor, &PopupAnchor::windowChanged, this, &ProxyPopupWindow::parentWindowChanged);
+	QObject::connect(&this->mAnchor, &PopupAnchor::windowRectChanged, this, &ProxyPopupWindow::reposition);
+	QObject::connect(&this->mAnchor, &PopupAnchor::edgesChanged, this, &ProxyPopupWindow::reposition);
+	QObject::connect(&this->mAnchor, &PopupAnchor::gravityChanged, this, &ProxyPopupWindow::reposition);
+	QObject::connect(&this->mAnchor, &PopupAnchor::adjustmentChanged, this, &ProxyPopupWindow::reposition);
+	QObject::connect(&this->mAnchor, &PopupAnchor::backingWindowVisibilityChanged, this, &ProxyPopupWindow::onParentUpdated);
+	// clang-format on
+}
+
+void ProxyPopupWindow::completeWindow() {
+	this->ProxyWindowBase::completeWindow();
+
+	// clang-format off
+	QObject::connect(this->window, &QWindow::visibleChanged, this, &ProxyPopupWindow::onVisibleChanged);
+	QObject::connect(this->window, &QWindow::widthChanged, this, &ProxyPopupWindow::reposition);
+	QObject::connect(this->window, &QWindow::heightChanged, this, &ProxyPopupWindow::reposition);
+	// clang-format on
+
+	this->window->setFlag(Qt::ToolTip);
+}
+
+void ProxyPopupWindow::postCompleteWindow() { this->updateTransientParent(); }
+
+void ProxyPopupWindow::setParentWindow(QObject* parent) {
+	qmlWarning(this) << "PopupWindow.parentWindow is deprecated. Use PopupWindow.anchor.window.";
+	this->mAnchor.setWindow(parent);
+}
+
+QObject* ProxyPopupWindow::parentWindow() const { return this->mAnchor.window(); }
+
+void ProxyPopupWindow::updateTransientParent() {
+	auto* bw = this->mAnchor.backingWindow();
+
+	if (this->window != nullptr && bw != this->window->transientParent()) {
+		if (this->window->transientParent()) {
+			QObject::disconnect(this->window->transientParent(), nullptr, this, nullptr);
+		}
+
+		if (bw && PopupPositioner::instance()->shouldRepositionOnMove()) {
+			QObject::connect(bw, &QWindow::xChanged, this, &ProxyPopupWindow::reposition);
+			QObject::connect(bw, &QWindow::yChanged, this, &ProxyPopupWindow::reposition);
+			QObject::connect(bw, &QWindow::widthChanged, this, &ProxyPopupWindow::reposition);
+			QObject::connect(bw, &QWindow::heightChanged, this, &ProxyPopupWindow::reposition);
+		}
+
+		this->window->setTransientParent(bw);
+	}
+
+	this->updateVisible();
+}
+
+void ProxyPopupWindow::onParentUpdated() { this->updateTransientParent(); }
+
+void ProxyPopupWindow::setScreen(QuickshellScreenInfo* /*unused*/) {
+	qmlWarning(this
+	) << "Cannot set screen of popup window, as that is controlled by the parent window";
+}
+
+void ProxyPopupWindow::setVisible(bool visible) {
+	if (visible == this->wantsVisible) return;
+	this->wantsVisible = visible;
+	this->updateVisible();
+}
+
+void ProxyPopupWindow::updateVisible() {
+	auto target = this->wantsVisible && this->mAnchor.window() != nullptr
+	           && this->mAnchor.proxyWindow()->isVisibleDirect();
+
+	if (target && this->window != nullptr && !this->window->isVisible()) {
+		PopupPositioner::instance()->reposition(&this->mAnchor, this->window);
+	}
+
+	this->ProxyWindowBase::setVisible(target);
+}
+
+void ProxyPopupWindow::onVisibleChanged() {
+	// If the window was made invisible without its parent becoming invisible
+	// the compositor probably destroyed it. Without this the window won't ever
+	// be able to become visible again.
+	if (this->window->transientParent() && this->window->transientParent()->isVisible()) {
+		this->wantsVisible = this->window->isVisible();
+	}
+}
+
+void ProxyPopupWindow::setRelativeX(qint32 x) {
+	qmlWarning(this) << "PopupWindow.relativeX is deprecated. Use PopupWindow.anchor.rect.x.";
+	auto rect = this->mAnchor.rect();
+	if (x == rect.x) return;
+	rect.x = x;
+	this->mAnchor.setRect(rect);
+}
+
+qint32 ProxyPopupWindow::relativeX() const {
+	qmlWarning(this) << "PopupWindow.relativeX is deprecated. Use PopupWindow.anchor.rect.x.";
+	return this->mAnchor.rect().x;
+}
+
+void ProxyPopupWindow::setRelativeY(qint32 y) {
+	qmlWarning(this) << "PopupWindow.relativeY is deprecated. Use PopupWindow.anchor.rect.y.";
+	auto rect = this->mAnchor.rect();
+	if (y == rect.y) return;
+	rect.y = y;
+	this->mAnchor.setRect(rect);
+}
+
+qint32 ProxyPopupWindow::relativeY() const {
+	qmlWarning(this) << "PopupWindow.relativeY is deprecated. Use PopupWindow.anchor.rect.y.";
+	return this->mAnchor.rect().y;
+}
+
+PopupAnchor* ProxyPopupWindow::anchor() { return &this->mAnchor; }
+
+void ProxyPopupWindow::reposition() {
+	// not gated on pendingReposition as a polish might not be triggered in edge cases
+	if (this->window) {
+		this->pendingReposition = true;
+		this->schedulePolish();
+	}
+}
+
+void ProxyPopupWindow::onPolished() {
+	this->ProxyWindowBase::onPolished();
+	if (this->pendingReposition) {
+		this->pendingReposition = false;
+
+		if (this->window) {
+			PopupPositioner::instance()->reposition(&this->mAnchor, this->window);
+		}
+	}
+}
diff --git a/src/window/popupwindow.hpp b/src/window/popupwindow.hpp
new file mode 100644
index 00000000..e00495cc
--- /dev/null
+++ b/src/window/popupwindow.hpp
@@ -0,0 +1,124 @@
+#pragma once
+
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qquickwindow.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../core/doc.hpp"
+#include "../core/popupanchor.hpp"
+#include "../core/qmlscreen.hpp"
+#include "proxywindow.hpp"
+#include "windowinterface.hpp"
+
+///! Popup window.
+/// Popup window that can display in a position relative to a floating
+/// or panel window.
+///
+/// #### Example
+/// The following snippet creates a panel with a popup centered over it.
+///
+/// ```qml
+/// PanelWindow {
+///   id: toplevel
+///
+///   anchors {
+///     bottom: true
+///     left: true
+///     right: true
+///   }
+///
+///   PopupWindow {
+///     anchor.window: toplevel
+///     anchor.rect.x: parentWindow.width / 2 - width / 2
+///     anchor.rect.y: parentWindow.height
+///     width: 500
+///     height: 500
+///     visible: true
+///   }
+/// }
+/// ```
+class ProxyPopupWindow: public ProxyWindowBase {
+	QSDOC_BASECLASS(WindowInterface);
+	Q_OBJECT;
+	// clang-format off
+	/// > [!ERROR] Deprecated in favor of `anchor.window`.
+	///
+	/// The parent window of this popup.
+	///
+	/// Changing this property reparents the popup.
+	Q_PROPERTY(QObject* parentWindow READ parentWindow WRITE setParentWindow NOTIFY parentWindowChanged);
+	/// > [!ERROR] Deprecated in favor of `anchor.rect.x`.
+	///
+	/// The X position of the popup relative to the parent window.
+	Q_PROPERTY(qint32 relativeX READ relativeX WRITE setRelativeX NOTIFY relativeXChanged);
+	/// > [!ERROR] Deprecated in favor of `anchor.rect.y`.
+	///
+	/// The Y position of the popup relative to the parent window.
+	Q_PROPERTY(qint32 relativeY READ relativeY WRITE setRelativeY NOTIFY relativeYChanged);
+	/// The popup's anchor / positioner relative to another item or window. The popup will
+	/// not be shown until it has a valid anchor relative to a window and @@visible is true.
+	///
+	/// You can set properties of the anchor like so:
+	/// ```qml
+	/// PopupWindow {
+	///   anchor.window: parentwindow
+	///   // or
+	///   anchor {
+	///     window: parentwindow
+	///   }
+	/// }
+	/// ```
+	Q_PROPERTY(PopupAnchor* anchor READ anchor CONSTANT);
+	/// If the window is shown or hidden. Defaults to false.
+	///
+	/// The popup will not be shown until @@anchor is valid, regardless of this property.
+	QSDOC_PROPERTY_OVERRIDE(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged);
+	/// The screen that the window currently occupies.
+	///
+	/// This may be modified to move the window to the given screen.
+	QSDOC_PROPERTY_OVERRIDE(QuickshellScreenInfo* screen READ screen NOTIFY screenChanged);
+	// clang-format on
+	QML_NAMED_ELEMENT(PopupWindow);
+
+public:
+	explicit ProxyPopupWindow(QObject* parent = nullptr);
+
+	void completeWindow() override;
+	void postCompleteWindow() override;
+	void onPolished() override;
+
+	void setScreen(QuickshellScreenInfo* screen) override;
+	void setVisible(bool visible) override;
+
+	[[nodiscard]] QObject* parentWindow() const;
+	void setParentWindow(QObject* parent);
+
+	[[nodiscard]] qint32 relativeX() const;
+	void setRelativeX(qint32 x);
+
+	[[nodiscard]] qint32 relativeY() const;
+	void setRelativeY(qint32 y);
+
+	[[nodiscard]] PopupAnchor* anchor();
+
+signals:
+	void parentWindowChanged();
+	void relativeXChanged();
+	void relativeYChanged();
+
+private slots:
+	void onVisibleChanged();
+	void onParentUpdated();
+	void reposition();
+
+private:
+	QQuickWindow* parentBackingWindow();
+	void updateTransientParent();
+	void updateVisible();
+
+	PopupAnchor mAnchor {this};
+	bool wantsVisible = false;
+	bool pendingReposition = false;
+};
diff --git a/src/window/proxywindow.cpp b/src/window/proxywindow.cpp
new file mode 100644
index 00000000..618751ae
--- /dev/null
+++ b/src/window/proxywindow.cpp
@@ -0,0 +1,611 @@
+#include "proxywindow.hpp"
+
+#include <private/qquickwindow_p.h>
+#include <qcontainerfwd.h>
+#include <qcoreevent.h>
+#include <qevent.h>
+#include <qguiapplication.h>
+#include <qlogging.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qpoint.h>
+#include <qqmlcontext.h>
+#include <qqmlengine.h>
+#include <qqmlinfo.h>
+#include <qqmllist.h>
+#include <qquickitem.h>
+#include <qquickwindow.h>
+#include <qregion.h>
+#include <qsurfaceformat.h>
+#include <qtenvironmentvariables.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+#include <qwindow.h>
+
+#include "../core/generation.hpp"
+#include "../core/qmlglobal.hpp"
+#include "../core/qmlscreen.hpp"
+#include "../core/region.hpp"
+#include "../core/reload.hpp"
+#include "../debug/lint.hpp"
+#include "windowinterface.hpp"
+
+ProxyWindowBase::ProxyWindowBase(QObject* parent)
+    : Reloadable(parent)
+    , mContentItem(new ProxyWindowContentItem()) {
+	QQmlEngine::setObjectOwnership(this->mContentItem, QQmlEngine::CppOwnership);
+	this->mContentItem->setParent(this);
+
+	// clang-format off
+	QObject::connect(this->mContentItem, &ProxyWindowContentItem::polished, this, &ProxyWindowBase::onPolished);
+
+	QObject::connect(this, &ProxyWindowBase::widthChanged, this, &ProxyWindowBase::onWidthChanged);
+	QObject::connect(this, &ProxyWindowBase::heightChanged, this, &ProxyWindowBase::onHeightChanged);
+
+	QObject::connect(this, &ProxyWindowBase::widthChanged, this, &ProxyWindowBase::onMaskChanged);
+	QObject::connect(this, &ProxyWindowBase::heightChanged, this, &ProxyWindowBase::onMaskChanged);
+
+	QObject::connect(this, &ProxyWindowBase::xChanged, this, &ProxyWindowBase::windowTransformChanged);
+	QObject::connect(this, &ProxyWindowBase::yChanged, this, &ProxyWindowBase::windowTransformChanged);
+	QObject::connect(this, &ProxyWindowBase::widthChanged, this, &ProxyWindowBase::windowTransformChanged);
+	QObject::connect(this, &ProxyWindowBase::heightChanged, this, &ProxyWindowBase::windowTransformChanged);
+	QObject::connect(this, &ProxyWindowBase::backerVisibilityChanged, this, &ProxyWindowBase::windowTransformChanged);
+	// clang-format on
+}
+
+ProxyWindowBase::~ProxyWindowBase() { this->deleteWindow(true); }
+
+void ProxyWindowBase::onReload(QObject* oldInstance) {
+	this->window = this->retrieveWindow(oldInstance);
+	auto wasVisible = this->window != nullptr && this->window->isVisible();
+	this->ensureQWindow();
+
+	// The qml engine will leave the WindowInterface as owner of everything
+	// nested in an item, so we have to make sure the interface's children
+	// are also reloaded.
+	// Reparenting from the interface does not work reliably, so instead
+	// we check if the parent is one, as it proxies reloads to here.
+	if (auto* w = qobject_cast<WindowInterface*>(this->parent())) {
+		for (auto* child: w->children()) {
+			if (child == this) continue;
+			auto* oldInterfaceParent = oldInstance == nullptr ? nullptr : oldInstance->parent();
+			Reloadable::reloadRecursive(child, oldInterfaceParent);
+		}
+	}
+
+	Reloadable::reloadChildrenRecursive(this, oldInstance);
+
+	this->connectWindow();
+	this->completeWindow();
+
+	this->reloadComplete = true;
+
+	emit this->windowConnected();
+	this->postCompleteWindow();
+
+	if (wasVisible && this->isVisibleDirect()) {
+		emit this->backerVisibilityChanged();
+		this->onExposed();
+	}
+}
+
+void ProxyWindowBase::postCompleteWindow() { this->setVisible(this->mVisible); }
+
+ProxiedWindow* ProxyWindowBase::createQQuickWindow() { return new ProxiedWindow(this); }
+
+void ProxyWindowBase::ensureQWindow() {
+	auto format = QSurfaceFormat::defaultFormat();
+
+	{
+		// match QtQuick's default format, including env var controls
+		static const auto useDepth = qEnvironmentVariableIsEmpty("QSG_NO_DEPTH_BUFFER");
+		static const auto useStencil = qEnvironmentVariableIsEmpty("QSG_NO_STENCIL_BUFFER");
+		static const auto enableDebug = qEnvironmentVariableIsSet("QSG_OPENGL_DEBUG");
+		static const auto disableVSync = qEnvironmentVariableIsSet("QSG_NO_VSYNC");
+
+		if (useDepth && format.depthBufferSize() == -1) format.setDepthBufferSize(24);
+		else if (!useDepth) format.setDepthBufferSize(0);
+
+		if (useStencil && format.stencilBufferSize() == -1) format.setStencilBufferSize(8);
+		else if (!useStencil) format.setStencilBufferSize(0);
+
+		auto opaque = this->qsSurfaceFormat.opaqueModified ? this->qsSurfaceFormat.opaque
+		                                                   : this->mColor.alpha() >= 255;
+
+		format.setOption(QSurfaceFormat::ResetNotification);
+
+		if (opaque) format.setAlphaBufferSize(0);
+		else format.setAlphaBufferSize(8);
+
+		if (enableDebug) format.setOption(QSurfaceFormat::DebugContext);
+		if (disableVSync) format.setSwapInterval(0);
+
+		format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
+		format.setRedBufferSize(8);
+		format.setGreenBufferSize(8);
+		format.setBlueBufferSize(8);
+	}
+
+	this->mSurfaceFormat = format;
+
+	auto useOldWindow = this->window != nullptr;
+
+	if (useOldWindow) {
+		if (this->window->requestedFormat() != format) {
+			useOldWindow = false;
+		}
+	}
+
+	if (useOldWindow) return;
+	delete this->window;
+	this->window = nullptr; // createQQuickWindow may indirectly reference this->window
+	this->window = this->createQQuickWindow();
+	this->window->setFormat(format);
+}
+
+void ProxyWindowBase::createWindow() {
+	this->ensureQWindow();
+	this->connectWindow();
+	this->completeWindow();
+	emit this->windowConnected();
+}
+
+void ProxyWindowBase::deleteWindow(bool keepItemOwnership) {
+	if (this->window != nullptr) emit this->windowDestroyed();
+	if (auto* window = this->disownWindow(keepItemOwnership)) {
+		if (auto* generation = EngineGeneration::findObjectGeneration(this)) {
+			generation->deregisterIncubationController(window->incubationController());
+		}
+
+		window->deleteLater();
+	}
+}
+
+ProxiedWindow* ProxyWindowBase::disownWindow(bool keepItemOwnership) {
+	if (this->window == nullptr) return nullptr;
+
+	QObject::disconnect(this->window, nullptr, this, nullptr);
+
+	if (!keepItemOwnership) {
+		this->mContentItem->setParentItem(nullptr);
+	}
+
+	auto* window = this->window;
+	this->window = nullptr;
+	return window;
+}
+
+ProxiedWindow* ProxyWindowBase::retrieveWindow(QObject* oldInstance) {
+	auto* old = qobject_cast<ProxyWindowBase*>(oldInstance);
+	return old == nullptr ? nullptr : old->disownWindow();
+}
+
+void ProxyWindowBase::connectWindow() {
+	if (auto* generation = EngineGeneration::findObjectGeneration(this)) {
+		// All windows have effectively the same incubation controller so it dosen't matter
+		// which window it belongs to. We do want to replace the delay one though.
+		generation->registerIncubationController(this->window->incubationController());
+	}
+
+	this->window->setProxy(this);
+
+	// clang-format off
+	QObject::connect(this->window, &QWindow::visibilityChanged, this, &ProxyWindowBase::onVisibleChanged);
+	QObject::connect(this->window, &QWindow::xChanged, this, &ProxyWindowBase::xChanged);
+	QObject::connect(this->window, &QWindow::yChanged, this, &ProxyWindowBase::yChanged);
+	QObject::connect(this->window, &QWindow::widthChanged, this, &ProxyWindowBase::widthChanged);
+	QObject::connect(this->window, &QWindow::heightChanged, this, &ProxyWindowBase::heightChanged);
+	QObject::connect(this->window, &QWindow::screenChanged, this, &ProxyWindowBase::screenChanged);
+	QObject::connect(this->window, &QQuickWindow::colorChanged, this, &ProxyWindowBase::colorChanged);
+	QObject::connect(this->window, &QQuickWindow::sceneGraphError, this, &ProxyWindowBase::onSceneGraphError);
+	QObject::connect(this->window, &ProxiedWindow::exposed, this, &ProxyWindowBase::onExposed);
+	QObject::connect(this->window, &ProxiedWindow::devicePixelRatioChanged, this, &ProxyWindowBase::devicePixelRatioChanged);
+	// clang-format on
+}
+
+void ProxyWindowBase::completeWindow() {
+	if (this->mScreen != nullptr && this->window->screen() != this->mScreen) {
+		if (this->window->isVisible()) this->window->setVisible(false);
+		this->window->setScreen(this->mScreen);
+	}
+
+	this->trySetWidth(this->implicitWidth());
+	this->trySetHeight(this->implicitHeight());
+	this->setColor(this->mColor);
+	this->updateMask();
+
+	// notify initial / post-connection geometry
+	emit this->xChanged();
+	emit this->yChanged();
+	emit this->widthChanged();
+	emit this->heightChanged();
+	emit this->devicePixelRatioChanged();
+
+	this->mContentItem->setParentItem(this->window->contentItem());
+	this->mContentItem->setWidth(this->width());
+	this->mContentItem->setHeight(this->height());
+
+	// without this the dangling screen pointer wont be updated to a real screen
+	emit this->screenChanged();
+}
+
+void ProxyWindowBase::onSceneGraphError(
+    QQuickWindow::SceneGraphError error,
+    const QString& message
+) {
+	if (error == QQuickWindow::ContextNotAvailable) {
+		qCritical().nospace() << "Failed to create graphics context for " << this << ": " << message;
+	} else {
+		qCritical().nospace() << "Scene graph error " << error << " occurred for " << this << ": "
+		                      << message;
+	}
+
+	emit this->resourcesLost();
+	this->mVisible = false;
+	this->setVisibleDirect(false);
+}
+
+void ProxyWindowBase::onVisibleChanged() {
+	if (this->mVisible && !this->window->isVisible()) {
+		this->mVisible = false;
+		this->setVisibleDirect(false);
+		emit this->closed();
+	}
+
+	emit this->visibleChanged();
+}
+
+bool ProxyWindowBase::deleteOnInvisible() const { return false; }
+
+QQuickWindow* ProxyWindowBase::backingWindow() const { return this->window; }
+QQuickItem* ProxyWindowBase::contentItem() const { return this->mContentItem; }
+
+bool ProxyWindowBase::isVisible() const {
+	if (this->window == nullptr) return this->mVisible;
+	else return this->isVisibleDirect();
+}
+
+bool ProxyWindowBase::isVisibleDirect() const {
+	if (this->window == nullptr) return false;
+	else return this->window->isVisible();
+}
+
+void ProxyWindowBase::setVisible(bool visible) {
+	this->mVisible = visible;
+	if (this->reloadComplete) this->setVisibleDirect(visible);
+}
+
+void ProxyWindowBase::setVisibleDirect(bool visible) {
+	if (this->deleteOnInvisible()) {
+		if (visible == this->isVisibleDirect()) return;
+
+		if (visible) {
+			this->createWindow();
+			this->polishItems();
+			this->window->setVisible(true);
+			emit this->backerVisibilityChanged();
+		} else {
+			if (this->window != nullptr) {
+				this->window->setVisible(false);
+				emit this->backerVisibilityChanged();
+				this->deleteWindow();
+			}
+		}
+	} else if (this->window != nullptr) {
+		if (visible) this->polishItems();
+		this->window->setVisible(visible);
+		emit this->backerVisibilityChanged();
+	}
+}
+
+void ProxyWindowBase::schedulePolish() {
+	if (this->isVisibleDirect()) {
+		this->mContentItem->polish();
+	}
+}
+
+void ProxyWindowBase::polishItems() {
+	// Due to QTBUG-126704, layouts in invisible windows don't update their dimensions.
+	// Usually this isn't an issue, but it is when the size of a window is based on the size
+	// of its content, and that content is in a layout.
+	//
+	// This hack manually polishes the item tree right before showing the window so it will
+	// always be created with the correct size.
+	QQuickWindowPrivate::get(this->window)->polishItems();
+}
+
+void ProxyWindowBase::onExposed() {
+	this->onPolished();
+
+	if (!this->ranLints) {
+		qs::debug::lintItemTree(this->mContentItem);
+		this->ranLints = true;
+	}
+}
+
+qint32 ProxyWindowBase::x() const {
+	if (this->window == nullptr) return 0;
+	else return this->window->x();
+}
+
+qint32 ProxyWindowBase::y() const {
+	if (this->window == nullptr) return 0;
+	else return this->window->y();
+}
+
+void ProxyWindowBase::setImplicitWidth(qint32 implicitWidth) {
+	if (implicitWidth == this->bImplicitWidth) return;
+	this->bImplicitWidth = implicitWidth;
+
+	if (this->window) this->trySetWidth(implicitWidth);
+	else emit this->widthChanged();
+}
+
+void ProxyWindowBase::trySetWidth(qint32 implicitWidth) { this->window->setWidth(implicitWidth); }
+
+void ProxyWindowBase::setImplicitHeight(qint32 implicitHeight) {
+	if (implicitHeight == this->bImplicitHeight) return;
+	this->bImplicitHeight = implicitHeight;
+
+	if (this->window) this->trySetHeight(implicitHeight);
+	else emit this->heightChanged();
+}
+
+void ProxyWindowBase::trySetHeight(qint32 implicitHeight) {
+	this->window->setHeight(implicitHeight);
+}
+
+qint32 ProxyWindowBase::width() const {
+	if (this->window == nullptr) return this->implicitWidth();
+	else return this->window->width();
+}
+
+void ProxyWindowBase::setWidth(qint32 width) {
+	this->setImplicitWidth(width);
+	qmlWarning(this) << "Setting `width` is deprecated. Set `implicitWidth` instead.";
+}
+
+qint32 ProxyWindowBase::height() const {
+	if (this->window == nullptr) return this->implicitHeight();
+	else return this->window->height();
+}
+
+void ProxyWindowBase::setHeight(qint32 height) {
+	this->setImplicitHeight(height);
+	qmlWarning(this) << "Setting `height` is deprecated. Set `implicitHeight` instead.";
+}
+
+void ProxyWindowBase::setScreen(QuickshellScreenInfo* screen) {
+	auto* qscreen = screen == nullptr ? nullptr : screen->screen;
+	auto newMScreen = this->mScreen != qscreen;
+
+	if (this->mScreen && newMScreen) {
+		QObject::disconnect(this->mScreen, nullptr, this, nullptr);
+	}
+
+	auto* oldScreen = this->qscreen();
+	this->mScreen = qscreen;
+
+	if (oldScreen != qscreen) {
+		if (this->window == nullptr) {
+			emit this->screenChanged();
+		} else if (qscreen) {
+			auto reshow = this->isVisibleDirect();
+			if (reshow) this->setVisibleDirect(false);
+			if (this->window != nullptr) this->window->setScreen(qscreen);
+			if (reshow) this->setVisibleDirect(true);
+		}
+	}
+
+	if (qscreen && newMScreen) {
+		QObject::connect(this->mScreen, &QObject::destroyed, this, &ProxyWindowBase::onScreenDestroyed);
+	}
+}
+
+void ProxyWindowBase::onScreenDestroyed() { this->mScreen = nullptr; }
+
+QScreen* ProxyWindowBase::qscreen() const {
+	if (this->window) return this->window->screen();
+	if (this->mScreen) return this->mScreen;
+	return QGuiApplication::primaryScreen();
+}
+
+QuickshellScreenInfo* ProxyWindowBase::screen() const {
+	return QuickshellTracked::instance()->screenInfo(this->qscreen());
+}
+
+QColor ProxyWindowBase::color() const { return this->mColor; }
+
+void ProxyWindowBase::setColor(QColor color) {
+	this->mColor = color;
+
+	if (this->window == nullptr) {
+		if (color != this->mColor) emit this->colorChanged();
+	} else {
+		auto premultiplied = QColor::fromRgbF(
+		    color.redF() * color.alphaF(),
+		    color.greenF() * color.alphaF(),
+		    color.blueF() * color.alphaF(),
+		    color.alphaF()
+		);
+
+		this->window->setColor(premultiplied);
+		// setColor also modifies the alpha buffer size of the surface format
+		this->window->setFormat(this->mSurfaceFormat);
+	}
+}
+
+PendingRegion* ProxyWindowBase::mask() const { return this->mMask; }
+
+void ProxyWindowBase::setMask(PendingRegion* mask) {
+	if (mask == this->mMask) return;
+
+	if (this->mMask != nullptr) {
+		QObject::disconnect(this->mMask, nullptr, this, nullptr);
+	}
+
+	this->mMask = mask;
+
+	if (mask != nullptr) {
+		QObject::connect(mask, &QObject::destroyed, this, &ProxyWindowBase::onMaskDestroyed);
+		QObject::connect(mask, &PendingRegion::changed, this, &ProxyWindowBase::onMaskChanged);
+	}
+
+	this->onMaskChanged();
+	emit this->maskChanged();
+}
+
+void ProxyWindowBase::setSurfaceFormat(QsSurfaceFormat format) {
+	if (format == this->qsSurfaceFormat) return;
+	if (this->window != nullptr) {
+		qmlWarning(this) << "Cannot set window surface format.";
+		return;
+	}
+
+	this->qsSurfaceFormat = format;
+	emit this->surfaceFormatChanged();
+}
+
+qreal ProxyWindowBase::devicePixelRatio() const {
+	if (this->window != nullptr) return this->window->devicePixelRatio();
+	if (this->mScreen != nullptr) return this->mScreen->devicePixelRatio();
+	return 1.0;
+}
+
+void ProxyWindowBase::onMaskChanged() {
+	if (this->window != nullptr) this->updateMask();
+}
+
+void ProxyWindowBase::onMaskDestroyed() {
+	this->mMask = nullptr;
+	this->onMaskChanged();
+	emit this->maskChanged();
+}
+
+void ProxyWindowBase::updateMask() {
+	this->pendingPolish.inputMask = true;
+	this->schedulePolish();
+}
+
+QQmlListProperty<QObject> ProxyWindowBase::data() {
+	return this->mContentItem->property("data").value<QQmlListProperty<QObject>>();
+}
+
+void ProxyWindowBase::onWidthChanged() { this->mContentItem->setWidth(this->width()); }
+void ProxyWindowBase::onHeightChanged() { this->mContentItem->setHeight(this->height()); }
+
+QPointF ProxyWindowBase::itemPosition(QQuickItem* item) const {
+	if (!item) {
+		qCritical() << "Cannot map position of null item.";
+		return {};
+	}
+
+	return this->mContentItem->mapFromItem(item, 0, 0);
+}
+
+QRectF ProxyWindowBase::itemRect(QQuickItem* item) const {
+	if (!item) {
+		qCritical() << "Cannot map position of null item.";
+		return {};
+	}
+
+	return this->mContentItem->mapFromItem(item, item->boundingRect());
+}
+
+QPointF ProxyWindowBase::mapFromItem(QQuickItem* item, QPointF point) const {
+	if (!item) {
+		qCritical() << "Cannot map position of null item.";
+		return {};
+	}
+
+	return this->mContentItem->mapFromItem(item, point);
+}
+
+QPointF ProxyWindowBase::mapFromItem(QQuickItem* item, qreal x, qreal y) const {
+	if (!item) {
+		qCritical() << "Cannot map position of null item.";
+		return {};
+	}
+
+	return this->mContentItem->mapFromItem(item, x, y);
+}
+
+QRectF ProxyWindowBase::mapFromItem(QQuickItem* item, QRectF rect) const {
+	if (!item) {
+		qCritical() << "Cannot map position of null item.";
+		return {};
+	}
+
+	return this->mContentItem->mapFromItem(item, rect);
+}
+
+QRectF
+ProxyWindowBase::mapFromItem(QQuickItem* item, qreal x, qreal y, qreal width, qreal height) const {
+	if (!item) {
+		qCritical() << "Cannot map position of null item.";
+		return {};
+	}
+
+	return this->mContentItem->mapFromItem(item, x, y, width, height);
+}
+
+ProxyWindowAttached::ProxyWindowAttached(QQuickItem* parent): QsWindowAttached(parent) {
+	this->updateWindow();
+}
+
+QObject* ProxyWindowAttached::window() const { return this->mWindowInterface; }
+ProxyWindowBase* ProxyWindowAttached::proxyWindow() const { return this->mWindow; }
+
+QQuickItem* ProxyWindowAttached::contentItem() const {
+	return this->mWindow ? this->mWindow->contentItem() : nullptr;
+}
+
+void ProxyWindowAttached::updateWindow() {
+	auto* window = static_cast<QQuickItem*>(this->parent())->window(); // NOLINT
+
+	if (auto* proxy = qobject_cast<ProxiedWindow*>(window)) {
+		this->setWindow(proxy->proxy());
+	} else {
+		this->setWindow(nullptr);
+	}
+}
+
+void ProxyWindowAttached::setWindow(ProxyWindowBase* window) {
+	if (window == this->mWindow) return;
+	this->mWindow = window;
+	auto* parentInterface = window ? qobject_cast<WindowInterface*>(window->parent()) : nullptr;
+	this->mWindowInterface = parentInterface ? static_cast<QObject*>(parentInterface) : window;
+	emit this->windowChanged();
+}
+
+bool ProxiedWindow::event(QEvent* event) {
+	if (event->type() == QEvent::DevicePixelRatioChange) {
+		emit this->devicePixelRatioChanged();
+	}
+
+	return this->QQuickWindow::event(event);
+}
+
+void ProxiedWindow::exposeEvent(QExposeEvent* event) {
+	this->QQuickWindow::exposeEvent(event);
+	emit this->exposed();
+}
+
+void ProxyWindowContentItem::updatePolish() { emit this->polished(); }
+
+void ProxyWindowBase::onPolished() {
+	if (this->pendingPolish.inputMask) {
+		QRegion mask;
+		if (this->mMask != nullptr) {
+			mask = this->mMask->applyTo(QRect(0, 0, this->width(), this->height()));
+		}
+
+		this->window->setFlag(Qt::WindowTransparentForInput, this->mMask != nullptr && mask.isEmpty());
+		this->window->setMask(mask);
+
+		this->pendingPolish.inputMask = false;
+	}
+
+	emit this->polished();
+}
diff --git a/src/window/proxywindow.hpp b/src/window/proxywindow.hpp
new file mode 100644
index 00000000..025b970a
--- /dev/null
+++ b/src/window/proxywindow.hpp
@@ -0,0 +1,265 @@
+#pragma once
+
+#include <qcolor.h>
+#include <qcontainerfwd.h>
+#include <qevent.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qpoint.h>
+#include <qproperty.h>
+#include <qqmllist.h>
+#include <qqmlparserstatus.h>
+#include <qquickitem.h>
+#include <qquickwindow.h>
+#include <qsurfaceformat.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <qvariant.h>
+#include <qvectornd.h>
+#include <qwindow.h>
+
+#include "../core/qmlscreen.hpp"
+#include "../core/region.hpp"
+#include "../core/reload.hpp"
+#include "windowinterface.hpp"
+
+class ProxiedWindow;
+class ProxyWindowContentItem;
+
+// Proxy to an actual window exposing a limited property set with the ability to
+// transfer it to a new window.
+
+///! Base class for reloadable windows
+///
+/// [ShellWindow]: ../shellwindow
+/// [FloatingWindow]: ../floatingwindow
+class ProxyWindowBase: public Reloadable {
+	Q_OBJECT;
+	// clang-format off
+	/// The QtQuick window backing this window.
+	///
+	/// > [!WARNING] Do not expect values set via this property to work correctly.
+	/// > Values set this way will almost certainly misbehave across a reload, possibly
+	/// > even without one.
+	/// >
+	/// > Use **only** if you know what you are doing.
+	Q_PROPERTY(QQuickWindow* _backingWindow READ backingWindow);
+	Q_PROPERTY(QQuickItem* contentItem READ contentItem CONSTANT);
+	Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged);
+	Q_PROPERTY(qint32 implicitWidth READ implicitWidth WRITE setImplicitWidth NOTIFY implicitWidthChanged);
+	Q_PROPERTY(qint32 implicitHeight READ implicitHeight WRITE setImplicitHeight NOTIFY implicitHeightChanged);
+	Q_PROPERTY(qint32 width READ width WRITE setWidth NOTIFY widthChanged);
+	Q_PROPERTY(qint32 height READ height WRITE setHeight NOTIFY heightChanged);
+	Q_PROPERTY(qreal devicePixelRatio READ devicePixelRatio NOTIFY devicePixelRatioChanged);
+	Q_PROPERTY(QuickshellScreenInfo* screen READ screen WRITE setScreen NOTIFY screenChanged);
+	Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged);
+	Q_PROPERTY(PendingRegion* mask READ mask WRITE setMask NOTIFY maskChanged);
+	Q_PROPERTY(QObject* windowTransform READ windowTransform NOTIFY windowTransformChanged);
+	Q_PROPERTY(bool backingWindowVisible READ isVisibleDirect NOTIFY backerVisibilityChanged);
+	Q_PROPERTY(QsSurfaceFormat surfaceFormat READ surfaceFormat WRITE setSurfaceFormat NOTIFY surfaceFormatChanged);
+	Q_PROPERTY(QQmlListProperty<QObject> data READ data);
+	// clang-format on
+	Q_CLASSINFO("DefaultProperty", "data");
+
+public:
+	explicit ProxyWindowBase(QObject* parent = nullptr);
+	~ProxyWindowBase() override;
+
+	ProxyWindowBase(ProxyWindowBase&) = delete;
+	ProxyWindowBase(ProxyWindowBase&&) = delete;
+	void operator=(ProxyWindowBase&) = delete;
+	void operator=(ProxyWindowBase&&) = delete;
+
+	Q_INVOKABLE [[nodiscard]] QPointF itemPosition(QQuickItem* item) const;
+	Q_INVOKABLE [[nodiscard]] QRectF itemRect(QQuickItem* item) const;
+	Q_INVOKABLE [[nodiscard]] QPointF mapFromItem(QQuickItem* item, QPointF point) const;
+	Q_INVOKABLE [[nodiscard]] QPointF mapFromItem(QQuickItem* item, qreal x, qreal y) const;
+	Q_INVOKABLE [[nodiscard]] QRectF mapFromItem(QQuickItem* item, QRectF rect) const;
+	Q_INVOKABLE [[nodiscard]] QRectF
+	mapFromItem(QQuickItem* item, qreal x, qreal y, qreal width, qreal height) const;
+
+	void onReload(QObject* oldInstance) override;
+	void ensureQWindow();
+	void createWindow();
+	void deleteWindow(bool keepItemOwnership = false);
+
+	// Disown the backing window and delete all its children.
+	virtual ProxiedWindow* disownWindow(bool keepItemOwnership = false);
+
+	virtual ProxiedWindow* retrieveWindow(QObject* oldInstance);
+	virtual ProxiedWindow* createQQuickWindow();
+	virtual void connectWindow();
+	virtual void completeWindow();
+	virtual void postCompleteWindow();
+	[[nodiscard]] virtual bool deleteOnInvisible() const;
+
+	[[nodiscard]] QQuickWindow* backingWindow() const;
+	[[nodiscard]] QQuickItem* contentItem() const;
+
+	[[nodiscard]] virtual bool isVisible() const;
+	[[nodiscard]] virtual bool isVisibleDirect() const;
+	virtual void setVisible(bool visible);
+	virtual void setVisibleDirect(bool visible);
+
+	void schedulePolish();
+
+	[[nodiscard]] virtual qint32 x() const;
+	[[nodiscard]] virtual qint32 y() const;
+
+	[[nodiscard]] qint32 implicitWidth() const { return this->bImplicitWidth; }
+	void setImplicitWidth(qint32 implicitWidth);
+
+	[[nodiscard]] qint32 implicitHeight() const { return this->bImplicitHeight; }
+	void setImplicitHeight(qint32 implicitHeight);
+
+	[[nodiscard]] virtual qint32 width() const;
+	void setWidth(qint32 width);
+
+	[[nodiscard]] virtual qint32 height() const;
+	void setHeight(qint32 height);
+
+	virtual void trySetWidth(qint32 implicitWidth);
+	virtual void trySetHeight(qint32 implicitHeight);
+
+	[[nodiscard]] qreal devicePixelRatio() const;
+
+	[[nodiscard]] QScreen* qscreen() const;
+	[[nodiscard]] QuickshellScreenInfo* screen() const;
+	virtual void setScreen(QuickshellScreenInfo* screen);
+
+	[[nodiscard]] QColor color() const;
+	virtual void setColor(QColor color);
+
+	[[nodiscard]] PendingRegion* mask() const;
+	virtual void setMask(PendingRegion* mask);
+
+	[[nodiscard]] QsSurfaceFormat surfaceFormat() const { return this->qsSurfaceFormat; }
+	void setSurfaceFormat(QsSurfaceFormat format);
+
+	[[nodiscard]] QObject* windowTransform() const { return nullptr; } // NOLINT
+
+	[[nodiscard]] QQmlListProperty<QObject> data();
+
+signals:
+	void closed();
+	void resourcesLost();
+	void windowConnected();
+	void windowDestroyed();
+	void visibleChanged();
+	void backerVisibilityChanged();
+	void xChanged();
+	void yChanged();
+	void implicitWidthChanged();
+	void implicitHeightChanged();
+	void widthChanged();
+	void heightChanged();
+	void devicePixelRatioChanged();
+	void windowTransformChanged();
+	void screenChanged();
+	void colorChanged();
+	void maskChanged();
+	void surfaceFormatChanged();
+	void polished();
+
+protected slots:
+	virtual void onWidthChanged();
+	virtual void onHeightChanged();
+	virtual void onPolished();
+
+private slots:
+	void onSceneGraphError(QQuickWindow::SceneGraphError error, const QString& message);
+	void onVisibleChanged();
+	void onMaskChanged();
+	void onMaskDestroyed();
+	void onScreenDestroyed();
+	void onExposed();
+
+protected:
+	bool mVisible = true;
+	QScreen* mScreen = nullptr;
+	QColor mColor = Qt::white;
+	PendingRegion* mMask = nullptr;
+	ProxiedWindow* window = nullptr;
+	ProxyWindowContentItem* mContentItem = nullptr;
+	bool reloadComplete = false;
+	bool ranLints = false;
+	QsSurfaceFormat qsSurfaceFormat;
+	QSurfaceFormat mSurfaceFormat;
+
+	struct {
+		bool inputMask : 1 = false;
+	} pendingPolish;
+
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(
+	    ProxyWindowBase,
+	    qint32,
+	    bImplicitWidth,
+	    100,
+	    &ProxyWindowBase::implicitWidthChanged
+	);
+
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(
+	    ProxyWindowBase,
+	    qint32,
+	    bImplicitHeight,
+	    100,
+	    &ProxyWindowBase::implicitHeightChanged
+	);
+
+private:
+	void polishItems();
+	void updateMask();
+};
+
+class ProxyWindowAttached: public QsWindowAttached {
+	Q_OBJECT;
+
+public:
+	explicit ProxyWindowAttached(QQuickItem* parent);
+
+	[[nodiscard]] QObject* window() const override;
+	[[nodiscard]] ProxyWindowBase* proxyWindow() const override;
+	[[nodiscard]] QQuickItem* contentItem() const override;
+
+protected:
+	void updateWindow() override;
+
+private:
+	ProxyWindowBase* mWindow = nullptr;
+	QObject* mWindowInterface = nullptr;
+
+	void setWindow(ProxyWindowBase* window);
+};
+
+class ProxiedWindow: public QQuickWindow {
+	Q_OBJECT;
+
+public:
+	explicit ProxiedWindow(ProxyWindowBase* proxy, QWindow* parent = nullptr)
+	    : QQuickWindow(parent)
+	    , mProxy(proxy) {}
+
+	[[nodiscard]] ProxyWindowBase* proxy() const { return this->mProxy; }
+	void setProxy(ProxyWindowBase* proxy) { this->mProxy = proxy; }
+
+signals:
+	void exposed();
+	void devicePixelRatioChanged();
+
+protected:
+	bool event(QEvent* event) override;
+	void exposeEvent(QExposeEvent* event) override;
+
+private:
+	ProxyWindowBase* mProxy;
+};
+
+class ProxyWindowContentItem: public QQuickItem {
+	Q_OBJECT;
+
+signals:
+	void polished();
+
+protected:
+	void updatePolish() override;
+};
diff --git a/src/window/test/CMakeLists.txt b/src/window/test/CMakeLists.txt
new file mode 100644
index 00000000..8a0d65cf
--- /dev/null
+++ b/src/window/test/CMakeLists.txt
@@ -0,0 +1,8 @@
+function (qs_test name)
+	add_executable(${name} ${ARGN})
+	target_link_libraries(${name} PRIVATE Qt::Quick Qt::Test quickshell-window quickshell-core quickshell-ui quickshell-io)
+	add_test(NAME ${name} WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" COMMAND $<TARGET_FILE:${name}>)
+endfunction()
+
+qs_test(popupwindow popupwindow.cpp)
+qs_test(windowattached windowattached.cpp)
diff --git a/src/window/test/manual/panel.qml b/src/window/test/manual/panel.qml
new file mode 100644
index 00000000..5c4868c9
--- /dev/null
+++ b/src/window/test/manual/panel.qml
@@ -0,0 +1,151 @@
+import QtQuick
+import QtQuick.Controls
+import QtQuick.Layouts
+import Quickshell
+
+Scope {
+	FloatingWindow {
+		color: contentItem.palette.window
+		minimumSize.width: layout.implicitWidth
+		minimumSize.height: layout.implicitHeight
+
+		ColumnLayout {
+			id: layout
+
+			RowLayout {
+				CheckBox {
+					id: visibleCb
+					text: "Visible"
+					checked: true
+				}
+
+				CheckBox {
+					id: aboveCb
+					text: "Above Windows"
+					checked: true
+				}
+			}
+
+			RowLayout {
+				ColumnLayout {
+					CheckBox {
+						id: leftAnchorCb
+						text: "Left"
+					}
+
+					SpinBox {
+						id: leftMarginSb
+						editable: true
+						value: 0
+						to: 1000
+					}
+				}
+
+				ColumnLayout {
+					CheckBox {
+						id: rightAnchorCb
+						text: "Right"
+					}
+
+					SpinBox {
+						id: rightMarginSb
+						editable: true
+						value: 0
+						to: 1000
+					}
+				}
+
+				ColumnLayout {
+					CheckBox {
+						id: topAnchorCb
+						text: "Top"
+					}
+
+					SpinBox {
+						id: topMarginSb
+						editable: true
+						value: 0
+						to: 1000
+					}
+				}
+
+				ColumnLayout {
+					CheckBox {
+						id: bottomAnchorCb
+						text: "Bottom"
+					}
+
+					SpinBox {
+						id: bottomMarginSb
+						editable: true
+						value: 0
+						to: 1000
+					}
+				}
+			}
+
+			RowLayout {
+				ComboBox {
+					id: exclusiveModeCb
+					model: [ "Normal", "Ignore", "Auto" ]
+					currentIndex: w.exclusionMode
+				}
+
+				SpinBox {
+					id: exclusiveZoneSb
+					editable: true
+					value: 100
+					to: 1000
+				}
+			}
+
+			RowLayout {
+				Label { text: "Width" }
+
+				SpinBox {
+					id: widthSb
+					editable: true
+					value: 100
+					to: 1000
+				}
+			}
+
+			RowLayout {
+				Label { text: "Height" }
+
+				SpinBox {
+					id: heightSb
+					editable: true
+					value: 100
+					to: 1000
+				}
+			}
+		}
+	}
+
+	PanelWindow {
+		id: w
+		visible: visibleCb.checked
+		aboveWindows: aboveCb.checked
+
+		anchors {
+			left: leftAnchorCb.checked
+			right: rightAnchorCb.checked
+			top: topAnchorCb.checked
+			bottom: bottomAnchorCb.checked
+		}
+
+		margins {
+			left: leftMarginSb.value
+			right: rightMarginSb.value
+			top: topMarginSb.value
+			bottom: bottomMarginSb.value
+		}
+
+		exclusionMode: exclusiveModeCb.currentIndex
+		exclusiveZone: exclusiveZoneSb.value
+
+		implicitWidth: widthSb.value
+		implicitHeight: heightSb.value
+	}
+}
diff --git a/src/window/test/popupwindow.cpp b/src/window/test/popupwindow.cpp
new file mode 100644
index 00000000..1262044c
--- /dev/null
+++ b/src/window/test/popupwindow.cpp
@@ -0,0 +1,180 @@
+#include "popupwindow.hpp"
+
+#include <qquickwindow.h>
+#include <qsignalspy.h>
+#include <qtest.h>
+#include <qtestcase.h>
+#include <qwindow.h>
+
+#include "../popupwindow.hpp"
+#include "../proxywindow.hpp"
+
+void TestPopupWindow::initiallyVisible() { // NOLINT
+	auto parent = ProxyWindowBase();
+	auto popup = ProxyPopupWindow();
+
+	popup.setParentWindow(&parent);
+	popup.setVisible(true);
+
+	parent.reload();
+	popup.reload();
+
+	QVERIFY(popup.isVisible());
+	QVERIFY(popup.backingWindow()->isVisible());
+	QCOMPARE(popup.backingWindow()->transientParent(), parent.backingWindow());
+}
+
+void TestPopupWindow::reloadReparent() { // NOLINT
+	// first generation
+	auto parent = ProxyWindowBase();
+	auto popup = ProxyPopupWindow();
+
+	auto* win2 = new QQuickWindow();
+	win2->setVisible(true);
+
+	parent.setVisible(true);
+	popup.setParentWindow(&parent);
+	popup.setVisible(true);
+
+	parent.reload();
+	popup.reload();
+
+	// second generation
+	auto newParent = ProxyWindowBase();
+	auto newPopup = ProxyPopupWindow();
+
+	newPopup.setParentWindow(&newParent);
+	newPopup.setVisible(true);
+
+	auto* oldWindow = popup.backingWindow();
+	auto* oldTransientParent = oldWindow->transientParent();
+
+	auto spy = QSignalSpy(oldWindow, &QWindow::visibleChanged);
+
+	newParent.reload(&parent);
+	newPopup.reload(&popup);
+
+	QVERIFY(newPopup.isVisible());
+	QVERIFY(newPopup.backingWindow()->isVisible());
+	QCOMPARE(newPopup.backingWindow()->transientParent(), oldTransientParent);
+	QCOMPARE(newPopup.backingWindow()->transientParent(), newParent.backingWindow());
+	QCOMPARE(spy.length(), 0);
+}
+
+void TestPopupWindow::reloadUnparent() { // NOLINT
+	// first generation
+	auto parent = ProxyWindowBase();
+	auto popup = ProxyPopupWindow();
+
+	popup.setParentWindow(&parent);
+	popup.setVisible(true);
+
+	parent.reload();
+	popup.reload();
+
+	// second generation
+	auto newPopup = ProxyPopupWindow();
+
+	// parent not set
+	newPopup.setVisible(true);
+	newPopup.reload(&popup);
+
+	QVERIFY(!newPopup.isVisible());
+	QVERIFY(!newPopup.backingWindow()->isVisible());
+	QCOMPARE(newPopup.backingWindow()->transientParent(), nullptr);
+}
+
+void TestPopupWindow::invisibleWithoutParent() { // NOLINT
+	auto popup = ProxyPopupWindow();
+
+	popup.setVisible(true);
+	popup.reload();
+
+	QVERIFY(!popup.isVisible());
+}
+
+void TestPopupWindow::moveWithParent() { // NOLINT
+	auto parent = ProxyWindowBase();
+	auto popup = ProxyPopupWindow();
+
+	popup.setParentWindow(&parent);
+	popup.setRelativeX(10);
+	popup.setRelativeY(10);
+	popup.setVisible(true);
+
+	parent.reload();
+	popup.reload();
+
+	QCOMPARE(popup.x(), parent.x() + 10);
+	QCOMPARE(popup.y(), parent.y() + 10);
+
+	parent.backingWindow()->setX(10);
+	parent.backingWindow()->setY(10);
+
+	QCOMPARE(popup.x(), parent.x() + 10);
+	QCOMPARE(popup.y(), parent.y() + 10);
+}
+
+void TestPopupWindow::attachParentLate() { // NOLINT
+	auto parent = ProxyWindowBase();
+	auto popup = ProxyPopupWindow();
+
+	popup.setVisible(true);
+
+	parent.reload();
+	popup.reload();
+
+	QVERIFY(!popup.isVisible());
+
+	popup.setParentWindow(&parent);
+	QVERIFY(popup.isVisible());
+	QVERIFY(popup.backingWindow()->isVisible());
+	QCOMPARE(popup.backingWindow()->transientParent(), parent.backingWindow());
+}
+
+void TestPopupWindow::reparentLate() { // NOLINT
+	auto parent = ProxyWindowBase();
+	auto popup = ProxyPopupWindow();
+
+	popup.setParentWindow(&parent);
+	popup.setVisible(true);
+
+	parent.reload();
+	popup.reload();
+
+	QCOMPARE(popup.x(), parent.x());
+	QCOMPARE(popup.y(), parent.y());
+
+	auto parent2 = ProxyWindowBase();
+	parent2.reload();
+
+	parent2.backingWindow()->setX(10);
+	parent2.backingWindow()->setY(10);
+
+	popup.setParentWindow(&parent2);
+	QVERIFY(popup.isVisible());
+	QVERIFY(popup.backingWindow()->isVisible());
+	QCOMPARE(popup.backingWindow()->transientParent(), parent2.backingWindow());
+	QCOMPARE(popup.x(), parent2.x());
+	QCOMPARE(popup.y(), parent2.y());
+}
+
+void TestPopupWindow::xMigrationFix() { // NOLINT
+	auto parent = ProxyWindowBase();
+	auto popup = ProxyPopupWindow();
+
+	popup.setParentWindow(&parent);
+	popup.setVisible(true);
+
+	parent.reload();
+	popup.reload();
+
+	QCOMPARE(popup.x(), parent.x());
+
+	popup.setVisible(false);
+	popup.setVisible(true);
+
+	QCOMPARE(popup.x(), parent.x());
+}
+
+QTEST_MAIN(TestPopupWindow);
diff --git a/src/window/test/popupwindow.hpp b/src/window/test/popupwindow.hpp
new file mode 100644
index 00000000..bebc5154
--- /dev/null
+++ b/src/window/test/popupwindow.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+class TestPopupWindow: public QObject {
+	Q_OBJECT;
+
+private slots:
+	void initiallyVisible();
+	void reloadReparent();
+	void reloadUnparent();
+	void invisibleWithoutParent();
+	void moveWithParent();
+	void attachParentLate();
+	void reparentLate();
+	void xMigrationFix();
+};
diff --git a/src/window/test/windowattached.cpp b/src/window/test/windowattached.cpp
new file mode 100644
index 00000000..ef2d47e4
--- /dev/null
+++ b/src/window/test/windowattached.cpp
@@ -0,0 +1,101 @@
+#include "windowattached.hpp"
+
+#include <qobject.h>
+#include <qquickitem.h>
+#include <qscopedpointer.h>
+#include <qsignalspy.h>
+#include <qtest.h>
+#include <qtestcase.h>
+
+#include "../proxywindow.hpp"
+#include "../windowinterface.hpp"
+
+void TestWindowAttachment::attachedAfterReload() {
+	auto window = ProxyWindowBase();
+	auto item = QQuickItem();
+	item.setParentItem(window.contentItem());
+	window.reload(nullptr);
+
+	auto* attached = WindowInterface::qmlAttachedProperties(&item);
+	QCOMPARE_NE(attached, nullptr);
+	QCOMPARE(attached->window(), &window);
+}
+
+void TestWindowAttachment::attachedBeforeReload() {
+	auto window = ProxyWindowBase();
+	auto item = QQuickItem();
+	item.setParentItem(window.contentItem());
+
+	auto* attached = WindowInterface::qmlAttachedProperties(&item);
+	QCOMPARE_NE(attached, nullptr);
+	QCOMPARE(attached->window(), nullptr);
+
+	auto spy = QSignalSpy(attached, &QsWindowAttached::windowChanged);
+	window.reload(nullptr);
+
+	QCOMPARE(attached->window(), &window);
+	QCOMPARE(spy.length(), 1);
+}
+
+void TestWindowAttachment::earlyAttachReloaded() {
+	auto window1 = QScopedPointer(new ProxyWindowBase());
+	auto item1 = QScopedPointer(new QQuickItem());
+	item1->setParentItem(window1->contentItem());
+	window1->reload(nullptr);
+
+	auto window2 = ProxyWindowBase();
+	auto item2 = QQuickItem();
+	item2.setParentItem(window2.contentItem());
+
+	auto* attached = WindowInterface::qmlAttachedProperties(&item2);
+	QCOMPARE_NE(attached, nullptr);
+	QCOMPARE(attached->window(), nullptr);
+
+	auto spy = QSignalSpy(attached, &QsWindowAttached::windowChanged);
+	window2.reload(window1.get());
+
+	QCOMPARE(attached->window(), &window2);
+	QCOMPARE(spy.length(), 1);
+
+	item1.reset();
+	window1.reset();
+
+	QCOMPARE(attached->window(), &window2);
+	QCOMPARE(spy.length(), 1);
+}
+
+void TestWindowAttachment::owningWindowChanged() {
+	auto window1 = ProxyWindowBase();
+	auto window2 = ProxyWindowBase();
+	window1.reload(nullptr);
+	window2.reload(nullptr);
+
+	auto item = QQuickItem();
+	item.setParentItem(window1.contentItem());
+
+	auto* attached = WindowInterface::qmlAttachedProperties(&item);
+	QCOMPARE_NE(attached, nullptr);
+	QCOMPARE(attached->window(), &window1);
+
+	auto spy = QSignalSpy(attached, &QsWindowAttached::windowChanged);
+	item.setParentItem(window2.contentItem());
+	QCOMPARE(attached->window(), &window2);
+	// setParentItem changes the parent to nullptr before the new window.
+	QCOMPARE(spy.length(), 2);
+}
+
+void TestWindowAttachment::nonItemParents() {
+	auto window = ProxyWindowBase();
+
+	auto item = QQuickItem();
+	item.setParentItem(window.contentItem());
+	auto object = QObject(&item);
+
+	window.reload(nullptr);
+
+	auto* attached = WindowInterface::qmlAttachedProperties(&object);
+	QCOMPARE_NE(attached, nullptr);
+	QCOMPARE(attached->window(), &window);
+}
+
+QTEST_MAIN(TestWindowAttachment);
diff --git a/src/window/test/windowattached.hpp b/src/window/test/windowattached.hpp
new file mode 100644
index 00000000..89b3bf76
--- /dev/null
+++ b/src/window/test/windowattached.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+class TestWindowAttachment: public QObject {
+	Q_OBJECT;
+
+private slots:
+	static void attachedAfterReload();
+	static void attachedBeforeReload();
+	static void earlyAttachReloaded();
+	static void owningWindowChanged();
+	static void nonItemParents();
+};
diff --git a/src/window/windowinterface.cpp b/src/window/windowinterface.cpp
new file mode 100644
index 00000000..8917f12d
--- /dev/null
+++ b/src/window/windowinterface.cpp
@@ -0,0 +1,162 @@
+#include "windowinterface.hpp"
+
+#include <qlogging.h>
+#include <qobject.h>
+#include <qqmllist.h>
+#include <qquickitem.h>
+#include <qtypes.h>
+
+#include "../core/qmlscreen.hpp"
+#include "../core/region.hpp"
+#include "proxywindow.hpp"
+
+QPointF WindowInterface::itemPosition(QQuickItem* item) const {
+	return this->proxyWindow()->itemPosition(item);
+}
+
+QRectF WindowInterface::itemRect(QQuickItem* item) const {
+	return this->proxyWindow()->itemRect(item);
+}
+
+QPointF WindowInterface::mapFromItem(QQuickItem* item, QPointF point) const {
+	return this->proxyWindow()->mapFromItem(item, point);
+}
+
+QPointF WindowInterface::mapFromItem(QQuickItem* item, qreal x, qreal y) const {
+	return this->proxyWindow()->mapFromItem(item, x, y);
+}
+
+QRectF WindowInterface::mapFromItem(QQuickItem* item, QRectF rect) const {
+	return this->proxyWindow()->mapFromItem(item, rect);
+}
+
+QRectF
+WindowInterface::mapFromItem(QQuickItem* item, qreal x, qreal y, qreal width, qreal height) const {
+	return this->proxyWindow()->mapFromItem(item, x, y, width, height);
+}
+
+QsWindowAttached::QsWindowAttached(QQuickItem* parent): QObject(parent) {
+	QObject::connect(parent, &QQuickItem::windowChanged, this, &QsWindowAttached::updateWindow);
+}
+
+QPointF QsWindowAttached::itemPosition(QQuickItem* item) const {
+	if (auto* proxyWindow = this->proxyWindow()) {
+		return proxyWindow->itemPosition(item);
+	} else {
+		qCritical() << "Cannot call itemPosition before item is a member of a window.";
+		return {};
+	}
+}
+
+QRectF QsWindowAttached::itemRect(QQuickItem* item) const {
+	if (auto* proxyWindow = this->proxyWindow()) {
+		return proxyWindow->itemRect(item);
+	} else {
+		qCritical() << "Cannot call itemRect before item is a member of a window.";
+		return {};
+	}
+}
+
+QPointF QsWindowAttached::mapFromItem(QQuickItem* item, QPointF point) const {
+	if (auto* proxyWindow = this->proxyWindow()) {
+		return proxyWindow->mapFromItem(item, point);
+	} else {
+		qCritical() << "Cannot call mapFromItem before item is a member of a window.";
+		return {};
+	}
+}
+
+QPointF QsWindowAttached::mapFromItem(QQuickItem* item, qreal x, qreal y) const {
+	if (auto* proxyWindow = this->proxyWindow()) {
+		return proxyWindow->mapFromItem(item, x, y);
+	} else {
+		qCritical() << "Cannot call mapFromItem before item is a member of a window.";
+		return {};
+	}
+}
+
+QRectF QsWindowAttached::mapFromItem(QQuickItem* item, QRectF rect) const {
+	if (auto* proxyWindow = this->proxyWindow()) {
+		return proxyWindow->mapFromItem(item, rect);
+	} else {
+		qCritical() << "Cannot call mapFromItem before item is a member of a window.";
+		return {};
+	}
+}
+
+QRectF
+QsWindowAttached::mapFromItem(QQuickItem* item, qreal x, qreal y, qreal width, qreal height) const {
+	if (auto* proxyWindow = this->proxyWindow()) {
+		return proxyWindow->mapFromItem(item, x, y, width, height);
+	} else {
+		qCritical() << "Cannot call mapFromItem before item is a member of a window.";
+		return {};
+	}
+}
+
+// clang-format off
+QQuickItem* WindowInterface::contentItem() const { return this->proxyWindow()->contentItem(); }
+
+bool WindowInterface::isVisible() const { return this->proxyWindow()->isVisible(); };
+bool WindowInterface::isBackingWindowVisible() const { return this->proxyWindow()->isVisibleDirect(); };
+void WindowInterface::setVisible(bool visible) const { this->proxyWindow()->setVisible(visible); };
+
+qint32 WindowInterface::implicitWidth() const { return this->proxyWindow()->implicitWidth(); };
+void WindowInterface::setImplicitWidth(qint32 implicitWidth) const { this->proxyWindow()->setImplicitWidth(implicitWidth); };
+
+qint32 WindowInterface::implicitHeight() const { return this->proxyWindow()->implicitHeight(); };
+void WindowInterface::setImplicitHeight(qint32 implicitHeight) const { this->proxyWindow()->setImplicitHeight(implicitHeight); };
+
+qint32 WindowInterface::width() const { return this->proxyWindow()->width(); };
+void WindowInterface::setWidth(qint32 width) const { this->proxyWindow()->setWidth(width); };
+
+qint32 WindowInterface::height() const { return this->proxyWindow()->height(); };
+void WindowInterface::setHeight(qint32 height) const { this->proxyWindow()->setHeight(height); };
+
+qreal WindowInterface::devicePixelRatio() const { return this->proxyWindow()->devicePixelRatio(); };
+
+QuickshellScreenInfo* WindowInterface::screen() const { return this->proxyWindow()->screen(); };
+void WindowInterface::setScreen(QuickshellScreenInfo* screen) const { this->proxyWindow()->setScreen(screen); };
+
+QColor WindowInterface::color() const { return this->proxyWindow()->color(); };
+void WindowInterface::setColor(QColor color) const { this->proxyWindow()->setColor(color); };
+
+PendingRegion* WindowInterface::mask() const { return this->proxyWindow()->mask(); };
+void WindowInterface::setMask(PendingRegion* mask) const { this->proxyWindow()->setMask(mask); };
+
+QsSurfaceFormat WindowInterface::surfaceFormat() const { return this->proxyWindow()->surfaceFormat(); };
+void WindowInterface::setSurfaceFormat(QsSurfaceFormat format) const { this->proxyWindow()->setSurfaceFormat(format); };
+
+QQmlListProperty<QObject> WindowInterface::data() const { return this->proxyWindow()->data(); };
+// clang-format on
+
+void WindowInterface::connectSignals() const {
+	auto* window = this->proxyWindow();
+	// clang-format off
+	QObject::connect(window, &ProxyWindowBase::closed, this, &WindowInterface::closed);
+	QObject::connect(window, &ProxyWindowBase::resourcesLost, this, &WindowInterface::resourcesLost);
+	QObject::connect(window, &ProxyWindowBase::windowConnected, this, &WindowInterface::windowConnected);
+	QObject::connect(window, &ProxyWindowBase::visibleChanged, this, &WindowInterface::visibleChanged);
+	QObject::connect(window, &ProxyWindowBase::backerVisibilityChanged, this, &WindowInterface::backingWindowVisibleChanged);
+	QObject::connect(window, &ProxyWindowBase::implicitHeightChanged, this, &WindowInterface::implicitHeightChanged);
+	QObject::connect(window, &ProxyWindowBase::implicitWidthChanged, this, &WindowInterface::implicitWidthChanged);
+	QObject::connect(window, &ProxyWindowBase::heightChanged, this, &WindowInterface::heightChanged);
+	QObject::connect(window, &ProxyWindowBase::widthChanged, this, &WindowInterface::widthChanged);
+	QObject::connect(window, &ProxyWindowBase::devicePixelRatioChanged, this, &WindowInterface::devicePixelRatioChanged);
+	QObject::connect(window, &ProxyWindowBase::screenChanged, this, &WindowInterface::screenChanged);
+	QObject::connect(window, &ProxyWindowBase::windowTransformChanged, this, &WindowInterface::windowTransformChanged);
+	QObject::connect(window, &ProxyWindowBase::colorChanged, this, &WindowInterface::colorChanged);
+	QObject::connect(window, &ProxyWindowBase::maskChanged, this, &WindowInterface::maskChanged);
+	QObject::connect(window, &ProxyWindowBase::surfaceFormatChanged, this, &WindowInterface::surfaceFormatChanged);
+	// clang-format on
+}
+
+QsWindowAttached* WindowInterface::qmlAttachedProperties(QObject* object) {
+	while (object && !qobject_cast<QQuickItem*>(object)) {
+		object = object->parent();
+	}
+
+	if (!object) return nullptr;
+	auto* item = static_cast<QQuickItem*>(object); // NOLINT
+	return new ProxyWindowAttached(item);
+}
diff --git a/src/window/windowinterface.hpp b/src/window/windowinterface.hpp
new file mode 100644
index 00000000..9e917b9f
--- /dev/null
+++ b/src/window/windowinterface.hpp
@@ -0,0 +1,294 @@
+#pragma once
+
+#include <qcolor.h>
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qqmllist.h>
+#include <qquickitem.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../core/qmlscreen.hpp"
+#include "../core/region.hpp"
+#include "../core/reload.hpp"
+
+class ProxyWindowBase;
+class QsWindowAttached;
+
+class QsSurfaceFormat {
+	Q_GADGET;
+	QML_VALUE_TYPE(surfaceFormat);
+	QML_STRUCTURED_VALUE;
+	Q_PROPERTY(bool opaque MEMBER opaque WRITE setOpaque);
+
+public:
+	bool opaque = false;
+	bool opaqueModified = false;
+
+	void setOpaque(bool opaque) {
+		this->opaque = opaque;
+		this->opaqueModified = true;
+	}
+
+	[[nodiscard]] bool operator==(const QsSurfaceFormat& other) const {
+		return other.opaqueModified == this->opaqueModified && other.opaque == this->opaque;
+	}
+};
+
+///! Base class of Quickshell windows
+/// Base class of Quickshell windows
+/// ### Attached properties
+/// `QSWindow` can be used as an attached object of anything that subclasses @@QtQuick.Item$.
+/// It provides the following properties
+/// - `window` - the `QSWindow` object.
+/// - `contentItem` - the `contentItem` property of the window.
+///
+/// @@itemPosition(), @@itemRect(), and @@mapFromItem() can also be called directly
+/// on the attached object.
+class WindowInterface: public Reloadable {
+	Q_OBJECT;
+	// clang-format off
+	Q_PROPERTY(QQuickItem* contentItem READ contentItem CONSTANT);
+	/// If the window should be shown or hidden. Defaults to true.
+	Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged);
+	/// If the window is currently shown. You should generally prefer [visible](#prop.visible).
+	///
+	/// This property is useful for ensuring windows spawn in a specific order, and you should
+	/// not use it in place of [visible](#prop.visible).
+	Q_PROPERTY(bool backingWindowVisible READ isBackingWindowVisible NOTIFY backingWindowVisibleChanged);
+	/// The window's desired width.
+	Q_PROPERTY(qint32 implicitWidth READ implicitWidth WRITE setImplicitWidth NOTIFY implicitWidthChanged);
+	/// The window's desired height.
+	Q_PROPERTY(qint32 implicitHeight READ implicitHeight WRITE setImplicitHeight NOTIFY implicitHeightChanged);
+	/// The window's actual width.
+	///
+	/// Setting this property is deprecated. Set @@implicitWidth instead.
+	Q_PROPERTY(qint32 width READ width WRITE setWidth NOTIFY widthChanged);
+	/// The window's actual height.
+	///
+	/// Setting this property is deprecated. Set @@implicitHeight instead.
+	Q_PROPERTY(qint32 height READ height WRITE setHeight NOTIFY heightChanged);
+	/// The ratio between logical pixels and monitor pixels.
+	///
+	/// Qt's coordinate system works in logical pixels, which equal N monitor pixels
+	/// depending on scale factor. This property returns the amount of monitor pixels
+	/// in a logical pixel for the current window.
+	Q_PROPERTY(qreal devicePixelRatio READ devicePixelRatio NOTIFY devicePixelRatioChanged);
+	/// The screen that the window currently occupies.
+	///
+	/// This may be modified to move the window to the given screen.
+	Q_PROPERTY(QuickshellScreenInfo* screen READ screen WRITE setScreen NOTIFY screenChanged);
+	/// Opaque property that will receive an update when factors that affect the window's position
+	/// and transform changed.
+	///
+	/// This property is intended to be used to force a binding update,
+	/// along with map[To|From]Item (which is not reactive).
+	Q_PROPERTY(QObject* windowTransform READ windowTransform NOTIFY windowTransformChanged);
+	/// The background color of the window. Defaults to white.
+	///
+	/// > [!WARNING] If the window color is opaque before it is made visible,
+	/// > it will not be able to become transparent later unless @@surfaceFormat$.opaque
+	/// > is false.
+	Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged);
+	/// The clickthrough mask. Defaults to null.
+	///
+	/// If non null then the clickable areas of the window will be determined by the provided region.
+	///
+	/// ```qml
+	/// ShellWindow {
+	///   // The mask region is set to `rect`, meaning only `rect` is clickable.
+	///   // All other clicks pass through the window to ones behind it.
+	///   mask: Region { item: rect }
+	///
+	///   Rectangle {
+	///     id: rect
+	///
+	///     anchors.centerIn: parent
+	///     width: 100
+	///     height: 100
+	///   }
+	/// }
+	/// ```
+	///
+	/// If the provided region's intersection mode is `Combine` (the default),
+	/// then the region will be used as is. Otherwise it will be applied on top of the window region.
+	///
+	/// For example, setting the intersection mode to `Xor` will invert the mask and make everything in
+	/// the mask region not clickable and pass through clicks inside it through the window.
+	///
+	/// ```qml
+	/// ShellWindow {
+	///   // The mask region is set to `rect`, but the intersection mode is set to `Xor`.
+	///   // This inverts the mask causing all clicks inside `rect` to be passed to the window
+	///   // behind this one.
+	///   mask: Region { item: rect; intersection: Intersection.Xor }
+	///
+	///   Rectangle {
+	///     id: rect
+	///
+	///     anchors.centerIn: parent
+	///     width: 100
+	///     height: 100
+	///   }
+	/// }
+	/// ```
+	Q_PROPERTY(PendingRegion* mask READ mask WRITE setMask NOTIFY maskChanged);
+	/// Set the surface format to request from the system.
+	///
+	/// - `opaque` - If the requested surface should be opaque. Opaque windows allow
+	/// the operating system to avoid drawing things behind them, or blending the window
+	/// with those behind it, saving power and GPU load. If unset, this property defaults to
+	/// true if @@color is opaque, or false if not. *You should not need to modify this
+	/// property unless you create a surface that starts opaque and later becomes transparent.*
+	///
+	/// > [!NOTE] The surface format cannot be changed after the window is created.
+	Q_PROPERTY(QsSurfaceFormat surfaceFormat READ surfaceFormat WRITE setSurfaceFormat NOTIFY surfaceFormatChanged);
+	Q_PROPERTY(QQmlListProperty<QObject> data READ data);
+	// clang-format on
+	Q_CLASSINFO("DefaultProperty", "data");
+	QML_NAMED_ELEMENT(QsWindow);
+	QML_UNCREATABLE("uncreatable base class");
+	QML_ATTACHED(QsWindowAttached);
+
+public:
+	explicit WindowInterface(QObject* parent = nullptr): Reloadable(parent) {}
+
+	/// Returns the given Item's position relative to the window. Does not update reactively.
+	///
+	/// Equivalent to calling `window.contentItem.mapFromItem(item, 0, 0)`
+	///
+	/// See also: @@QtQuick.Item.mapFromItem()
+	Q_INVOKABLE [[nodiscard]] QPointF itemPosition(QQuickItem* item) const;
+	/// Returns the given Item's geometry relative to the window. Does not update reactively.
+	///
+	/// Equivalent to calling `window.contentItem.mapFromItem(item, 0, 0, 0, 0)`
+	///
+	/// See also: @@QtQuick.Item.mapFromItem()
+	Q_INVOKABLE [[nodiscard]] QRectF itemRect(QQuickItem* item) const;
+	/// Maps the given point in the coordinate space of `item` to one in the coordinate space
+	/// of this window. Does not update reactively.
+	///
+	/// Equivalent to calling `window.contentItem.mapFromItem(item, point)`
+	///
+	/// See also: @@QtQuick.Item.mapFromItem()
+	Q_INVOKABLE [[nodiscard]] QPointF mapFromItem(QQuickItem* item, QPointF point) const;
+	/// Maps the given point in the coordinate space of `item` to one in the coordinate space
+	/// of this window. Does not update reactively.
+	///
+	/// Equivalent to calling `window.contentItem.mapFromItem(item, x, y)`
+	///
+	/// See also: @@QtQuick.Item.mapFromItem()
+	Q_INVOKABLE [[nodiscard]] QPointF mapFromItem(QQuickItem* item, qreal x, qreal y) const;
+	/// Maps the given rect in the coordinate space of `item` to one in the coordinate space
+	/// of this window. Does not update reactively.
+	///
+	/// Equivalent to calling `window.contentItem.mapFromItem(item, rect)`
+	///
+	/// See also: @@QtQuick.Item.mapFromItem()
+	Q_INVOKABLE [[nodiscard]] QRectF mapFromItem(QQuickItem* item, QRectF rect) const;
+	// clang-format off
+	/// Maps the given rect in the coordinate space of `item` to one in the coordinate space
+	/// of this window. Does not update reactively.
+	///
+	/// Equivalent to calling `window.contentItem.mapFromItem(item, x, y, width, height)`
+	///
+	/// See also: @@QtQuick.Item.mapFromItem()
+	Q_INVOKABLE [[nodiscard]] QRectF mapFromItem(QQuickItem* item, qreal x, qreal y, qreal width, qreal height) const;
+	// clang-format on
+
+	[[nodiscard]] virtual ProxyWindowBase* proxyWindow() const = 0;
+	[[nodiscard]] QQuickItem* contentItem() const;
+
+	[[nodiscard]] bool isVisible() const;
+	[[nodiscard]] bool isBackingWindowVisible() const;
+	void setVisible(bool visible) const;
+
+	[[nodiscard]] qint32 implicitWidth() const;
+	void setImplicitWidth(qint32 implicitWidth) const;
+
+	[[nodiscard]] qint32 implicitHeight() const;
+	void setImplicitHeight(qint32 implicitHeight) const;
+
+	[[nodiscard]] qint32 width() const;
+	void setWidth(qint32 width) const;
+
+	[[nodiscard]] qint32 height() const;
+	void setHeight(qint32 height) const;
+
+	[[nodiscard]] qreal devicePixelRatio() const;
+
+	[[nodiscard]] QuickshellScreenInfo* screen() const;
+	void setScreen(QuickshellScreenInfo* screen) const;
+
+	[[nodiscard]] QObject* windowTransform() const { return nullptr; } // NOLINT
+
+	[[nodiscard]] QColor color() const;
+	void setColor(QColor color) const;
+
+	[[nodiscard]] PendingRegion* mask() const;
+	void setMask(PendingRegion* mask) const;
+
+	[[nodiscard]] QsSurfaceFormat surfaceFormat() const;
+	void setSurfaceFormat(QsSurfaceFormat format) const;
+
+	[[nodiscard]] QQmlListProperty<QObject> data() const;
+
+	static QsWindowAttached* qmlAttachedProperties(QObject* object);
+
+signals:
+	/// This signal is emitted when the window is closed by the user, the display server,
+	/// or an error. It is not emitted when @@visible is set to false.
+	void closed();
+	/// This signal is emitted when resources a window depends on to display are lost,
+	/// or could not be acquired during window creation. The most common trigger for
+	/// this signal is a lack of VRAM when creating or resizing a window.
+	///
+	/// Following this signal, @@closed(s) will be sent.
+	void resourcesLost();
+	void windowConnected();
+	void visibleChanged();
+	void backingWindowVisibleChanged();
+	void implicitWidthChanged();
+	void implicitHeightChanged();
+	void widthChanged();
+	void heightChanged();
+	void devicePixelRatioChanged();
+	void screenChanged();
+	void windowTransformChanged();
+	void colorChanged();
+	void maskChanged();
+	void surfaceFormatChanged();
+
+protected:
+	void connectSignals() const;
+};
+
+class QsWindowAttached: public QObject {
+	Q_OBJECT;
+	Q_PROPERTY(QObject* window READ window NOTIFY windowChanged);
+	Q_PROPERTY(QQuickItem* contentItem READ contentItem NOTIFY windowChanged);
+	QML_ANONYMOUS;
+
+public:
+	[[nodiscard]] virtual QObject* window() const = 0;
+	[[nodiscard]] virtual ProxyWindowBase* proxyWindow() const = 0;
+	[[nodiscard]] virtual QQuickItem* contentItem() const = 0;
+
+	Q_INVOKABLE [[nodiscard]] QPointF itemPosition(QQuickItem* item) const;
+	Q_INVOKABLE [[nodiscard]] QRectF itemRect(QQuickItem* item) const;
+	Q_INVOKABLE [[nodiscard]] QPointF mapFromItem(QQuickItem* item, QPointF point) const;
+	Q_INVOKABLE [[nodiscard]] QPointF mapFromItem(QQuickItem* item, qreal x, qreal y) const;
+	Q_INVOKABLE [[nodiscard]] QRectF mapFromItem(QQuickItem* item, QRectF rect) const;
+
+	Q_INVOKABLE [[nodiscard]] QRectF
+	mapFromItem(QQuickItem* item, qreal x, qreal y, qreal width, qreal height) const;
+
+signals:
+	void windowChanged();
+
+protected slots:
+	virtual void updateWindow() = 0;
+
+protected:
+	explicit QsWindowAttached(QQuickItem* parent);
+};
diff --git a/src/x11/CMakeLists.txt b/src/x11/CMakeLists.txt
new file mode 100644
index 00000000..2a085d94
--- /dev/null
+++ b/src/x11/CMakeLists.txt
@@ -0,0 +1,27 @@
+find_package(XCB REQUIRED COMPONENTS XCB)
+
+qt_add_library(quickshell-x11 STATIC
+	util.cpp
+	panel_window.cpp
+)
+
+qt_add_qml_module(quickshell-x11
+	URI Quickshell.X11
+	VERSION 0.1
+	DEPENDENCIES QtQuick
+)
+
+if(I3)
+	add_subdirectory(i3)
+endif()
+
+install_qml_module(quickshell-x11)
+
+add_library(quickshell-x11-init OBJECT init.cpp)
+
+target_link_libraries(quickshell-x11 PRIVATE Qt::Quick ${XCB_LIBRARIES})
+target_link_libraries(quickshell-x11-init PRIVATE Qt::Quick Qt::Qml ${XCB_LIBRARIES})
+
+qs_module_pch(quickshell-x11 SET large)
+
+target_link_libraries(quickshell PRIVATE quickshell-x11plugin quickshell-x11-init)
diff --git a/src/x11/i3/CMakeLists.txt b/src/x11/i3/CMakeLists.txt
new file mode 100644
index 00000000..4a7b99c3
--- /dev/null
+++ b/src/x11/i3/CMakeLists.txt
@@ -0,0 +1,23 @@
+qt_add_library(quickshell-i3 STATIC)
+
+target_link_libraries(quickshell-i3 PRIVATE ${QT_DEPS})
+
+set(I3_MODULES)
+
+if (I3_IPC)
+	add_subdirectory(ipc)
+	list(APPEND I3_MODULES Quickshell.I3._Ipc)
+endif()
+
+qt_add_qml_module(quickshell-i3
+	URI Quickshell.I3
+	VERSION 0.1
+	IMPORTS ${I3_MODULES}
+)
+
+install_qml_module(quickshell-i3)
+
+qs_pch(quickshell-i3)
+qs_pch(quickshell-i3plugin)
+
+target_link_libraries(quickshell PRIVATE quickshell-i3plugin)
diff --git a/src/x11/i3/ipc/CMakeLists.txt b/src/x11/i3/ipc/CMakeLists.txt
new file mode 100644
index 00000000..27a44841
--- /dev/null
+++ b/src/x11/i3/ipc/CMakeLists.txt
@@ -0,0 +1,22 @@
+qt_add_library(quickshell-i3-ipc STATIC
+	connection.cpp
+	qml.cpp
+	workspace.cpp
+	monitor.cpp
+)
+
+qt_add_qml_module(quickshell-i3-ipc
+	URI Quickshell.I3._Ipc
+	VERSION 0.1
+	DEPENDENCIES QtQml
+)
+
+qs_add_module_deps_light(quickshell-i3-ipc Quickshell)
+
+install_qml_module(quickshell-i3-ipc)
+
+target_link_libraries(quickshell-i3-ipc PRIVATE Qt::Quick)
+
+qs_module_pch(quickshell-i3-ipc SET large)
+
+target_link_libraries(quickshell PRIVATE quickshell-i3-ipcplugin)
diff --git a/src/x11/i3/ipc/connection.cpp b/src/x11/i3/ipc/connection.cpp
new file mode 100644
index 00000000..ba010ed3
--- /dev/null
+++ b/src/x11/i3/ipc/connection.cpp
@@ -0,0 +1,539 @@
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <tuple>
+
+#include <bit>
+#include <qbytearray.h>
+#include <qbytearrayview.h>
+#include <qcontainerfwd.h>
+#include <qdatastream.h>
+#include <qjsonarray.h>
+#include <qjsondocument.h>
+#include <qjsonobject.h>
+#include <qjsonvalue.h>
+#include <qlocalsocket.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qsysinfo.h>
+#include <qtenvironmentvariables.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../../core/logcat.hpp"
+#include "../../../core/model.hpp"
+#include "../../../core/qmlscreen.hpp"
+#include "connection.hpp"
+#include "monitor.hpp"
+#include "workspace.hpp"
+
+namespace qs::i3::ipc {
+
+namespace {
+QS_LOGGING_CATEGORY(logI3Ipc, "quickshell.I3.ipc", QtWarningMsg);
+QS_LOGGING_CATEGORY(logI3IpcEvents, "quickshell.I3.ipc.events", QtWarningMsg);
+} // namespace
+
+void I3Ipc::makeRequest(const QByteArray& request) {
+	if (!this->valid) {
+		qCWarning(logI3IpcEvents) << "IPC connection is not open, ignoring request.";
+		return;
+	}
+	this->liveEventSocket.write(request);
+	this->liveEventSocket.flush();
+}
+
+void I3Ipc::dispatch(const QString& payload) {
+	auto message = I3Ipc::buildRequestMessage(EventCode::RunCommand, payload.toLocal8Bit());
+
+	this->makeRequest(message);
+}
+
+QByteArray I3Ipc::buildRequestMessage(EventCode cmd, const QByteArray& payload) {
+	auto payloadLength = static_cast<quint32>(payload.length());
+
+	auto type = QByteArray(std::bit_cast<std::array<char, 4>>(cmd).data(), 4);
+	auto len = QByteArray(std::bit_cast<std::array<char, 4>>(payloadLength).data(), 4);
+
+	return MAGIC.data() + len + type + payload;
+}
+
+I3Ipc::I3Ipc() {
+	auto sock = qEnvironmentVariable("I3SOCK");
+
+	if (sock.isEmpty()) {
+		qCWarning(logI3Ipc) << "$I3SOCK is unset. Trying $SWAYSOCK.";
+
+		sock = qEnvironmentVariable("SWAYSOCK");
+
+		if (sock.isEmpty()) {
+			qCWarning(logI3Ipc) << "$SWAYSOCK and I3SOCK are unset. Cannot connect to socket.";
+			return;
+		}
+	}
+
+	this->bFocusedWorkspace.setBinding([this]() -> I3Workspace* {
+		if (!this->bFocusedMonitor) return nullptr;
+		return this->bFocusedMonitor->bindableActiveWorkspace().value();
+	});
+
+	this->mSocketPath = sock;
+
+	// clang-format off
+	QObject::connect(&this->liveEventSocket, &QLocalSocket::errorOccurred, this, &I3Ipc::eventSocketError);
+	QObject::connect(&this->liveEventSocket, &QLocalSocket::stateChanged, this, &I3Ipc::eventSocketStateChanged);
+	QObject::connect(&this->liveEventSocket, &QLocalSocket::readyRead, this, &I3Ipc::eventSocketReady);
+	QObject::connect(&this->liveEventSocket, &QLocalSocket::connected, this, &I3Ipc::subscribe);
+	// clang-format on
+
+	this->liveEventSocketDs.setDevice(&this->liveEventSocket);
+	this->liveEventSocketDs.setByteOrder(static_cast<QDataStream::ByteOrder>(QSysInfo::ByteOrder));
+
+	this->liveEventSocket.connectToServer(this->mSocketPath);
+}
+
+void I3Ipc::subscribe() {
+	auto payload = QByteArray(R"(["workspace","output"])");
+	auto message = I3Ipc::buildRequestMessage(EventCode::Subscribe, payload);
+
+	this->makeRequest(message);
+
+	// Workspaces must be refreshed before monitors or no focus will be
+	// detected on launch.
+	this->refreshWorkspaces();
+	this->refreshMonitors();
+}
+
+void I3Ipc::eventSocketReady() {
+	for (auto& [type, data]: this->parseResponse()) {
+		this->event.mCode = type;
+		this->event.mData = data;
+
+		this->onEvent(&this->event);
+		emit this->rawEvent(&this->event);
+	}
+}
+
+void I3Ipc::reconnectIPC() {
+	qCWarning(logI3Ipc) << "Fatal IPC error occured, recreating connection";
+	this->liveEventSocket.disconnectFromServer();
+	this->liveEventSocket.connectToServer(this->mSocketPath);
+}
+
+QVector<Event> I3Ipc::parseResponse() {
+	QVector<std::tuple<EventCode, QJsonDocument>> events;
+	const int magicLen = 6;
+
+	while (!this->liveEventSocketDs.atEnd()) {
+		this->liveEventSocketDs.startTransaction();
+		this->liveEventSocketDs.startTransaction();
+
+		std::array<char, 6> buffer = {};
+		qint32 size = 0;
+		qint32 type = EventCode::Unknown;
+
+		this->liveEventSocketDs.readRawData(buffer.data(), magicLen);
+		this->liveEventSocketDs >> size;
+		this->liveEventSocketDs >> type;
+
+		if (!this->liveEventSocketDs.commitTransaction()) break;
+
+		QByteArray payload(size, Qt::Uninitialized);
+
+		this->liveEventSocketDs.readRawData(payload.data(), size);
+
+		if (!this->liveEventSocketDs.commitTransaction()) break;
+
+		if (strncmp(buffer.data(), MAGIC.data(), 6) != 0) {
+			qCWarning(logI3Ipc) << "No magic sequence found in string.";
+			this->reconnectIPC();
+			break;
+		};
+
+		if (I3IpcEvent::intToEvent(type) == EventCode::Unknown) {
+			qCWarning(logI3Ipc) << "Received unknown event";
+			break;
+		}
+
+		// Importing this makes CI builds fail for some reason.
+		QJsonParseError e; // NOLINT (misc-include-cleaner)
+
+		auto data = QJsonDocument::fromJson(payload, &e);
+		if (e.error != QJsonParseError::NoError) {
+			qCWarning(logI3Ipc) << "Invalid JSON value:" << e.errorString();
+			break;
+		} else {
+			events.push_back(std::tuple(I3IpcEvent::intToEvent(type), data));
+		}
+	}
+
+	return events;
+}
+
+void I3Ipc::eventSocketError(QLocalSocket::LocalSocketError error) const {
+	if (!this->valid) {
+		qCWarning(logI3Ipc) << "Unable to connect to I3 socket:" << error;
+	} else {
+		qCWarning(logI3Ipc) << "I3 socket error:" << error;
+	}
+}
+
+void I3Ipc::eventSocketStateChanged(QLocalSocket::LocalSocketState state) {
+	if (state == QLocalSocket::ConnectedState) {
+		qCInfo(logI3Ipc) << "I3 event socket connected.";
+		emit this->connected();
+	} else if (state == QLocalSocket::UnconnectedState && this->valid) {
+		qCWarning(logI3Ipc) << "I3 event socket disconnected.";
+	}
+
+	this->valid = state == QLocalSocket::ConnectedState;
+}
+
+QString I3Ipc::socketPath() const { return this->mSocketPath; }
+
+void I3Ipc::setFocusedMonitor(I3Monitor* monitor) {
+	auto* oldMonitor = this->bFocusedMonitor.value();
+	if (monitor == oldMonitor) return;
+
+	if (oldMonitor != nullptr) {
+		QObject::disconnect(oldMonitor, nullptr, this, nullptr);
+	}
+
+	if (monitor != nullptr) {
+		QObject::connect(monitor, &QObject::destroyed, this, &I3Ipc::onFocusedMonitorDestroyed);
+	}
+
+	this->bFocusedMonitor = monitor;
+}
+
+void I3Ipc::onFocusedMonitorDestroyed() { this->bFocusedMonitor = nullptr; }
+
+I3Ipc* I3Ipc::instance() {
+	static I3Ipc* instance = nullptr; // NOLINT
+
+	if (instance == nullptr) {
+		instance = new I3Ipc();
+	}
+
+	return instance;
+}
+
+void I3Ipc::refreshWorkspaces() {
+	this->makeRequest(I3Ipc::buildRequestMessage(EventCode::GetWorkspaces));
+}
+
+void I3Ipc::handleGetWorkspacesEvent(I3IpcEvent* event) {
+	auto data = event->mData;
+
+	auto workspaces = data.array();
+
+	const auto& mList = this->mWorkspaces.valueList();
+	auto names = QVector<QString>();
+
+	qCDebug(logI3Ipc) << "There are" << workspaces.toVariantList().length() << "workspaces";
+	for (auto entry: workspaces) {
+		auto object = entry.toObject().toVariantMap();
+		auto name = object["name"].toString();
+
+		auto workspaceIter = std::ranges::find_if(mList, [name](I3Workspace* m) {
+			return m->bindableName().value() == name;
+		});
+
+		auto* workspace = workspaceIter == mList.end() ? nullptr : *workspaceIter;
+		auto existed = workspace != nullptr;
+
+		if (workspace == nullptr) {
+			workspace = new I3Workspace(this);
+		}
+
+		workspace->updateFromObject(object);
+
+		if (!existed) {
+			this->mWorkspaces.insertObjectSorted(workspace, &I3Ipc::compareWorkspaces);
+		}
+
+		if (!this->bFocusedWorkspace && object.value("focused").value<bool>()) {
+			this->bFocusedMonitor = workspace->bindableMonitor().value();
+		}
+
+		names.push_back(name);
+	}
+
+	auto removedWorkspaces = QVector<I3Workspace*>();
+
+	for (auto* workspace: mList) {
+		if (!names.contains(workspace->bindableName().value())) {
+			removedWorkspaces.push_back(workspace);
+		}
+	}
+
+	qCDebug(logI3Ipc) << "Removing" << removedWorkspaces.length() << "deleted workspaces.";
+
+	for (auto* workspace: removedWorkspaces) {
+		this->mWorkspaces.removeObject(workspace);
+		delete workspace;
+	}
+}
+
+void I3Ipc::refreshMonitors() {
+	this->makeRequest(I3Ipc::buildRequestMessage(EventCode::GetOutputs));
+}
+
+void I3Ipc::handleGetOutputsEvent(I3IpcEvent* event) {
+	auto data = event->mData;
+
+	auto monitors = data.array();
+	const auto& mList = this->mMonitors.valueList();
+	auto names = QVector<QString>();
+
+	qCDebug(logI3Ipc) << "There are" << monitors.toVariantList().length() << "monitors";
+
+	for (auto elem: monitors) {
+		auto object = elem.toObject().toVariantMap();
+		auto name = object["name"].toString();
+
+		auto monitorIter = std::ranges::find_if(mList, [name](I3Monitor* m) {
+			return m->bindableName().value() == name;
+		});
+
+		auto* monitor = monitorIter == mList.end() ? nullptr : *monitorIter;
+		auto existed = monitor != nullptr;
+
+		if (monitor == nullptr) {
+			monitor = new I3Monitor(this);
+		}
+
+		monitor->updateFromObject(object);
+
+		if (monitor->bindableFocused().value()) {
+			this->setFocusedMonitor(monitor);
+		}
+
+		if (!existed) {
+			this->mMonitors.insertObject(monitor);
+		}
+
+		names.push_back(name);
+	}
+
+	auto removedMonitors = QVector<I3Monitor*>();
+
+	for (auto* monitor: mList) {
+		if (!names.contains(monitor->bindableName().value())) {
+			removedMonitors.push_back(monitor);
+		}
+	}
+
+	qCDebug(logI3Ipc) << "Removing" << removedMonitors.length() << "disconnected monitors.";
+
+	for (auto* monitor: removedMonitors) {
+		this->mMonitors.removeObject(monitor);
+		delete monitor;
+	}
+}
+
+void I3Ipc::onEvent(I3IpcEvent* event) {
+	switch (event->mCode) {
+	case EventCode::Workspace: this->handleWorkspaceEvent(event); return;
+	case EventCode::Output:
+		/// I3 only sends an "unspecified" event, so we have to query the data changes ourselves
+		qCInfo(logI3Ipc) << "Refreshing Monitors...";
+		this->refreshMonitors();
+		return;
+	case EventCode::Subscribe: qCInfo(logI3Ipc) << "Connected to IPC"; return;
+	case EventCode::GetOutputs: this->handleGetOutputsEvent(event); return;
+	case EventCode::GetWorkspaces: this->handleGetWorkspacesEvent(event); return;
+	case EventCode::RunCommand: I3Ipc::handleRunCommand(event); return;
+	case EventCode::Unknown:
+		qCWarning(logI3Ipc) << "Unknown event:" << event->type() << event->data();
+		return;
+	default: qCWarning(logI3Ipc) << "Unhandled event:" << event->type();
+	}
+}
+
+void I3Ipc::handleRunCommand(I3IpcEvent* event) {
+	for (auto r: event->mData.array()) {
+		auto obj = r.toObject();
+		const bool success = obj["success"].toBool();
+
+		if (!success) {
+			const QString error = obj["error"].toString();
+			qCWarning(logI3Ipc) << "Error occured while running command:" << error;
+		}
+	}
+}
+
+void I3Ipc::handleWorkspaceEvent(I3IpcEvent* event) {
+	// If a workspace doesn't exist, and is being switch to, no focus change event is emited,
+	// only the init one, which does not contain the previously focused workspace
+	auto change = event->mData["change"];
+
+	if (change == "init") {
+		qCInfo(logI3IpcEvents) << "New workspace has been created";
+
+		auto workspaceData = event->mData["current"];
+
+		auto* workspace = this->findWorkspaceByID(workspaceData["id"].toInt(-1));
+		auto existed = workspace != nullptr;
+
+		if (!existed) {
+			workspace = new I3Workspace(this);
+		}
+
+		if (workspaceData.isObject()) {
+			workspace->updateFromObject(workspaceData.toObject().toVariantMap());
+		}
+
+		if (!existed) {
+			this->mWorkspaces.insertObjectSorted(workspace, &I3Ipc::compareWorkspaces);
+			qCInfo(logI3Ipc) << "Added workspace" << workspace->bindableName().value() << "to list";
+		}
+	} else if (change == "focus") {
+		auto oldData = event->mData["old"];
+		auto newData = event->mData["current"];
+		auto oldName = oldData["name"].toString();
+		auto newName = newData["name"].toString();
+
+		qCInfo(logI3IpcEvents) << "Focus changed: " << oldName << "->" << newName;
+
+		if (auto* oldWorkspace = this->findWorkspaceByName(oldName)) {
+			oldWorkspace->updateFromObject(oldData.toObject().toVariantMap());
+		}
+
+		auto* newWorkspace = this->findWorkspaceByName(newName);
+
+		if (newWorkspace == nullptr) {
+			newWorkspace = new I3Workspace(this);
+		}
+
+		newWorkspace->updateFromObject(newData.toObject().toVariantMap());
+
+		if (newWorkspace->bindableMonitor().value()) {
+			auto* monitor = newWorkspace->bindableMonitor().value();
+			monitor->setFocusedWorkspace(newWorkspace);
+			this->bFocusedMonitor = monitor;
+		}
+	} else if (change == "empty") {
+		auto name = event->mData["current"]["name"].toString();
+
+		auto* oldWorkspace = this->findWorkspaceByName(name);
+
+		if (oldWorkspace != nullptr) {
+			qCInfo(logI3Ipc) << "Deleting" << oldWorkspace->bindableId().value() << name;
+
+			if (this->bFocusedWorkspace == oldWorkspace) {
+				this->bFocusedMonitor->setFocusedWorkspace(nullptr);
+			}
+
+			this->workspaces()->removeObject(oldWorkspace);
+
+			delete oldWorkspace;
+		} else {
+			qCInfo(logI3Ipc) << "Workspace" << name << "has already been deleted";
+		}
+	} else if (change == "move" || change == "rename" || change == "urgent") {
+		auto name = event->mData["current"]["name"].toString();
+
+		auto* workspace = this->findWorkspaceByName(name);
+
+		if (workspace != nullptr) {
+			auto data = event->mData["current"].toObject().toVariantMap();
+
+			workspace->updateFromObject(data);
+		} else {
+			qCWarning(logI3Ipc) << "Workspace" << name << "doesn't exist";
+		}
+	} else if (change == "reload") {
+		qCInfo(logI3Ipc) << "Refreshing Workspaces...";
+		this->refreshWorkspaces();
+	}
+}
+
+I3Monitor* I3Ipc::monitorFor(QuickshellScreenInfo* screen) {
+	if (screen == nullptr) return nullptr;
+
+	return this->findMonitorByName(screen->name());
+}
+
+I3Workspace* I3Ipc::findWorkspaceByID(qint32 id) {
+	auto list = this->mWorkspaces.valueList();
+	auto workspaceIter =
+	    std::ranges::find_if(list, [id](I3Workspace* m) { return m->bindableId().value() == id; });
+
+	return workspaceIter == list.end() ? nullptr : *workspaceIter;
+}
+
+I3Workspace* I3Ipc::findWorkspaceByName(const QString& name) {
+	auto list = this->mWorkspaces.valueList();
+	auto workspaceIter = std::ranges::find_if(list, [name](I3Workspace* m) {
+		return m->bindableName().value() == name;
+	});
+
+	return workspaceIter == list.end() ? nullptr : *workspaceIter;
+}
+
+I3Monitor* I3Ipc::findMonitorByName(const QString& name, bool createIfMissing) {
+	auto list = this->mMonitors.valueList();
+	auto monitorIter = std::ranges::find_if(list, [name](I3Monitor* m) {
+		return m->bindableName().value() == name;
+	});
+
+	if (monitorIter != list.end()) {
+		return *monitorIter;
+	} else if (createIfMissing) {
+		qCDebug(logI3Ipc) << "Monitor" << name << "requested before creation, performing early init";
+		auto* monitor = new I3Monitor(this);
+		monitor->updateInitial(name);
+		this->mMonitors.insertObject(monitor);
+		return monitor;
+	} else {
+		return nullptr;
+	}
+}
+
+ObjectModel<I3Monitor>* I3Ipc::monitors() { return &this->mMonitors; }
+ObjectModel<I3Workspace>* I3Ipc::workspaces() { return &this->mWorkspaces; }
+
+bool I3Ipc::compareWorkspaces(I3Workspace* a, I3Workspace* b) {
+	return a->bindableNumber().value() > b->bindableNumber().value();
+}
+
+QString I3IpcEvent::type() const { return I3IpcEvent::eventToString(this->mCode); }
+QString I3IpcEvent::data() const { return QString::fromUtf8(this->mData.toJson()); }
+
+EventCode I3IpcEvent::intToEvent(quint32 raw) {
+	if ((EventCode::Workspace <= raw && raw <= EventCode::Input)
+	    || (EventCode::RunCommand <= raw && raw <= EventCode::GetTree))
+	{
+		return static_cast<EventCode>(raw);
+	} else {
+		return EventCode::Unknown;
+	}
+}
+
+QString I3IpcEvent::eventToString(EventCode event) {
+	switch (event) {
+	case EventCode::RunCommand: return "run_command"; break;
+	case EventCode::GetWorkspaces: return "get_workspaces"; break;
+	case EventCode::Subscribe: return "subscribe"; break;
+	case EventCode::GetOutputs: return "get_outputs"; break;
+	case EventCode::GetTree: return "get_tree"; break;
+
+	case EventCode::Output: return "output"; break;
+	case EventCode::Workspace: return "workspace"; break;
+	case EventCode::Mode: return "mode"; break;
+	case EventCode::Window: return "window"; break;
+	case EventCode::BarconfigUpdate: return "barconfig_update"; break;
+	case EventCode::Binding: return "binding"; break;
+	case EventCode::Shutdown: return "shutdown"; break;
+	case EventCode::Tick: return "tick"; break;
+	case EventCode::BarStateUpdate: return "bar_state_update"; break;
+	case EventCode::Input: return "input"; break;
+
+	case EventCode::Unknown: return "unknown"; break;
+	}
+}
+
+} // namespace qs::i3::ipc
diff --git a/src/x11/i3/ipc/connection.hpp b/src/x11/i3/ipc/connection.hpp
new file mode 100644
index 00000000..af480c55
--- /dev/null
+++ b/src/x11/i3/ipc/connection.hpp
@@ -0,0 +1,164 @@
+#pragma once
+
+#include <qbytearrayview.h>
+#include <qjsondocument.h>
+#include <qjsonobject.h>
+#include <qlocalsocket.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqml.h>
+#include <qqmlintegration.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "../../../core/model.hpp"
+#include "../../../core/qmlscreen.hpp"
+
+namespace qs::i3::ipc {
+
+class I3Workspace;
+class I3Monitor;
+} // namespace qs::i3::ipc
+
+Q_DECLARE_OPAQUE_POINTER(qs::i3::ipc::I3Workspace*);
+Q_DECLARE_OPAQUE_POINTER(qs::i3::ipc::I3Monitor*);
+
+namespace qs::i3::ipc {
+
+constexpr std::string MAGIC = "i3-ipc";
+
+enum EventCode {
+	RunCommand = 0,
+	GetWorkspaces = 1,
+	Subscribe = 2,
+	GetOutputs = 3,
+	GetTree = 4,
+
+	Workspace = 0x80000000,
+	Output = 0x80000001,
+	Mode = 0x80000002,
+	Window = 0x80000003,
+	BarconfigUpdate = 0x80000004,
+	Binding = 0x80000005,
+	Shutdown = 0x80000006,
+	Tick = 0x80000007,
+	BarStateUpdate = 0x80000014,
+	Input = 0x80000015,
+	Unknown = 999,
+};
+
+using Event = std::tuple<EventCode, QJsonDocument>;
+
+///! I3/Sway IPC Events
+/// Emitted by @@I3.rawEvent(s)
+class I3IpcEvent: public QObject {
+	Q_OBJECT;
+
+	/// The name of the event
+	Q_PROPERTY(QString type READ type CONSTANT);
+	/// The payload of the event in JSON format.
+	Q_PROPERTY(QString data READ data CONSTANT);
+
+	QML_NAMED_ELEMENT(I3Event);
+	QML_UNCREATABLE("I3IpcEvents cannot be created.");
+
+public:
+	I3IpcEvent(QObject* parent): QObject(parent) {}
+
+	[[nodiscard]] QString type() const;
+	[[nodiscard]] QString data() const;
+
+	EventCode mCode = EventCode::Unknown;
+	QJsonDocument mData;
+
+	static EventCode intToEvent(uint32_t raw);
+	static QString eventToString(EventCode event);
+};
+
+class I3Ipc: public QObject {
+	Q_OBJECT;
+
+public:
+	static I3Ipc* instance();
+
+	[[nodiscard]] QString socketPath() const;
+
+	void makeRequest(const QByteArray& request);
+	void dispatch(const QString& payload);
+
+	static QByteArray buildRequestMessage(EventCode cmd, const QByteArray& payload = QByteArray());
+
+	I3Workspace* findWorkspaceByName(const QString& name);
+	I3Monitor* findMonitorByName(const QString& name, bool createIfMissing = false);
+	I3Workspace* findWorkspaceByID(qint32 id);
+
+	void setFocusedMonitor(I3Monitor* monitor);
+
+	void refreshWorkspaces();
+	void refreshMonitors();
+
+	I3Monitor* monitorFor(QuickshellScreenInfo* screen);
+
+	[[nodiscard]] QBindable<I3Monitor*> bindableFocusedMonitor() const {
+		return &this->bFocusedMonitor;
+	};
+
+	[[nodiscard]] QBindable<I3Workspace*> bindableFocusedWorkspace() const {
+		return &this->bFocusedWorkspace;
+	};
+
+	[[nodiscard]] ObjectModel<I3Monitor>* monitors();
+	[[nodiscard]] ObjectModel<I3Workspace>* workspaces();
+
+signals:
+	void connected();
+	void rawEvent(I3IpcEvent* event);
+	void focusedWorkspaceChanged();
+	void focusedMonitorChanged();
+
+private slots:
+	void eventSocketError(QLocalSocket::LocalSocketError error) const;
+	void eventSocketStateChanged(QLocalSocket::LocalSocketState state);
+	void eventSocketReady();
+	void subscribe();
+
+	void onFocusedMonitorDestroyed();
+
+private:
+	explicit I3Ipc();
+
+	void onEvent(I3IpcEvent* event);
+
+	void handleWorkspaceEvent(I3IpcEvent* event);
+	void handleGetWorkspacesEvent(I3IpcEvent* event);
+	void handleGetOutputsEvent(I3IpcEvent* event);
+	static void handleRunCommand(I3IpcEvent* event);
+	static bool compareWorkspaces(I3Workspace* a, I3Workspace* b);
+
+	void reconnectIPC();
+
+	QVector<std::tuple<EventCode, QJsonDocument>> parseResponse();
+
+	QLocalSocket liveEventSocket;
+	QDataStream liveEventSocketDs;
+
+	QString mSocketPath;
+
+	bool valid = false;
+
+	ObjectModel<I3Monitor> mMonitors {this};
+	ObjectModel<I3Workspace> mWorkspaces {this};
+
+	I3IpcEvent event {this};
+
+	Q_OBJECT_BINDABLE_PROPERTY(I3Ipc, I3Monitor*, bFocusedMonitor, &I3Ipc::focusedMonitorChanged);
+
+	Q_OBJECT_BINDABLE_PROPERTY(
+	    I3Ipc,
+	    I3Workspace*,
+	    bFocusedWorkspace,
+	    &I3Ipc::focusedWorkspaceChanged
+	);
+};
+
+} // namespace qs::i3::ipc
diff --git a/src/x11/i3/ipc/monitor.cpp b/src/x11/i3/ipc/monitor.cpp
new file mode 100644
index 00000000..1bc593cd
--- /dev/null
+++ b/src/x11/i3/ipc/monitor.cpp
@@ -0,0 +1,60 @@
+#include "monitor.hpp"
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qstring.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "connection.hpp"
+#include "workspace.hpp"
+
+namespace qs::i3::ipc {
+
+I3Monitor::I3Monitor(I3Ipc* ipc): QObject(ipc), ipc(ipc) {
+	// clang-format off
+	this->bFocused.setBinding([this]() { return this->ipc->bindableFocusedMonitor().value() == this; });
+	// clang-format on
+}
+
+QVariantMap I3Monitor::lastIpcObject() const { return this->mLastIpcObject; };
+
+void I3Monitor::updateFromObject(const QVariantMap& obj) {
+	if (obj != this->mLastIpcObject) {
+		this->mLastIpcObject = obj;
+		emit this->lastIpcObjectChanged();
+	}
+
+	auto activeWorkspaceName = obj.value("current_workspace").value<QString>();
+	auto rect = obj.value("rect").toMap();
+
+	Qt::beginPropertyUpdateGroup();
+
+	this->bId = obj.value("id").value<qint32>();
+	this->bName = obj.value("name").value<QString>();
+	this->bPower = obj.value("power").value<bool>();
+	this->bX = rect.value("x").value<qint32>();
+	this->bY = rect.value("y").value<qint32>();
+	this->bWidth = rect.value("width").value<qint32>();
+	this->bHeight = rect.value("height").value<qint32>();
+	this->bScale = obj.value("scale").value<qreal>();
+
+	if (!this->bActiveWorkspace
+	    || activeWorkspaceName != this->bActiveWorkspace->bindableName().value())
+	{
+		if (activeWorkspaceName.isEmpty()) {
+			this->bActiveWorkspace = nullptr;
+		} else {
+			this->bActiveWorkspace = this->ipc->findWorkspaceByName(activeWorkspaceName);
+		}
+	};
+
+	Qt::endPropertyUpdateGroup();
+}
+
+void I3Monitor::updateInitial(const QString& name) { this->bName = name; }
+
+void I3Monitor::setFocusedWorkspace(I3Workspace* workspace) { this->bActiveWorkspace = workspace; };
+
+} // namespace qs::i3::ipc
diff --git a/src/x11/i3/ipc/monitor.hpp b/src/x11/i3/ipc/monitor.hpp
new file mode 100644
index 00000000..00269a1b
--- /dev/null
+++ b/src/x11/i3/ipc/monitor.hpp
@@ -0,0 +1,100 @@
+#pragma once
+
+#include <qobject.h>
+#include <qproperty.h>
+
+#include "connection.hpp"
+
+namespace qs::i3::ipc {
+
+///! I3/Sway monitors
+class I3Monitor: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// The ID of this monitor
+	Q_PROPERTY(qint32 id READ default NOTIFY idChanged BINDABLE bindableId);
+	/// The name of this monitor
+	Q_PROPERTY(QString name READ default NOTIFY nameChanged BINDABLE bindableName);
+	/// Wether this monitor is turned on or not
+	Q_PROPERTY(bool power READ default NOTIFY powerChanged BINDABLE bindablePower);
+	/// The currently active workspace on this monitor, May be null.
+	Q_PROPERTY(qs::i3::ipc::I3Workspace* activeWorkspace READ default NOTIFY activeWorkspaceChanged BINDABLE bindableActiveWorkspace);
+	/// Deprecated: See @@activeWorkspace.
+	Q_PROPERTY(qs::i3::ipc::I3Workspace* focusedWorkspace READ default NOTIFY activeWorkspaceChanged BINDABLE bindableActiveWorkspace);
+	/// The X coordinate of this monitor inside the monitor layout
+	Q_PROPERTY(qint32 x READ default NOTIFY xChanged BINDABLE bindableX);
+	/// The Y coordinate of this monitor inside the monitor layout
+	Q_PROPERTY(qint32 y READ default NOTIFY yChanged BINDABLE bindableY);
+	/// The width in pixels of this monitor
+	Q_PROPERTY(qint32 width READ default NOTIFY widthChanged BINDABLE bindableWidth);
+	/// The height in pixels of this monitor
+	Q_PROPERTY(qint32 height READ default NOTIFY heightChanged BINDABLE bindableHeight);
+	/// The scaling factor of this monitor, 1 means it runs at native resolution
+	Q_PROPERTY(qreal scale READ default NOTIFY scaleChanged BINDABLE bindableScale);
+	/// Whether this monitor is currently in focus
+	Q_PROPERTY(bool focused READ default NOTIFY focusedChanged BINDABLE bindableFocused);
+	/// Last JSON returned for this monitor, as a JavaScript object.
+	///
+	/// This updates every time Quickshell receives an `output` event from i3/Sway
+	Q_PROPERTY(QVariantMap lastIpcObject READ lastIpcObject NOTIFY lastIpcObjectChanged);
+	// clang-format on
+	QML_ELEMENT;
+	QML_UNCREATABLE("I3Monitors must be retrieved from the I3Ipc object.");
+
+public:
+	explicit I3Monitor(I3Ipc* ipc);
+
+	[[nodiscard]] QBindable<qint32> bindableId() { return &this->bId; }
+	[[nodiscard]] QBindable<QString> bindableName() { return &this->bName; }
+	[[nodiscard]] QBindable<bool> bindablePower() { return &this->bPower; }
+	[[nodiscard]] QBindable<qint32> bindableX() { return &this->bX; }
+	[[nodiscard]] QBindable<qint32> bindableY() { return &this->bY; }
+	[[nodiscard]] QBindable<qint32> bindableWidth() { return &this->bWidth; }
+	[[nodiscard]] QBindable<qint32> bindableHeight() { return &this->bHeight; }
+	[[nodiscard]] QBindable<qreal> bindableScale() { return &this->bScale; }
+	[[nodiscard]] QBindable<bool> bindableFocused() { return &this->bFocused; }
+
+	[[nodiscard]] QBindable<I3Workspace*> bindableActiveWorkspace() {
+		return &this->bActiveWorkspace;
+	}
+
+	[[nodiscard]] QVariantMap lastIpcObject() const;
+
+	void updateFromObject(const QVariantMap& obj);
+	void updateInitial(const QString& name);
+
+	void setFocusedWorkspace(I3Workspace* workspace);
+
+signals:
+	void idChanged();
+	void nameChanged();
+	void powerChanged();
+	void activeWorkspaceChanged();
+	void xChanged();
+	void yChanged();
+	void widthChanged();
+	void heightChanged();
+	void scaleChanged();
+	void lastIpcObjectChanged();
+	void focusedChanged();
+
+private:
+	I3Ipc* ipc;
+
+	QVariantMap mLastIpcObject;
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(I3Monitor, qint32, bId, -1, &I3Monitor::idChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(I3Monitor, QString, bName, &I3Monitor::nameChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(I3Monitor, bool, bPower, &I3Monitor::powerChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(I3Monitor, qint32, bX, &I3Monitor::xChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(I3Monitor, qint32, bY, &I3Monitor::yChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(I3Monitor, qint32, bWidth, &I3Monitor::widthChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(I3Monitor, qint32, bHeight, &I3Monitor::heightChanged);
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(I3Monitor, qreal, bScale, 1, &I3Monitor::scaleChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(I3Monitor, bool, bFocused, &I3Monitor::focusedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(I3Monitor, I3Workspace*, bActiveWorkspace, &I3Monitor::activeWorkspaceChanged);
+	// clang-format on
+};
+
+} // namespace qs::i3::ipc
diff --git a/src/x11/i3/ipc/qml.cpp b/src/x11/i3/ipc/qml.cpp
new file mode 100644
index 00000000..28041612
--- /dev/null
+++ b/src/x11/i3/ipc/qml.cpp
@@ -0,0 +1,52 @@
+#include "qml.hpp"
+
+#include <qobject.h>
+#include <qproperty.h>
+#include <qstring.h>
+
+#include "../../../core/model.hpp"
+#include "../../../core/qmlscreen.hpp"
+#include "connection.hpp"
+#include "workspace.hpp"
+
+namespace qs::i3::ipc {
+
+I3IpcQml::I3IpcQml() {
+	auto* instance = I3Ipc::instance();
+
+	// clang-format off
+	QObject::connect(instance, &I3Ipc::rawEvent, this, &I3IpcQml::rawEvent);
+	QObject::connect(instance, &I3Ipc::connected, this, &I3IpcQml::connected);
+	QObject::connect(instance, &I3Ipc::focusedWorkspaceChanged, this, &I3IpcQml::focusedWorkspaceChanged);
+	QObject::connect(instance, &I3Ipc::focusedMonitorChanged, this, &I3IpcQml::focusedMonitorChanged);
+	// clang-format on
+}
+
+void I3IpcQml::dispatch(const QString& request) { I3Ipc::instance()->dispatch(request); }
+void I3IpcQml::refreshMonitors() { I3Ipc::instance()->refreshMonitors(); }
+void I3IpcQml::refreshWorkspaces() { I3Ipc::instance()->refreshWorkspaces(); }
+QString I3IpcQml::socketPath() { return I3Ipc::instance()->socketPath(); }
+ObjectModel<I3Monitor>* I3IpcQml::monitors() { return I3Ipc::instance()->monitors(); }
+ObjectModel<I3Workspace>* I3IpcQml::workspaces() { return I3Ipc::instance()->workspaces(); }
+
+QBindable<I3Workspace*> I3IpcQml::bindableFocusedWorkspace() {
+	return I3Ipc::instance()->bindableFocusedWorkspace();
+}
+
+QBindable<I3Monitor*> I3IpcQml::bindableFocusedMonitor() {
+	return I3Ipc::instance()->bindableFocusedMonitor();
+}
+
+I3Workspace* I3IpcQml::findWorkspaceByName(const QString& name) {
+	return I3Ipc::instance()->findWorkspaceByName(name);
+}
+
+I3Monitor* I3IpcQml::findMonitorByName(const QString& name) {
+	return I3Ipc::instance()->findMonitorByName(name);
+}
+
+I3Monitor* I3IpcQml::monitorFor(QuickshellScreenInfo* screen) {
+	return I3Ipc::instance()->monitorFor(screen);
+}
+
+} // namespace qs::i3::ipc
diff --git a/src/x11/i3/ipc/qml.hpp b/src/x11/i3/ipc/qml.hpp
new file mode 100644
index 00000000..804e42a0
--- /dev/null
+++ b/src/x11/i3/ipc/qml.hpp
@@ -0,0 +1,75 @@
+#pragma once
+
+#include <qjsonarray.h>
+#include <qobject.h>
+#include <qproperty.h>
+
+#include "../../../core/doc.hpp"
+#include "../../../core/qmlscreen.hpp"
+#include "connection.hpp"
+
+namespace qs::i3::ipc {
+
+///! I3/Sway IPC integration
+class I3IpcQml: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// Path to the I3 socket
+	Q_PROPERTY(QString socketPath READ socketPath CONSTANT);
+
+	Q_PROPERTY(qs::i3::ipc::I3Workspace* focusedWorkspace READ default NOTIFY focusedWorkspaceChanged BINDABLE bindableFocusedWorkspace);
+	Q_PROPERTY(qs::i3::ipc::I3Monitor* focusedMonitor READ default NOTIFY focusedMonitorChanged BINDABLE bindableFocusedMonitor);
+	/// All I3 monitors.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::i3::ipc::I3Monitor>*);
+	Q_PROPERTY(UntypedObjectModel* monitors READ monitors CONSTANT);
+	/// All I3 workspaces.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::i3::ipc::I3Workspace>*);
+	Q_PROPERTY(UntypedObjectModel* workspaces READ workspaces CONSTANT);
+	// clang-format on
+	QML_NAMED_ELEMENT(I3);
+	QML_SINGLETON;
+
+public:
+	explicit I3IpcQml();
+
+	/// Execute an [I3/Sway command](https://i3wm.org/docs/userguide.html#list_of_commands)
+	Q_INVOKABLE static void dispatch(const QString& request);
+
+	/// Refresh monitor information.
+	Q_INVOKABLE static void refreshMonitors();
+
+	/// Refresh workspace information.
+	Q_INVOKABLE static void refreshWorkspaces();
+
+	/// Find an I3Workspace using its name, returns null if the workspace doesn't exist.
+	Q_INVOKABLE static I3Workspace* findWorkspaceByName(const QString& name);
+
+	/// Find an I3Monitor using its name, returns null if the monitor doesn't exist.
+	Q_INVOKABLE static I3Monitor* findMonitorByName(const QString& name);
+
+	/// Return the i3/Sway monitor associated with `screen`
+	Q_INVOKABLE static I3Monitor* monitorFor(QuickshellScreenInfo* screen);
+
+	/// The path to the I3 or Sway socket currently being used
+	[[nodiscard]] static QString socketPath();
+
+	/// All I3Monitors
+	[[nodiscard]] static ObjectModel<I3Monitor>* monitors();
+
+	/// All I3Workspaces
+	[[nodiscard]] static ObjectModel<I3Workspace>* workspaces();
+
+	/// The currently focused Workspace
+	[[nodiscard]] static QBindable<I3Workspace*> bindableFocusedWorkspace();
+
+	/// The currently focused Monitor
+	[[nodiscard]] static QBindable<I3Monitor*> bindableFocusedMonitor();
+
+signals:
+	void rawEvent(I3IpcEvent* event);
+	void connected();
+	void focusedWorkspaceChanged();
+	void focusedMonitorChanged();
+};
+
+} // namespace qs::i3::ipc
diff --git a/src/x11/i3/ipc/workspace.cpp b/src/x11/i3/ipc/workspace.cpp
new file mode 100644
index 00000000..7d0b7305
--- /dev/null
+++ b/src/x11/i3/ipc/workspace.cpp
@@ -0,0 +1,61 @@
+#include "workspace.hpp"
+
+#include <qcontainerfwd.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qstring.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+
+#include "connection.hpp"
+#include "monitor.hpp"
+
+namespace qs::i3::ipc {
+
+I3Workspace::I3Workspace(I3Ipc* ipc): QObject(ipc), ipc(ipc) {
+	Qt::beginPropertyUpdateGroup();
+
+	this->bActive.setBinding([this]() {
+		return this->bMonitor.value() && this->bMonitor->bindableActiveWorkspace().value() == this;
+	});
+
+	this->bFocused.setBinding([this]() {
+		return this->ipc->bindableFocusedWorkspace().value() == this;
+	});
+
+	Qt::endPropertyUpdateGroup();
+}
+
+QVariantMap I3Workspace::lastIpcObject() const { return this->mLastIpcObject; }
+
+void I3Workspace::updateFromObject(const QVariantMap& obj) {
+	if (obj != this->mLastIpcObject) {
+		this->mLastIpcObject = obj;
+		emit this->lastIpcObjectChanged();
+	}
+
+	Qt::beginPropertyUpdateGroup();
+
+	this->bId = obj.value("id").value<qint32>();
+	this->bName = obj.value("name").value<QString>();
+	this->bNumber = obj.value("num").value<qint32>();
+	this->bUrgent = obj.value("urgent").value<bool>();
+
+	auto monitorName = obj.value("output").value<QString>();
+
+	if (!this->bMonitor || monitorName != this->bMonitor->bindableName().value()) {
+		if (monitorName.isEmpty()) {
+			this->bMonitor = nullptr;
+		} else {
+			this->bMonitor = this->ipc->findMonitorByName(monitorName, true);
+		}
+	}
+
+	Qt::endPropertyUpdateGroup();
+}
+
+void I3Workspace::activate() {
+	this->ipc->dispatch(QString("workspace number %1").arg(this->bNumber.value()));
+}
+
+} // namespace qs::i3::ipc
diff --git a/src/x11/i3/ipc/workspace.hpp b/src/x11/i3/ipc/workspace.hpp
new file mode 100644
index 00000000..c9cd0298
--- /dev/null
+++ b/src/x11/i3/ipc/workspace.hpp
@@ -0,0 +1,89 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+#include <qproperty.h>
+#include <qtypes.h>
+
+#include "connection.hpp"
+
+namespace qs::i3::ipc {
+
+class I3Monitor;
+
+///! I3/Sway workspaces
+class I3Workspace: public QObject {
+	Q_OBJECT;
+	// clang-format off
+	/// The ID of this workspace, it is unique for i3/Sway launch
+	Q_PROPERTY(qint32 id READ default NOTIFY idChanged BINDABLE bindableId);
+	/// The name of this workspace
+	Q_PROPERTY(QString name READ default NOTIFY nameChanged BINDABLE bindableName);
+	/// The number of this workspace
+	Q_PROPERTY(qint32 number READ default NOTIFY numberChanged BINDABLE bindableNumber);
+	/// Deprecated: use @@number
+	Q_PROPERTY(qint32 num READ default NOTIFY numberChanged BINDABLE bindableNumber);
+	/// If a window in this workspace has an urgent notification
+	Q_PROPERTY(bool urgent READ default NOTIFY urgentChanged BINDABLE bindableUrgent);
+	/// If this workspace is currently active on its monitor. See also @@focused.
+	Q_PROPERTY(bool active READ default NOTIFY activeChanged BINDABLE bindableActive);
+	/// If this workspace is currently active on a monitor and that monitor is currently
+	/// focused. See also @@active.
+	Q_PROPERTY(bool focused READ default NOTIFY focusedChanged BINDABLE bindableFocused);
+	/// The monitor this workspace is being displayed on
+	Q_PROPERTY(qs::i3::ipc::I3Monitor* monitor READ default NOTIFY monitorChanged BINDABLE bindableMonitor);
+	/// Last JSON returned for this workspace, as a JavaScript object.
+	///
+	/// This updates every time we receive a `workspace` event from i3/Sway
+	Q_PROPERTY(QVariantMap lastIpcObject READ lastIpcObject NOTIFY lastIpcObjectChanged);
+	// clang-format on
+	QML_ELEMENT;
+	QML_UNCREATABLE("I3Workspaces must be retrieved from the I3 object.");
+
+public:
+	I3Workspace(I3Ipc* ipc);
+
+	/// Activate the workspace.
+	///
+	/// > [!NOTE] This is equivalent to running
+	/// > ```qml
+	/// > I3.dispatch(`workspace number ${workspace.number}`);
+	/// > ```
+	Q_INVOKABLE void activate();
+
+	[[nodiscard]] QBindable<qint32> bindableId() { return &this->bId; }
+	[[nodiscard]] QBindable<QString> bindableName() { return &this->bName; }
+	[[nodiscard]] QBindable<qint32> bindableNumber() { return &this->bNumber; }
+	[[nodiscard]] QBindable<bool> bindableActive() { return &this->bActive; }
+	[[nodiscard]] QBindable<bool> bindableFocused() { return &this->bFocused; }
+	[[nodiscard]] QBindable<bool> bindableUrgent() { return &this->bUrgent; }
+	[[nodiscard]] QBindable<I3Monitor*> bindableMonitor() { return &this->bMonitor; }
+	[[nodiscard]] QVariantMap lastIpcObject() const;
+
+	void updateFromObject(const QVariantMap& obj);
+
+signals:
+	void idChanged();
+	void nameChanged();
+	void urgentChanged();
+	void activeChanged();
+	void focusedChanged();
+	void numberChanged();
+	void monitorChanged();
+	void lastIpcObjectChanged();
+
+private:
+	I3Ipc* ipc;
+
+	QVariantMap mLastIpcObject;
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(I3Workspace, qint32, bId, -1, &I3Workspace::idChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(I3Workspace, QString, bName, &I3Workspace::nameChanged);
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(I3Workspace, qint32, bNumber, -1, &I3Workspace::numberChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(I3Workspace, bool, bActive, &I3Workspace::activeChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(I3Workspace, bool, bFocused, &I3Workspace::focusedChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(I3Workspace, bool, bUrgent, &I3Workspace::urgentChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(I3Workspace, I3Monitor*, bMonitor, &I3Workspace::monitorChanged);
+	// clang-format on
+};
+} // namespace qs::i3::ipc
diff --git a/src/x11/i3/module.md b/src/x11/i3/module.md
new file mode 100644
index 00000000..10afb98d
--- /dev/null
+++ b/src/x11/i3/module.md
@@ -0,0 +1,9 @@
+name = "Quickshell.I3"
+description = "I3 specific Quickshell types"
+headers = [
+	"ipc/connection.hpp",
+	"ipc/qml.hpp",
+	"ipc/workspace.hpp",
+	"ipc/monitor.hpp",
+]
+-----
diff --git a/src/x11/init.cpp b/src/x11/init.cpp
new file mode 100644
index 00000000..ae1fa9b0
--- /dev/null
+++ b/src/x11/init.cpp
@@ -0,0 +1,33 @@
+#include <qguiapplication.h>
+#include <qlist.h>
+#include <qqml.h>
+#include <qstring.h>
+
+#include "../core/plugin.hpp"
+#include "panel_window.hpp"
+#include "util.hpp"
+
+namespace {
+
+class X11Plugin: public QsEnginePlugin {
+	QList<QString> dependencies() override { return {"window"}; }
+
+	bool applies() override { return QGuiApplication::platformName() == "xcb"; }
+
+	void init() override { XAtom::initAtoms(); }
+
+	void registerTypes() override {
+		qmlRegisterType<XPanelInterface>("Quickshell._X11Overlay", 1, 0, "PanelWindow");
+
+		qmlRegisterModuleImport(
+		    "Quickshell",
+		    QQmlModuleImportModuleAny,
+		    "Quickshell._X11Overlay",
+		    QQmlModuleImportLatest
+		);
+	}
+};
+
+QS_REGISTER_PLUGIN(X11Plugin);
+
+} // namespace
diff --git a/src/x11/panel_window.cpp b/src/x11/panel_window.cpp
new file mode 100644
index 00000000..5d53fdd5
--- /dev/null
+++ b/src/x11/panel_window.cpp
@@ -0,0 +1,451 @@
+#include "panel_window.hpp"
+#include <array>
+#include <map>
+
+#include <qevent.h>
+#include <qlist.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qqmlengine.h>
+#include <qqmllist.h>
+#include <qquickwindow.h>
+#include <qscreen.h>
+#include <qtenvironmentvariables.h>
+#include <qtimer.h>
+#include <qtmetamacros.h>
+#include <qtypes.h>
+#include <xcb/xproto.h>
+
+#include "../core/generation.hpp"
+#include "../core/qmlscreen.hpp"
+#include "../core/types.hpp"
+#include "../window/panelinterface.hpp"
+#include "../window/proxywindow.hpp"
+#include "util.hpp"
+
+class XPanelStack {
+public:
+	static XPanelStack* instance() {
+		static XPanelStack* stack = nullptr; // NOLINT
+
+		if (stack == nullptr) {
+			stack = new XPanelStack();
+		}
+
+		return stack;
+	}
+
+	[[nodiscard]] const QList<XPanelWindow*>& panels(XPanelWindow* panel) {
+		return this->mPanels[EngineGeneration::findObjectGeneration(panel)];
+	}
+
+	void addPanel(XPanelWindow* panel) {
+		panel->engineGeneration = EngineGeneration::findObjectGeneration(panel);
+		auto& panels = this->mPanels[panel->engineGeneration];
+		if (!panels.contains(panel)) {
+			panels.push_back(panel);
+		}
+	}
+
+	void removePanel(XPanelWindow* panel) {
+		if (!panel->engineGeneration) return;
+
+		auto& panels = this->mPanels[panel->engineGeneration];
+		if (panels.removeOne(panel)) {
+			if (panels.isEmpty()) {
+				this->mPanels.erase(panel->engineGeneration);
+			}
+
+			// from the bottom up, update all panels
+			for (auto* panel: panels) {
+				panel->updateDimensions();
+			}
+		}
+	}
+
+	void updateLowerDimensions(XPanelWindow* exclude) {
+		if (!exclude->engineGeneration) return;
+		auto& panels = this->mPanels[exclude->engineGeneration];
+
+		// update all panels lower than the one we start from
+		auto found = false;
+		for (auto* panel: panels) {
+			if (panel == exclude) found = true;
+			else if (found) panel->updateDimensions(false);
+		}
+	}
+
+private:
+	std::map<EngineGeneration*, QList<XPanelWindow*>> mPanels;
+};
+
+bool XPanelEventFilter::eventFilter(QObject* watched, QEvent* event) {
+	if (event->type() == QEvent::PlatformSurface) {
+		auto* surfaceEvent = static_cast<QPlatformSurfaceEvent*>(event); // NOLINT
+
+		if (surfaceEvent->surfaceEventType() == QPlatformSurfaceEvent::SurfaceCreated) {
+			emit this->surfaceCreated();
+		}
+	}
+
+	return this->QObject::eventFilter(watched, event);
+}
+
+XPanelWindow::XPanelWindow(QObject* parent): ProxyWindowBase(parent) {
+	QObject::connect(
+	    &this->eventFilter,
+	    &XPanelEventFilter::surfaceCreated,
+	    this,
+	    &XPanelWindow::xInit
+	);
+
+	this->bcExclusiveZone.setBinding([this]() -> qint32 {
+		switch (this->bExclusionMode.value()) {
+		case ExclusionMode::Ignore: return 0;
+		case ExclusionMode::Normal: return this->bExclusiveZone;
+		case ExclusionMode::Auto:
+			auto edge = this->bcExclusionEdge.value();
+			auto margins = this->bMargins.value();
+
+			if (edge == Qt::TopEdge || edge == Qt::BottomEdge) {
+				return this->bImplicitHeight + margins.top + margins.bottom;
+			} else if (edge == Qt::LeftEdge || edge == Qt::RightEdge) {
+				return this->bImplicitWidth + margins.left + margins.right;
+			} else {
+				return 0;
+			}
+		}
+	});
+
+	this->bcExclusionEdge.setBinding([this] { return this->bAnchors.value().exclusionEdge(); });
+}
+
+XPanelWindow::~XPanelWindow() { XPanelStack::instance()->removePanel(this); }
+
+void XPanelWindow::connectWindow() {
+	this->ProxyWindowBase::connectWindow();
+
+	this->window->installEventFilter(&this->eventFilter);
+	this->updateScreen();
+
+	QObject::connect(
+	    this->window,
+	    &QQuickWindow::visibleChanged,
+	    this,
+	    &XPanelWindow::updatePanelStack
+	);
+
+	// qt overwrites _NET_WM_STATE, so we have to use the qt api
+	// QXcbWindow::WindowType::Dock in qplatformwindow_p.h
+	// see QXcbWindow::setWindowFlags in qxcbwindow.cpp
+	this->window->setProperty("_q_xcb_wm_window_type", 0x000004);
+
+	// at least one flag needs to change for the above property to apply
+	this->window->setFlag(Qt::FramelessWindowHint);
+	this->updateAboveWindows();
+	this->updateFocusable();
+
+	if (this->window->handle() != nullptr) {
+		this->xInit();
+		this->updatePanelStack();
+	}
+}
+
+void XPanelWindow::trySetWidth(qint32 implicitWidth) {
+	// only update the actual size if not blocked by anchors
+	if (!this->bAnchors.value().horizontalConstraint()) {
+		this->ProxyWindowBase::trySetWidth(implicitWidth);
+		this->updateDimensions();
+	}
+}
+
+void XPanelWindow::trySetHeight(qint32 implicitHeight) {
+	// only update the actual size if not blocked by anchors
+	if (!this->bAnchors.value().verticalConstraint()) {
+		this->ProxyWindowBase::trySetHeight(implicitHeight);
+		this->updateDimensions();
+	}
+}
+
+void XPanelWindow::setScreen(QuickshellScreenInfo* screen) {
+	this->ProxyWindowBase::setScreen(screen);
+	this->updateScreen();
+}
+
+void XPanelWindow::xInit() {
+	if (this->window == nullptr || this->window->handle() == nullptr) return;
+	this->updateDimensions();
+
+	auto* conn = x11Connection();
+
+	// Stick to every workspace
+	auto desktop = 0xffffffff;
+	xcb_change_property(
+	    conn,
+	    XCB_PROP_MODE_REPLACE,
+	    this->window->winId(),
+	    XAtom::_NET_WM_DESKTOP.atom(),
+	    XCB_ATOM_CARDINAL,
+	    32,
+	    1,
+	    &desktop
+	);
+}
+
+void XPanelWindow::updateScreen() {
+	auto* newScreen =
+	    this->mScreen ? this->mScreen : (this->window ? this->window->screen() : nullptr);
+
+	if (newScreen == this->mTrackedScreen) return;
+
+	if (this->mTrackedScreen != nullptr) {
+		QObject::disconnect(this->mTrackedScreen, nullptr, this, nullptr);
+	}
+
+	this->mTrackedScreen = newScreen;
+
+	if (this->mTrackedScreen != nullptr) {
+		QObject::connect(
+		    this->mTrackedScreen,
+		    &QScreen::geometryChanged,
+		    this,
+		    &XPanelWindow::updateDimensionsSlot
+		);
+
+		QObject::connect(
+		    this->mTrackedScreen,
+		    &QScreen::virtualGeometryChanged,
+		    this,
+		    &XPanelWindow::onScreenVirtualGeometryChanged
+		);
+	}
+
+	this->updateDimensions();
+}
+
+// For some reason this gets sent multiple times with the same value.
+void XPanelWindow::onScreenVirtualGeometryChanged() {
+	auto geometry = this->mTrackedScreen->virtualGeometry();
+	if (geometry != this->lastScreenVirtualGeometry) {
+		this->lastScreenVirtualGeometry = geometry;
+		this->updateStrut(false);
+	}
+}
+
+void XPanelWindow::updateDimensionsSlot() { this->updateDimensions(); }
+
+void XPanelWindow::updateDimensions(bool propagate) {
+	if (this->window == nullptr || this->window->handle() == nullptr
+	    || this->mTrackedScreen == nullptr)
+		return;
+
+	auto screenGeometry = this->mTrackedScreen->geometry();
+
+	if (this->bExclusionMode != ExclusionMode::Ignore) {
+		for (auto* panel: XPanelStack::instance()->panels(this)) {
+			// we only care about windows below us
+			if (panel == this) break;
+
+			// we only care about windows in the same layer
+			if (panel->bAboveWindows != this->bAboveWindows) continue;
+
+			if (panel->mTrackedScreen != this->mTrackedScreen) continue;
+
+			auto edge = panel->bcExclusionEdge.value();
+			auto exclusiveZone = panel->bcExclusiveZone.value();
+
+			screenGeometry.adjust(
+			    edge == Qt::LeftEdge ? exclusiveZone : 0,
+			    edge == Qt::TopEdge ? exclusiveZone : 0,
+			    edge == Qt::RightEdge ? -exclusiveZone : 0,
+			    edge == Qt::BottomEdge ? -exclusiveZone : 0
+			);
+		}
+	}
+
+	auto geometry = QRect();
+
+	auto anchors = this->bAnchors.value();
+	auto margins = this->bMargins.value();
+
+	if (anchors.horizontalConstraint()) {
+		geometry.setX(screenGeometry.x() + margins.left);
+		geometry.setWidth(screenGeometry.width() - margins.left - margins.right);
+	} else {
+		if (anchors.mLeft) {
+			geometry.setX(screenGeometry.x() + margins.left);
+		} else if (anchors.mRight) {
+			geometry.setX(
+			    screenGeometry.x() + screenGeometry.width() - this->implicitWidth() - margins.right
+			);
+		} else {
+			geometry.setX(screenGeometry.x() + screenGeometry.width() / 2 - this->implicitWidth() / 2);
+		}
+
+		geometry.setWidth(this->implicitWidth());
+	}
+
+	if (anchors.verticalConstraint()) {
+		geometry.setY(screenGeometry.y() + margins.top);
+		geometry.setHeight(screenGeometry.height() - margins.top - margins.bottom);
+	} else {
+		if (anchors.mTop) {
+			geometry.setY(screenGeometry.y() + margins.top);
+		} else if (anchors.mBottom) {
+			geometry.setY(
+			    screenGeometry.y() + screenGeometry.height() - this->implicitHeight() - margins.bottom
+			);
+		} else {
+			geometry.setY(screenGeometry.y() + screenGeometry.height() / 2 - this->implicitHeight() / 2);
+		}
+
+		geometry.setHeight(this->implicitHeight());
+	}
+
+	this->window->setGeometry(geometry);
+	this->updateStrut(propagate);
+
+	// AwesomeWM incorrectly repositions the window without this.
+	// See https://github.com/polybar/polybar/blob/f0f9563ecf39e78ba04cc433cb7b38a83efde473/src/components/bar.cpp#L666
+	QTimer::singleShot(0, this, [this, geometry]() {
+		// forces second call not to be discarded as duplicate
+		this->window->setGeometry({0, 0, 0, 0});
+		this->window->setGeometry(geometry);
+	});
+}
+
+void XPanelWindow::updatePanelStack() {
+	if (this->window->isVisible()) {
+		XPanelStack::instance()->addPanel(this);
+	} else {
+		XPanelStack::instance()->removePanel(this);
+	}
+}
+
+// Disable xinerama structs to break multi monitor configurations with bad WMs less.
+// Usually this results in one monitor at the top left corner of the root window working
+// perfectly and all others being broken semi randomly.
+static bool XINERAMA_STRUTS = qEnvironmentVariableIsEmpty("QS_NO_XINERAMA_STRUTS"); // NOLINT
+
+void XPanelWindow::updateStrut(bool propagate) {
+	if (this->window == nullptr || this->window->handle() == nullptr) return;
+	auto* conn = x11Connection();
+
+	auto edge = this->bcExclusionEdge.value();
+	auto exclusiveZone = this->bcExclusiveZone.value();
+
+	if (edge == 0 || this->bExclusionMode == ExclusionMode::Ignore) {
+		xcb_delete_property(conn, this->window->winId(), XAtom::_NET_WM_STRUT.atom());
+		xcb_delete_property(conn, this->window->winId(), XAtom::_NET_WM_STRUT_PARTIAL.atom());
+		return;
+	}
+
+	auto rootGeometry = this->window->screen()->virtualGeometry();
+	auto screenGeometry = this->window->screen()->geometry();
+	auto horizontal = edge == Qt::LeftEdge || edge == Qt::RightEdge;
+
+	if (XINERAMA_STRUTS) {
+		switch (edge) {
+		case Qt::LeftEdge: exclusiveZone += screenGeometry.left(); break;
+		case Qt::RightEdge: exclusiveZone += rootGeometry.right() - screenGeometry.right(); break;
+		case Qt::TopEdge: exclusiveZone += screenGeometry.top(); break;
+		case Qt::BottomEdge: exclusiveZone += rootGeometry.bottom() - screenGeometry.bottom(); break;
+		default: break;
+		}
+	}
+
+	quint32 side = -1;
+
+	switch (edge) {
+	case Qt::LeftEdge: side = 0; break;
+	case Qt::RightEdge: side = 1; break;
+	case Qt::TopEdge: side = 2; break;
+	case Qt::BottomEdge: side = 3; break;
+	}
+
+	auto data = std::array<quint32, 12>();
+	data[side] = exclusiveZone;
+
+	auto start = horizontal ? this->window->y() : this->window->x();
+
+	data[4 + side * 2] = start;
+	data[5 + side * 2] = start + (horizontal ? this->window->height() : this->window->width());
+
+	xcb_change_property(
+	    conn,
+	    XCB_PROP_MODE_REPLACE,
+	    this->window->winId(),
+	    XAtom::_NET_WM_STRUT.atom(),
+	    XCB_ATOM_CARDINAL,
+	    32,
+	    4,
+	    data.data()
+	);
+
+	xcb_change_property(
+	    conn,
+	    XCB_PROP_MODE_REPLACE,
+	    this->window->winId(),
+	    XAtom::_NET_WM_STRUT_PARTIAL.atom(),
+	    XCB_ATOM_CARDINAL,
+	    32,
+	    12,
+	    data.data()
+	);
+
+	if (propagate) XPanelStack::instance()->updateLowerDimensions(this);
+}
+
+void XPanelWindow::updateAboveWindows() {
+	if (this->window == nullptr) return;
+
+	auto above = this->bAboveWindows.value();
+	this->window->setFlag(Qt::WindowStaysOnBottomHint, !above);
+	this->window->setFlag(Qt::WindowStaysOnTopHint, above);
+}
+
+void XPanelWindow::updateFocusable() {
+	if (this->window == nullptr) return;
+	this->window->setFlag(Qt::WindowDoesNotAcceptFocus, !this->bFocusable);
+}
+
+// XPanelInterface
+
+XPanelInterface::XPanelInterface(QObject* parent)
+    : PanelWindowInterface(parent)
+    , panel(new XPanelWindow(this)) {
+	this->connectSignals();
+
+	// clang-format off
+	QObject::connect(this->panel, &XPanelWindow::anchorsChanged, this, &XPanelInterface::anchorsChanged);
+	QObject::connect(this->panel, &XPanelWindow::marginsChanged, this, &XPanelInterface::marginsChanged);
+	QObject::connect(this->panel, &XPanelWindow::exclusiveZoneChanged, this, &XPanelInterface::exclusiveZoneChanged);
+	QObject::connect(this->panel, &XPanelWindow::exclusionModeChanged, this, &XPanelInterface::exclusionModeChanged);
+	QObject::connect(this->panel, &XPanelWindow::aboveWindowsChanged, this, &XPanelInterface::aboveWindowsChanged);
+	QObject::connect(this->panel, &XPanelWindow::focusableChanged, this, &XPanelInterface::focusableChanged);
+	// clang-format on
+}
+
+void XPanelInterface::onReload(QObject* oldInstance) {
+	QQmlEngine::setContextForObject(this->panel, QQmlEngine::contextForObject(this));
+
+	auto* old = qobject_cast<XPanelInterface*>(oldInstance);
+	this->panel->reload(old != nullptr ? old->panel : nullptr);
+}
+
+ProxyWindowBase* XPanelInterface::proxyWindow() const { return this->panel; }
+
+// NOLINTBEGIN
+#define proxyPair(type, get, set)                                                                  \
+	type XPanelInterface::get() const { return this->panel->get(); }                                 \
+	void XPanelInterface::set(type value) { this->panel->set(value); }
+
+proxyPair(Anchors, anchors, setAnchors);
+proxyPair(Margins, margins, setMargins);
+proxyPair(qint32, exclusiveZone, setExclusiveZone);
+proxyPair(ExclusionMode::Enum, exclusionMode, setExclusionMode);
+proxyPair(bool, focusable, setFocusable);
+proxyPair(bool, aboveWindows, setAboveWindows);
+
+#undef proxyPair
+// NOLINTEND
diff --git a/src/x11/panel_window.hpp b/src/x11/panel_window.hpp
new file mode 100644
index 00000000..ab36826c
--- /dev/null
+++ b/src/x11/panel_window.hpp
@@ -0,0 +1,163 @@
+#pragma once
+
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qproperty.h>
+#include <qqmlintegration.h>
+#include <qquickwindow.h>
+#include <qscreen.h>
+#include <qtclasshelpermacros.h>
+#include <qtmetamacros.h>
+
+#include "../core/doc.hpp"
+#include "../core/util.hpp"
+#include "../window/panelinterface.hpp"
+#include "../window/proxywindow.hpp"
+
+class XPanelStack;
+
+class XPanelEventFilter: public QObject {
+	Q_OBJECT;
+
+public:
+	explicit XPanelEventFilter(QObject* parent = nullptr): QObject(parent) {}
+
+signals:
+	void surfaceCreated();
+
+protected:
+	bool eventFilter(QObject* watched, QEvent* event) override;
+};
+
+class XPanelWindow: public ProxyWindowBase {
+	QSDOC_BASECLASS(PanelWindowInterface);
+	Q_OBJECT;
+	// clang-format off
+	QSDOC_HIDE Q_PROPERTY(Anchors anchors READ anchors WRITE setAnchors NOTIFY anchorsChanged);
+	QSDOC_HIDE Q_PROPERTY(qint32 exclusiveZone READ exclusiveZone WRITE setExclusiveZone NOTIFY exclusiveZoneChanged);
+	QSDOC_HIDE Q_PROPERTY(ExclusionMode::Enum exclusionMode READ exclusionMode WRITE setExclusionMode NOTIFY exclusionModeChanged);
+	QSDOC_HIDE Q_PROPERTY(Margins margins READ margins WRITE setMargins NOTIFY marginsChanged);
+	QSDOC_HIDE Q_PROPERTY(bool aboveWindows READ aboveWindows WRITE setAboveWindows NOTIFY aboveWindowsChanged);
+	QSDOC_HIDE Q_PROPERTY(bool focusable READ focusable WRITE setFocusable NOTIFY focusableChanged);
+	// clang-format on
+	QML_ELEMENT;
+
+public:
+	explicit XPanelWindow(QObject* parent = nullptr);
+	~XPanelWindow() override;
+	Q_DISABLE_COPY_MOVE(XPanelWindow);
+
+	void connectWindow() override;
+
+	void trySetWidth(qint32 implicitWidth) override;
+	void trySetHeight(qint32 implicitHeight) override;
+
+	void setScreen(QuickshellScreenInfo* screen) override;
+
+	[[nodiscard]] bool aboveWindows() const { return this->bAboveWindows; }
+	void setAboveWindows(bool aboveWindows) { this->bAboveWindows = aboveWindows; }
+
+	[[nodiscard]] Anchors anchors() const { return this->bAnchors; }
+	void setAnchors(Anchors anchors) { this->bAnchors = anchors; }
+
+	[[nodiscard]] qint32 exclusiveZone() const { return this->bExclusiveZone; }
+	void setExclusiveZone(qint32 exclusiveZone) {
+		Qt::beginPropertyUpdateGroup();
+		this->bExclusiveZone = exclusiveZone;
+		this->bExclusionMode = ExclusionMode::Normal;
+		Qt::endPropertyUpdateGroup();
+	}
+
+	[[nodiscard]] ExclusionMode::Enum exclusionMode() const { return this->bExclusionMode; }
+	void setExclusionMode(ExclusionMode::Enum exclusionMode) { this->bExclusionMode = exclusionMode; }
+
+	[[nodiscard]] Margins margins() const { return this->bMargins; }
+	void setMargins(Margins margins) { this->bMargins = margins; }
+
+	[[nodiscard]] bool focusable() const { return this->bFocusable; }
+	void setFocusable(bool focusable) { this->bFocusable = focusable; }
+
+signals:
+	QSDOC_HIDE void anchorsChanged();
+	QSDOC_HIDE void exclusiveZoneChanged();
+	QSDOC_HIDE void exclusionModeChanged();
+	QSDOC_HIDE void marginsChanged();
+	QSDOC_HIDE void aboveWindowsChanged();
+	QSDOC_HIDE void focusableChanged();
+
+private slots:
+	void xInit();
+	void updatePanelStack();
+	void updateDimensionsSlot();
+	void onScreenVirtualGeometryChanged();
+
+private:
+	void updateScreen();
+	void updateStrut(bool propagate = true);
+	void updateStrutCb() { this->updateStrut(); }
+	void updateAboveWindows();
+	void updateFocusable();
+	void updateDimensions(bool propagate = true);
+	void updateDimensionsCb() { this->updateDimensions(); }
+
+	QPointer<QScreen> mTrackedScreen = nullptr;
+	EngineGeneration* knownGeneration = nullptr;
+
+	QRect lastScreenVirtualGeometry;
+	XPanelEventFilter eventFilter;
+
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(XPanelWindow, bool, bAboveWindows, true, &XPanelWindow::aboveWindowsChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(XPanelWindow, bool, bFocusable, &XPanelWindow::focusableChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(XPanelWindow, Anchors, bAnchors, &XPanelWindow::anchorsChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(XPanelWindow, Margins, bMargins, &XPanelWindow::marginsChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(XPanelWindow, qint32, bExclusiveZone, &XPanelWindow::exclusiveZoneChanged);
+	Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(XPanelWindow, ExclusionMode::Enum, bExclusionMode, ExclusionMode::Auto, &XPanelWindow::exclusionModeChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(XPanelWindow, qint32, bcExclusiveZone);
+	Q_OBJECT_BINDABLE_PROPERTY(XPanelWindow, Qt::Edge, bcExclusionEdge);
+
+	QS_BINDING_SUBSCRIBE_METHOD(XPanelWindow, bAboveWindows, updateAboveWindows, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(XPanelWindow, bAnchors, updateDimensionsCb, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(XPanelWindow, bMargins, updateDimensionsCb, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(XPanelWindow, bcExclusiveZone, updateStrutCb, onValueChanged);
+	QS_BINDING_SUBSCRIBE_METHOD(XPanelWindow, bFocusable, updateFocusable, onValueChanged);
+	// clang-format on
+
+	friend class XPanelStack;
+};
+
+class XPanelInterface: public PanelWindowInterface {
+	Q_OBJECT;
+
+public:
+	explicit XPanelInterface(QObject* parent = nullptr);
+
+	void onReload(QObject* oldInstance) override;
+
+	[[nodiscard]] ProxyWindowBase* proxyWindow() const override;
+
+	// NOLINTBEGIN
+	[[nodiscard]] Anchors anchors() const override;
+	void setAnchors(Anchors anchors) override;
+
+	[[nodiscard]] Margins margins() const override;
+	void setMargins(Margins margins) override;
+
+	[[nodiscard]] qint32 exclusiveZone() const override;
+	void setExclusiveZone(qint32 exclusiveZone) override;
+
+	[[nodiscard]] ExclusionMode::Enum exclusionMode() const override;
+	void setExclusionMode(ExclusionMode::Enum exclusionMode) override;
+
+	[[nodiscard]] bool aboveWindows() const override;
+	void setAboveWindows(bool aboveWindows) override;
+
+	[[nodiscard]] bool focusable() const override;
+	void setFocusable(bool focusable) override;
+	// NOLINTEND
+
+private:
+	XPanelWindow* panel;
+
+	friend class WlrLayershell;
+};
diff --git a/src/x11/util.cpp b/src/x11/util.cpp
new file mode 100644
index 00000000..cdb86e01
--- /dev/null
+++ b/src/x11/util.cpp
@@ -0,0 +1,57 @@
+#include "util.hpp"
+
+#include <qbytearray.h>
+#include <qguiapplication.h>
+#include <qguiapplication_platform.h>
+#include <xcb/xcb.h>
+#include <xcb/xproto.h>
+
+xcb_connection_t* x11Connection() {
+	static xcb_connection_t* conn = nullptr; // NOLINT
+
+	if (conn == nullptr) {
+		if (auto* x11Application = dynamic_cast<QGuiApplication*>(QGuiApplication::instance())
+		                               ->nativeInterface<QNativeInterface::QX11Application>())
+		{
+			conn = x11Application->connection();
+		}
+	}
+
+	return conn;
+}
+
+// NOLINTBEGIN
+XAtom XAtom::_NET_WM_STRUT {};
+XAtom XAtom::_NET_WM_STRUT_PARTIAL {};
+XAtom XAtom::_NET_WM_DESKTOP {};
+// NOLINTEND
+
+void XAtom::initAtoms() {
+	_NET_WM_STRUT.init("_NET_WM_STRUT");
+	_NET_WM_STRUT_PARTIAL.init("_NET_WM_STRUT_PARTIAL");
+	_NET_WM_DESKTOP.init("_NET_WM_DESKTOP");
+}
+
+void XAtom::init(const QByteArray& name) {
+	this->cookie = xcb_intern_atom(x11Connection(), 0, name.length(), name.data());
+}
+
+bool XAtom::isValid() {
+	this->resolve();
+	return this->mAtom != XCB_ATOM_NONE;
+}
+
+const xcb_atom_t& XAtom::atom() {
+	this->resolve();
+	return this->mAtom;
+}
+
+void XAtom::resolve() {
+	if (!this->resolved) {
+		this->resolved = true;
+
+		auto* reply = xcb_intern_atom_reply(x11Connection(), this->cookie, nullptr);
+		if (reply != nullptr) this->mAtom = reply->atom;
+		free(reply); // NOLINT
+	}
+}
diff --git a/src/x11/util.hpp b/src/x11/util.hpp
new file mode 100644
index 00000000..579cbc78
--- /dev/null
+++ b/src/x11/util.hpp
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <qbytearray.h>
+#include <qtclasshelpermacros.h>
+#include <xcb/xcb.h>
+#include <xcb/xproto.h>
+
+xcb_connection_t* x11Connection();
+
+class XAtom {
+public:
+	[[nodiscard]] bool isValid();
+	[[nodiscard]] const xcb_atom_t& atom();
+
+	// NOLINTBEGIN
+	static XAtom _NET_WM_STRUT;
+	static XAtom _NET_WM_STRUT_PARTIAL;
+	static XAtom _NET_WM_DESKTOP;
+	// NOLINTEND
+
+	static void initAtoms();
+
+private:
+	void init(const QByteArray& name);
+	void resolve();
+
+	bool resolved = false;
+	xcb_atom_t mAtom = XCB_ATOM_NONE;
+	xcb_intern_atom_cookie_t cookie {};
+};