version: 0.3.2

docs: add PR template and clarify AI usage in pr descriptions
networking: prefer AP security
2026-10-28 02:55:05 +00:00 · 2026-10-08 01:42:54 -07:00 · 2026-10-05 21:20:58 -07:00 · 2026-10-05 11:03:58 -07:00 · 2026-10-03 04:43:26 -07:00 · 2026-09-25 06:40:25 -07:00
253 changed files with 9318 additions and 3434 deletions
@@ -20,6 +20,7 @@ Checks: >
  -cppcoreguidelines-avoid-do-while,
  -cppcoreguidelines-pro-type-reinterpret-cast,
  -cppcoreguidelines-pro-type-vararg,
+  -cppcoreguidelines-pro-type-union-access,
  -cppcoreguidelines-use-enum-class,
  google-global-names-in-headers,
  google-readability-casting,
@@ -1,82 +1,17 @@
-name: Crash Report
-description: Quickshell has crashed
-labels: ["bug", "crash"]
+name: Crash Report (v1)
+description: Quickshell has crashed (old)
+labels: ["unactionable"]
 body:
-  - type: textarea
-    id: crashinfo
+  - type: markdown
    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
+      value: |
+        Thank you for taking the time to click the report button.
+        At this point most of the worst issues in 0.2.1 and before have been fixed and we are
+        preparing for a new release. Please do not submit this report.
+  - type: checkboxes
+    id: donotcheck
    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.
+      label: Read the text above. Do not submit the report.
+      options:
+        - label: Yes I want this report to be deleted.
+          required: true
@@ -0,0 +1,43 @@
+name: Crash Report (v2)
+description: Quickshell has crashed
+labels: ["bug", "crash"]
+body:
+  - 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: upload
+    id: report
+    attributes:
+      label: Report file
+      description: |
+        Attach `report.txt` here.
+
+        Please ensure the report does not contain personal information,
+        as reports may contain detailed logs leading up to the crash.
+    validations:
+        required: true
+  - type: textarea
+    id: config
+    attributes:
+      label: Configuration
+      description: |
+        Attach or link 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: |
+        GDB usually produces better stacktraces than quickshell can. Consider attaching a gdb backtrace
+        following the instructions below.
+
+        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.
@@ -0,0 +1,31 @@
+<!--
+Read https://github.com/quickshell-mirror/quickshell/blob/master/CONTRIBUTING.md before opening a PR.
+
+Failing to do so may result in a ban from opening PRs.
+-->
+
+### Describe your changes
+<!-- High level overview of what you are changing and why. AI may not be used to write this. -->
+
+### Details and descisions
+<!--
+Put details of why you took a given approach to problems here if its not obvious.
+Reviewing PRs is easier if we don't have to reverse engineer your reasoning.
+
+Consider if things you put here should be code comments instead.
+
+If an AI was heavily used to make the change and its context might be useful,
+put it in a spoiler under your own reasoning.
+-->
+
+### Open concerns
+<!-- Anything you're not sure of or want help with? -->
+
+### Participation
+<!--
+With the advent of AI, we get a lot more drive-bys that don't care about participating
+in a traditional review process, and just want to get a change in.
+
+If you care about your code or learning how the project works to contribute in the future,
+please say so. If not, we'll assume you don't particularly care.
+-->
@@ -55,10 +55,11 @@ jobs:
            libpipewire \
            cli11 \
            polkit \
-            jemalloc
+            jemalloc \
+            libunwind \
+            git # for cpptrace clone

      - 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 -GNinja -B build -DVENDOR_CPPTRACE=ON
          cmake --build build
@@ -15,15 +15,7 @@ Please make this descriptive enough to identify your specific package, for examp
 - `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).
+If you are forking quickshell, please change `CRASHREPORT_URL` to your own issue tracker.

 ### QML Module dir
 Currently all QML modules are statically linked to quickshell, but this is where
@@ -41,11 +33,15 @@ Quickshell has a set of base dependencies you will always need, names vary by di
 - `cmake`
 - `qt6base`
 - `qt6declarative`
+- `libdrm`
 - `qtshadertools` (build-time)
 - `spirv-tools` (build-time)
 - `pkg-config` (build-time)
 - `cli11` (static library)

+Quickshell relies on private Qt APIs and **MUST** be rebuilt against the each Qt release
+or crashes via ABI mismatches will occur.
+
 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
@@ -64,14 +60,24 @@ 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,
+### Crash Handler
+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`
+To disable: `-DCRASH_HANDLER=OFF`

-Dependencies: `google-breakpad` (static library)
+Dependencies: `cpptrace`
+
+Note: `-DVENDOR_CPPTRACE=ON` can be set to vendor cpptrace using FetchContent.
+
+When using FetchContent, `libunwind` is required, and `libdwarf` can be provided by the
+package manager or fetched with FetchContent.
+
+*Please ensure binaries have usable symbols.* We do not necessarily need full debuginfo, but
+leaving symbols in the binary is extremely helpful. You can check if symbols are useful
+by sending a SIGSEGV to the process and ensuring symbols for the quickshell binary are present
+in the trace.

 ### Jemalloc
 We recommend leaving Jemalloc enabled as it will mask memory fragmentation caused
@@ -94,13 +100,6 @@ 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:
@@ -144,7 +143,6 @@ Enables streaming video from monitors and toplevel windows through various proto
 To disable: `-DSCREENCOPY=OFF`

 Dependencies:
- `libdrm`
 - `libgbm`
 - `vulkan-headers` (build-time)

@@ -240,7 +238,7 @@ 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]
+$ cmake -GNinja -B build -DCMAKE_BUILD_TYPE=Release [additional disable flags from above here]
 ```

 Note that features you do not supply dependencies for MUST be disabled with their associated flags
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.20)
-project(quickshell VERSION "0.2.1" LANGUAGES CXX C)
+project(quickshell VERSION "0.3.2" LANGUAGES CXX C)

 set(UNRELEASED_FEATURES)

@@ -9,6 +9,9 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)

 set(QS_BUILD_OPTIONS "")

+# should be changed for forks
+set(CRASHREPORT_URL "https://github.com/outfoxxed/quickshell/issues/new?template=crash2.yml" CACHE STRING "Bugreport URL")
+
 function(boption VAR NAME DEFAULT)
 	cmake_parse_arguments(PARSE_ARGV 3 arg "" "REQUIRES" "")

@@ -40,19 +43,17 @@ string(APPEND QS_BUILD_OPTIONS "  Distributor: ${DISTRIBUTOR}")

 message(STATUS "Quickshell configuration")
 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 (CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
-	boption(CRASH_REPORTER "Crash Handling" OFF)
 	boption(USE_JEMALLOC "Use jemalloc" OFF)
 else()
-	boption(CRASH_REPORTER "Crash Handling" ON)
 	boption(USE_JEMALLOC "Use jemalloc" ON)
 endif()
+boption(CRASH_HANDLER "Crash Handling" ON)
 boption(SOCKETS "Unix Sockets" ON)
 boption(WAYLAND "Wayland" ON)
 boption(WAYLAND_WLR_LAYERSHELL "  Wlroots Layer-Shell" ON REQUIRES WAYLAND)
@@ -86,8 +87,9 @@ include(cmake/util.cmake)

 add_compile_options(-Wall -Wextra -Wno-vla-cxx-extension)

-# pipewire defines this, breaking PCH
+# pipewire defines these, breaking PCH
 add_compile_definitions(_REENTRANT)
+add_compile_options(-fno-strict-overflow)

 if (FRAME_POINTERS)
 	add_compile_options(-fno-omit-frame-pointer)
@@ -1,235 +1,43 @@
-# Contributing / Development
-Instructions for development setup and upstreaming patches.
+# Contributing

-If you just want to build or package quickshell see [BUILD.md](BUILD.md).
+Thank you for taking the time to contribute.
+To ensure nobody's time is wasted, please follow the rules below.

-## Development
+## Acceptable Code Contributions

-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.
+- All changes submitted MUST be **fully understood by the submitter**. If you do not know why or how
+  your change works, do not submit it to be merged. You must be able to explain your reasoning
+  for every change.

-Quickshell also uses `just` for common development command aliases.
+- Change descriptions MUST NOT be written by AI. Summarize what you changed in your own words.
+  If you think an AI summary of a chat session etc may provide useful context, include it in a spoiler.

-The dependencies are also available as a nix shell or nix flake which we recommend
-using with nix-direnv.
+- Changes MUST be submitted by a human who will be responsible for them. Changes submitted without
+  a human in the loop such as automated tooling and AI Agents are **strictly disallowed**. Accounts
+  responsible for such contribution attempts **will be banned**.

-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.
+- Changes MUST respect Quickshell's license and the license of any source works. Changes including
+  code from any other works must disclose the source of the code, explain why it was used, and
+  ensure the license is compatible.

-### Formatting
-All contributions should be formatted similarly to what already exists.
-Group related functionality together.
+- Changes must follow the guidelines outlined in [HACKING.md](HACKING.md) for style and substance.

-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`.
+- Changes must stand on their own as a unit. Do not make multiple unrelated changes in one PR.
+  Changes depending on prior merges should be marked as a draft.

-#### 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.
+## Acceptable Non-code Contributions

-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.
+- Bug and crash reports. You must follow the instructions in the issue templates and provide the
+  information requested.

-```cpp
-auto x = <expr>; // ok
-auto x = QString::number(3); // ok
-QString x; // ok
-QString x = "foo"; // ok
-auto x = QString("foo"); // ok
+- Feature requests can be made via Issues. Please check to ensure nobody else has requested the same feature.

-auto x = QString(); // avoid
-QString x(); // avoid
-QString x("foo"); // avoid
-```
+- Do not make insubstantial or pointless changes.

-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
+- Changes to project rules / policy / governance will not be entertained, except from significant
+  long-term contributors. These changes should not be addressed through contribution channels.

-auto x = <expr>; // unit 1
-emit this->y(); // unit 2
+## Merge timelines

-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 `[email protected]`.
-
-### 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.
+We handle work for the most part on a push basis. If your PR has been ignored for a while
+and is still relevant please bump it.
@@ -0,0 +1,226 @@
+## 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.
+
+The dependencies are also available as a nix shell or nix flake which we recommend
+using with nix-direnv.
+
+Quickshell uses `just` for common development command aliases.
+
+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);
+};
+```
+
+Use lowercase .h suffixed Qt headers, e.g. `<qwindow.h>` over `<QWindow>`.
+
+### 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.
+
+Make sure new files containing doc comments are added to a `module.md` file.
+See existing module files for reference.
+
+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.
+
+If you have made a user visible change since the last tagged release, describe it in
+[changelog/next.md](changelog/next.md).
+
+## 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).
+
+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.)
+
+### 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. There is also a bridged [discord server](https://discord.gg/UtZeT3xNyT).
+Feel free to ask for advice early in your implementation if you are
+unsure.
@@ -13,7 +13,7 @@ lint-changed:
 	git diff --name-only HEAD | grep "^.*\.cpp\$" |  parallel -j$(nproc) --no-notice --will-cite --tty --bar clang-tidy --load={{ env_var("TIDYFOX") }}

 lint-staged:
-	git diff --staged --name-only HEAD | grep "^.*\.cpp\$" |  parallel -j$(nproc) --no-notice --will-cite --tty --bar clang-tidy --load={{ env_var("TIDYFOX") }}
+	git diff --staged --name-only --diff-filter=d 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}} \
@@ -7,7 +7,9 @@ This repo is hosted at:
 - https://github.com/quickshell-mirror/quickshell

 # Contributing / Development
-See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+- [HACKING.md](HACKING.md) - Development instructions and policy.
+- [CONTRIBUTING.md](CONTRIBUTING.md) - Contribution policy.
+- [BUILD.md](BUILD.md) - Packaging and build instructions.

 #### License

@@ -1,56 +0,0 @@
-## Breaking Changes
-
-### Config paths are no longer canonicalized
-
-This fixes nix configs changing shell-ids on rebuild as the shell id is now derived from
-the symlink path. Configs with a symlink in their path will have a different shell id.
-
-Shell ids are used to derive the default config / state / cache folders, so those files
-will need to be manually moved if using a config behind a symlinked path without an explicitly
-set shell id.
-
-## New Features
-
- Added support for creating Polkit agents.
- Added support for creating wayland idle inhibitors.
- Added support for wayland idle timeouts.
- Added support for inhibiting wayland compositor shortcuts for focused windows.
- Added the ability to override Quickshell.cacheDir with a custom path.
- Added minimized, maximized, and fullscreen properties to FloatingWindow.
- Added the ability to handle move and resize events to FloatingWindow.
- Pipewire service now reconnects if pipewire dies or a protocol error occurs.
- Added pipewire audio peak detection.
- Added initial support for network management.
- Added support for grabbing focus from popup windows.
- Added support for IPC signal listeners.
- Added Quickshell version checking and version gated preprocessing.
- Added a way to detect if an icon is from the system icon theme or not.
- Added vulkan support to screencopy.
-
-## Other Changes
-
- FreeBSD is now partially supported.
- IPC operations filter available instances to the current display connection by default.
- PwNodeLinkTracker ignores sound level monitoring programs.
-
-## Bug Fixes
-
- Fixed volume control breaking with pipewire pro audio mode.
- Fixed volume control breaking with bluez streams and potentially others.
- Fixed volume control breaking for devices without route definitions.
- Fixed escape sequence handling in desktop entries.
- Fixed volumes not initializing if a pipewire device was already loaded before its node.
- Fixed hyprland active toplevel not resetting after window closes.
- Fixed hyprland ipc window names and titles being reversed.
- Fixed missing signals for system tray item title and description updates.
- Fixed asynchronous loaders not working after reload.
- Fixed asynchronous loaders not working before window creation.
- Fixed memory leak in IPC handlers.
- Fixed ClippingRectangle related crashes.
- Fixed crashes when monitors are unplugged.
- Fixed crashes when default pipewire devices are lost.
-
-## Packaging Changes
-
-`glib` and `polkit` have been added as dependencies when compiling with polkit agent support.
-`vulkan-headers` has been added as a build-time dependency for screencopy (Vulkan backend support).
@@ -0,0 +1,89 @@
+## Breaking Changes
+
+### Config paths are no longer canonicalized
+
+This fixes nix configs changing shell-ids on rebuild as the shell id is now derived from
+the symlink path. Configs with a symlink in their path will have a different shell id.
+
+Shell ids are used to derive the default config / state / cache folders, so those files
+will need to be manually moved if using a config behind a symlinked path without an explicitly
+set shell id.
+
+## New Features
+
+- Added support for creating Polkit agents.
+- Added support for creating wayland idle inhibitors.
+- Added support for wayland idle timeouts.
+- Added support for inhibiting wayland compositor shortcuts for focused windows.
+- Added the ability to override Quickshell.cacheDir with a custom path.
+- Added minimized, maximized, and fullscreen properties to FloatingWindow.
+- Added the ability to handle move and resize events to FloatingWindow.
+- Pipewire service now reconnects if pipewire dies or a protocol error occurs.
+- Added pipewire audio peak detection.
+- Added network management support.
+- Added support for grabbing focus from popup windows.
+- Added support for IPC signal listeners.
+- Added Quickshell version checking and version gated preprocessing.
+- Added a way to detect if an icon is from the system icon theme or not.
+- Added vulkan support to screencopy.
+- Added generic WindowManager interface implementing ext-workspace.
+- Added ext-background-effect window blur support.
+- Added per-corner radius support to Region.
+- Added ColorQuantizer region selection.
+- Added dialog window support to FloatingWindow.
+- Added lua config support to Hyprland module.
+
+## Other Changes
+
+- IPC operations filter available instances to the current display connection by default.
+- PwNodeLinkTracker ignores sound level monitoring programs.
+- Replaced breakpad with cpptrace.
+- Reloads are prevented if no file content has changed.
+- Added `QS_DISABLE_FILE_WATCHER` environment variable to disable file watching.
+- Added `QS_DISABLE_CRASH_HANDLER` environment variable to disable crash handling.
+- Added `QS_CRASHREPORT_URL` environment variable to allow overriding the crash reporter link.
+- Added `AppId` pragma and `QS_APP_ID` environment variable to allow overriding the desktop application ID.
+- Added `DropExpensiveFonts` pragma and `QS_DROP_EXPENSIVE_FONTS` environment variable which avoids loading fonts which may cause lag and excessive memory usage if many variants are used.
+- Added `DefaultEnv` pragma which sets an environment variable if not already set.
+- Unrecognized pragmas are no longer a hard error for future backward compatibility.
+
+## Bug Fixes
+
+- Fixed volume control breaking with pipewire pro audio mode.
+- Fixed volume control breaking with bluez streams and potentially others.
+- Fixed volume control breaking for devices without route definitions.
+- Fixed escape sequence handling in desktop entries.
+- Fixed volumes not initializing if a pipewire device was already loaded before its node.
+- Fixed hyprland active toplevel not resetting after window closes.
+- Fixed hyprland ipc window names and titles being reversed.
+- Fixed a hyprland ipc crash when refreshing toplevels before workspaces.
+- Fixed missing signals for system tray item title and description updates.
+- Fixed asynchronous loaders not working after reload.
+- Fixed asynchronous loaders not working before window creation.
+- Fixed memory leak in IPC handlers.
+- Fixed ClippingRectangle related crashes.
+- Fixed crashes when monitors are unplugged.
+- Fixed crashes when default pipewire devices are lost.
+- Fixed ToplevelManager not clearing activeToplevel on deactivation.
+- Desktop action order is now preserved.
+- Fixed partial socket reads in greetd and hyprland on slow machines.
+- Worked around Qt bug causing crashes when plugging and unplugging monitors.
+- Fixed HyprlandFocusGrab crashing if windows were destroyed after being passed to it.
+- Fixed ScreencopyView pixelation when scaled.
+- Fixed JsonAdapter crashing and providing bad data on read when using JsonObject.
+- Fixed JsonAdapter sending unnecessary property changes for primitive values.
+- Fixed JsonAdapter serialization for lists.
+- Fixed pipewire crashes after hotplugging devices and changing default outputs.
+- Fixed launches failing for `--daemonize` on some systems.
+- Fixed screencopy crashing when used across GPUs.
+- Fixed pipewire volumes not working for some pw-pulse clients.
+- Fixed nulls in Toplevel.screens after unplugging a monitor.
+- Fixed some DbusMenu updates being dropped from apps.
+
+## Packaging Changes
+
+- `glib` and `polkit` have been added as dependencies when compiling with polkit agent support.
+- `vulkan-headers` has been added as a build-time dependency for screencopy (Vulkan backend support).
+- `breakpad` has been replaced by `cpptrace`, which is far easier to package, and the `CRASH_REPORTER` cmake variable has been replaced with `CRASH_HANDLER` to stop this from being easy to ignore.
+- `DISTRIBUTOR_DEBUGINFO_AVAILABLE` was removed as it is no longer important without breakpad.
+- `libdrm` is now unconditionally required as a direct dependency.
@@ -0,0 +1,23 @@
+## Bug Fixes
+
+- Fixed `ScreencopyView` not displaying when only lock surfaces are shown.
+- Fixed `WlSessionLockSurface.visible` crashing if accessed before backing surface creation.
+- Fixed `MprisPlayer` returning `rate` for `minRate` and `maxRate`.
+- Fixed missing/wrong change signals on various properties.
+- Fixed session lock crashes on sleep, wake, DPMS, and unlocking.
+- `QsWindow.updatesEnabled` makes sure windows are redrawn when set to true.
+- Fixed potential crashes from usage of `WindowsetProjection.screens` during monitor unplug.
+- Fixed crashes from accessing freed objects laundered through a `ScriptModel`.
+- Fixed crashes when a wifi network disappear.
+- Fixed unhandled notifications sending `NotificationClosed` out of order.
+- Fixed `qs kill` not waiting for the process to exit.
+- Fixed IPC calls from children of a crashed and relaunched process crashing.
+- Fixed `JsonAdapter` crashing when deserializing new objects into an array.
+- Fixed `Toplevel.unsetRectangle` crashing when calle.
+- Fixed intermittent `FileView` crashes when updating watched files.
+- Fixed `ColorQuantizer` deletion crashing if an operation was live.
+- Fixed crashes when failing to create a `ScreencopyView`.
+- Fixed `PwNodePeakMonitor` crashing when sampling a stream with mismatched channels from the node.
+- Fixed unsetting `PopupAnchor.item` causing a crash.
+- Fixed hiding the last `PanelWindow` on screen causing a crash under X11.
+- Fixed crashes when `ScriptModel.values` is set while processing previously set values.
@@ -0,0 +1,17 @@
+## Other Changes
+
+- Added support for Qt 6.12
+- Added support for Hyprland's new workspace address format.
+
+## Bug Fixes
+
+- Fixed main process crashes on pam subprocess misbehavior.
+- Fixed crashes when attempting to create or modify session locks reentrantly.
+- Fixed networking state breaking after restarting NetworkManager.
+- Fixed accessibility information not being provided for Quickshell windows.
+- Fixed `WlSessionLockSurface.screen` being null and never updating with a real screen on monitor plug.
+- Fixed `NotificationAction.text` not accepting text updates.
+- Fixed PipeWire route volume writes for devices without a reported volume step.
+- Fixed a crash when quitting or reloading while a `Loader` was still loading asynchronously.
+- Fixed future `Socket` connection attempts after a failed connection attempt.
+- Fixed Open wifi networks showing as Unknown security.
@@ -10,13 +10,16 @@
  ninja,
  spirv-tools,
  qt6,
-  breakpad,
+  cpptrace ? null,
+  libunwind,
+  libdwarf,
  jemalloc,
  cli11,
  wayland,
  wayland-protocols,
  wayland-scanner,
  xorg,
+  libxcb ? xorg.libxcb,
  libdrm,
  libgbm ? null,
  vulkan-headers,
@@ -49,9 +52,11 @@
  withPolkit ? true,
  withNetworkManager ? true,
 }: let
+  withCrashHandler = withCrashReporter && cpptrace != null && lib.strings.compareVersions cpptrace.version "0.7.2" >= 0;
+
  unwrapped = stdenv.mkDerivation {
    pname = "quickshell${lib.optionalString debug "-debug"}";
-    version = "0.2.1";
+    version = "0.3.2";
    src = nix-gitignore.gitignoreSource "/default.nix\n" ./.;

    dontWrapQtApps = true; # see wrappers
@@ -71,15 +76,21 @@
    buildInputs = [
      qt6.qtbase
      qt6.qtdeclarative
+      libdrm
      cli11
    ]
    ++ lib.optional withQtSvg qt6.qtsvg
-    ++ lib.optional withCrashReporter breakpad
+    ++ lib.optional withCrashHandler (cpptrace.overrideAttrs (prev: {
+      cmakeFlags = prev.cmakeFlags ++ [
+        "-DCPPTRACE_UNWIND_WITH_LIBUNWIND=TRUE"
+      ];
+      buildInputs = prev.buildInputs ++ [ libunwind ];
+    }))
    ++ lib.optional withJemalloc jemalloc
    ++ lib.optional (withWayland && lib.strings.compareVersions qt6.qtbase.version "6.10.0" == -1) qt6.qtwayland
    ++ lib.optionals withWayland [ wayland wayland-protocols ]
-    ++ lib.optionals (withWayland && libgbm != null) [ libdrm libgbm vulkan-headers ]
-    ++ lib.optional withX11 xorg.libxcb
+    ++ lib.optionals (withWayland && libgbm != null) [ libgbm vulkan-headers ]
+    ++ lib.optional withX11 libxcb
    ++ lib.optional withPam pam
    ++ lib.optional withPipewire pipewire
    ++ lib.optionals withPolkit [ polkit glib ];
@@ -91,7 +102,7 @@
      (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 "CRASH_HANDLER" withCrashHandler)
      (lib.cmakeBool "USE_JEMALLOC" withJemalloc)
      (lib.cmakeBool "WAYLAND" withWayland)
      (lib.cmakeBool "SCREENCOPY" (libgbm != null))
@@ -1,78 +0,0 @@
-(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
-                  polkit
-                  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
@@ -11,8 +11,9 @@ add_subdirectory(window)
 add_subdirectory(io)
 add_subdirectory(widgets)
 add_subdirectory(ui)
+add_subdirectory(windowmanager)

-if (CRASH_REPORTER)
+if (CRASH_HANDLER)
 	add_subdirectory(crash)
 endif()

@@ -28,6 +29,10 @@ if (X11)
 	add_subdirectory(x11)
 endif()

+if (I3)
+	add_subdirectory(x11/i3)
+endif()
+
 add_subdirectory(services)

 if (BLUETOOTH)
@@ -9,16 +9,10 @@ if (NOT DEFINED GIT_REVISION)
 	)
 endif()

-if (CRASH_REPORTER)
-	set(CRASH_REPORTER_DEF 1)
+if (CRASH_HANDLER)
+	set(CRASH_HANDLER_DEF 1)
 else()
-	set(CRASH_REPORTER_DEF 0)
-endif()
-
-if (DISTRIBUTOR_DEBUGINFO_AVAILABLE)
-	set(DEBUGINFO_AVAILABLE 1)
-else()
-	set(DEBUGINFO_AVAILABLE 0)
+	set(CRASH_HANDLER_DEF 0)
 endif()

 configure_file(build.hpp.in build.hpp @ONLY ESCAPE_QUOTES)
@@ -8,10 +8,10 @@
 #define QS_UNRELEASED_FEATURES "@UNRELEASED_FEATURES@"
 #define GIT_REVISION "@GIT_REVISION@"
 #define DISTRIBUTOR "@DISTRIBUTOR@"
-#define DISTRIBUTOR_DEBUGINFO_AVAILABLE @DEBUGINFO_AVAILABLE@
-#define CRASH_REPORTER @CRASH_REPORTER_DEF@
+#define CRASH_HANDLER @CRASH_HANDLER_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@"
+#define CRASHREPORT_URL "@CRASHREPORT_URL@"
 // NOLINTEND
@@ -1,3 +1,4 @@
+pkg_check_modules(libdrm REQUIRED IMPORTED_TARGET libdrm)
 qt_add_library(quickshell-core STATIC
 	plugin.cpp
 	shell.cpp
@@ -40,6 +41,8 @@ qt_add_library(quickshell-core STATIC
 	scriptmodel.cpp
 	colorquantizer.cpp
 	toolsupport.cpp
+	streamreader.cpp
+	debuginfo.cpp
 )

 qt_add_qml_module(quickshell-core
@@ -52,7 +55,7 @@ qt_add_qml_module(quickshell-core

 install_qml_module(quickshell-core)

-target_link_libraries(quickshell-core PRIVATE Qt::Quick Qt::QuickPrivate Qt::Widgets quickshell-build)
+target_link_libraries(quickshell-core PRIVATE Qt::Quick Qt::QuickPrivate Qt::Widgets quickshell-build PkgConfig::libdrm)

 qs_module_pch(quickshell-core SET large)

@@ -1,5 +1,6 @@
 #include "colorquantizer.hpp"
 #include <algorithm>
+#include <utility>

 #include <qatomic.h>
 #include <qcolor.h>
@@ -13,6 +14,7 @@
 #include <qnumeric.h>
 #include <qobject.h>
 #include <qqmllist.h>
+#include <qrect.h>
 #include <qrgb.h>
 #include <qthreadpool.h>
 #include <qtmetamacros.h>
@@ -24,19 +26,30 @@ namespace {
 QS_LOGGING_CATEGORY(logColorQuantizer, "quickshell.colorquantizer", QtWarningMsg);
 }

-ColorQuantizerOperation::ColorQuantizerOperation(QUrl* source, qreal depth, qreal rescaleSize)
-    : source(source)
+ColorQuantizerOperation::ColorQuantizerOperation(
+    QUrl source,
+    qreal depth,
+    QRect imageRect,
+    qreal rescaleSize
+)
+    : source(std::move(source))
    , maxDepth(depth)
+    , imageRect(imageRect)
    , rescaleSize(rescaleSize) {
 	this->setAutoDelete(false);
 }

 void ColorQuantizerOperation::quantizeImage(const QAtomicInteger<bool>& shouldCancel) {
-	if (shouldCancel.loadAcquire() || this->source->isEmpty()) return;
+	if (shouldCancel.loadAcquire() || this->source.isEmpty()) return;

 	this->colors.clear();

-	auto image = QImage(this->source->toLocalFile());
+	auto image = QImage(this->source.toLocalFile());
+
+	if (this->imageRect.isValid()) {
+		image = image.copy(this->imageRect);
+	}
+
 	if ((image.width() > this->rescaleSize || image.height() > this->rescaleSize)
 	    && this->rescaleSize > 0)
 	{
@@ -49,7 +62,7 @@ void ColorQuantizerOperation::quantizeImage(const QAtomicInteger<bool>& shouldCa
 	}

 	if (image.isNull()) {
-		qCWarning(logColorQuantizer) << "Failed to load image from" << this->source->toString();
+		qCWarning(logColorQuantizer) << "Failed to load image from" << this->source.toString();
 		return;
 	}

@@ -179,6 +192,8 @@ void ColorQuantizerOperation::run() {

 void ColorQuantizerOperation::tryCancel() { this->shouldCancel.storeRelease(true); }

+ColorQuantizer::~ColorQuantizer() { this->cancelAsync(); }
+
 void ColorQuantizer::componentComplete() {
 	this->componentCompleted = true;
 	if (!this->mSource.isEmpty()) this->quantizeAsync();
@@ -198,16 +213,27 @@ void ColorQuantizer::setDepth(qreal depth) {
 		this->mDepth = depth;
 		emit this->depthChanged();

-		if (this->componentCompleted) this->quantizeAsync();
+		if (this->componentCompleted && !this->mSource.isEmpty()) this->quantizeAsync();
 	}
 }

+void ColorQuantizer::setImageRect(QRect imageRect) {
+	if (this->mImageRect != imageRect) {
+		this->mImageRect = imageRect;
+		emit this->imageRectChanged();
+
+		if (this->componentCompleted && !this->mSource.isEmpty()) this->quantizeAsync();
+	}
+}
+
+void ColorQuantizer::resetImageRect() { this->setImageRect(QRect()); }
+
 void ColorQuantizer::setRescaleSize(int rescaleSize) {
 	if (this->mRescaleSize != rescaleSize) {
 		this->mRescaleSize = rescaleSize;
 		emit this->rescaleSizeChanged();

-		if (this->componentCompleted) this->quantizeAsync();
+		if (this->componentCompleted && !this->mSource.isEmpty()) this->quantizeAsync();
 	}
 }

@@ -221,8 +247,13 @@ void ColorQuantizer::quantizeAsync() {
 	if (this->liveOperation) this->cancelAsync();

 	qCDebug(logColorQuantizer) << "Starting color quantization asynchronously";
-	this->liveOperation =
-	    new ColorQuantizerOperation(&this->mSource, this->mDepth, this->mRescaleSize);
+
+	this->liveOperation = new ColorQuantizerOperation(
+	    this->mSource,
+	    this->mDepth,
+	    this->mImageRect,
+	    this->mRescaleSize
+	);

 	QObject::connect(
 	    this->liveOperation,
@@ -5,7 +5,9 @@
 #include <qproperty.h>
 #include <qqmlintegration.h>
 #include <qqmlparserstatus.h>
+#include <qrect.h>
 #include <qrunnable.h>
+#include <qtclasshelpermacros.h>
 #include <qtmetamacros.h>
 #include <qtypes.h>
 #include <qurl.h>
@@ -16,7 +18,7 @@ class ColorQuantizerOperation
 	Q_OBJECT;

 public:
-	explicit ColorQuantizerOperation(QUrl* source, qreal depth, qreal rescaleSize);
+	explicit ColorQuantizerOperation(QUrl source, qreal depth, QRect imageRect, qreal rescaleSize);

 	void run() override;
 	void tryCancel();
@@ -42,8 +44,9 @@ private:

 	QAtomicInteger<bool> shouldCancel = false;
 	QList<QColor> colors;
-	QUrl* source;
+	QUrl source;
 	qreal maxDepth;
+	QRect imageRect;
 	qreal rescaleSize;
 };

@@ -78,13 +81,22 @@ class ColorQuantizer
 	/// binary split of the color space
 	Q_PROPERTY(qreal depth READ depth WRITE setDepth NOTIFY depthChanged);

+	// clang-format off
+	/// Rectangle that the source image is cropped to.
+	///
+	/// Can be set to `undefined` to reset.
+	Q_PROPERTY(QRect imageRect READ imageRect WRITE setImageRect RESET resetImageRect NOTIFY imageRectChanged);
+	// clang-format on
+
 	/// 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.
+	/// > recommended 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) {}
+	~ColorQuantizer() override;
+	Q_DISABLE_COPY_MOVE(ColorQuantizer);

 	void componentComplete() override;
 	void classBegin() override {}
@@ -97,6 +109,10 @@ public:
 	[[nodiscard]] qreal depth() const { return this->mDepth; }
 	void setDepth(qreal depth);

+	[[nodiscard]] QRect imageRect() const { return this->mImageRect; }
+	void setImageRect(QRect imageRect);
+	void resetImageRect();
+
 	[[nodiscard]] qreal rescaleSize() const { return this->mRescaleSize; }
 	void setRescaleSize(int rescaleSize);

@@ -104,6 +120,7 @@ signals:
 	void colorsChanged();
 	void sourceChanged();
 	void depthChanged();
+	void imageRectChanged();
 	void rescaleSizeChanged();

 public slots:
@@ -117,6 +134,7 @@ private:
 	ColorQuantizerOperation* liveOperation = nullptr;
 	QUrl mSource;
 	qreal mDepth = 0;
+	QRect mImageRect;
 	qreal mRescaleSize = 0;

 	Q_OBJECT_BINDABLE_PROPERTY(
@@ -0,0 +1,176 @@
+#include "debuginfo.hpp"
+#include <array>
+#include <cstring>
+#include <string_view>
+
+#include <fcntl.h>
+#include <qconfig.h>
+#include <qcontainerfwd.h>
+#include <qdebug.h>
+#include <qfile.h>
+#include <qfloat16.h>
+#include <qhashfunctions.h>
+#include <qscopeguard.h>
+#include <qtversion.h>
+#include <unistd.h>
+#include <xf86drm.h>
+
+#include "build.hpp"
+
+extern char** environ; // NOLINT
+
+namespace qs::debuginfo {
+
+QString qsVersion() {
+	return QS_VERSION " (revision " GIT_REVISION ", distributed by " DISTRIBUTOR ")";
+}
+
+QString qtVersion() { return qVersion() % QStringLiteral(" (built against " QT_VERSION_STR ")"); }
+
+QString gpuInfo() {
+	auto deviceCount = drmGetDevices2(0, nullptr, 0);
+	if (deviceCount < 0) return "Failed to get DRM device count: " % QString::number(deviceCount);
+	auto* devices = new drmDevicePtr[deviceCount];
+	auto devicesArrayGuard = qScopeGuard([&] { delete[] devices; });
+	auto r = drmGetDevices2(0, devices, deviceCount);
+	if (deviceCount < 0) return "Failed to get DRM devices: " % QString::number(r);
+	auto devicesGuard = qScopeGuard([&] {
+		for (auto i = 0; i != deviceCount; ++i) drmFreeDevice(&devices[i]); // NOLINT
+	});
+
+	QString info;
+	auto stream = QTextStream(&info);
+
+	for (auto i = 0; i != deviceCount; ++i) {
+		auto* device = devices[i]; // NOLINT
+
+		int deviceNodeType = -1;
+		if (device->available_nodes & (1 << DRM_NODE_RENDER)) deviceNodeType = DRM_NODE_RENDER;
+		else if (device->available_nodes & (1 << DRM_NODE_PRIMARY)) deviceNodeType = DRM_NODE_PRIMARY;
+
+		if (deviceNodeType == -1) continue;
+
+		auto* deviceNode = device->nodes[DRM_NODE_RENDER]; // NOLINT
+
+		auto driver = [&]() -> QString {
+			auto fd = open(deviceNode, O_RDWR | O_CLOEXEC);
+			if (fd == -1) return "<failed to open device node>";
+			auto fdGuard = qScopeGuard([&] { close(fd); });
+			auto* ver = drmGetVersion(fd);
+			if (!ver) return "<drmGetVersion failed>";
+			auto verGuard = qScopeGuard([&] { drmFreeVersion(ver); });
+
+			// clang-format off
+			return QString(ver->name)
+				% ' ' % QString::number(ver->version_major)
+				% '.' % QString::number(ver->version_minor)
+				% '.' % QString::number(ver->version_patchlevel)
+				% " (" % ver->desc % ')';
+			// clang-format on
+		}();
+
+		QString product = "unknown";
+		QString address = "unknown";
+
+		auto hex = [](int num, int pad) { return QString::number(num, 16).rightJustified(pad, '0'); };
+
+		switch (device->bustype) {
+		case DRM_BUS_PCI: {
+			auto* b = device->businfo.pci;
+			auto* d = device->deviceinfo.pci;
+			address = "PCI " % hex(b->bus, 2) % ':' % hex(b->dev, 2) % '.' % hex(b->func, 1);
+			product = hex(d->vendor_id, 4) % ':' % hex(d->device_id, 4);
+		} break;
+		case DRM_BUS_USB: {
+			auto* b = device->businfo.usb;
+			auto* d = device->deviceinfo.usb;
+			address = "USB " % QString::number(b->bus) % ':' % QString::number(b->dev);
+			product = hex(d->vendor, 4) % ':' % hex(d->product, 4);
+		} break;
+		default: break;
+		}
+
+		stream << "GPU " << deviceNode << "\n  Driver: " << driver << "\n  Model: " << product
+		       << "\n  Address: " << address << '\n';
+	}
+
+	return info;
+}
+
+QString systemInfo() {
+	QString info;
+	auto stream = QTextStream(&info);
+
+	stream << gpuInfo() << '\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";
+	}
+
+	return info;
+}
+
+QString envInfo() {
+	QString info;
+	auto stream = QTextStream(&info);
+
+	for (auto** envp = environ; *envp != nullptr; ++envp) { // NOLINT
+		auto prefixes = std::array<std::string_view, 6> {
+		    "QS_",
+		    "QT_",
+		    "QML_",
+		    "QML2_",
+		    "QSG_",
+		    "XDG_CURRENT_DESKTOP=",
+		};
+
+		for (const auto& prefix: prefixes) {
+			if (strncmp(prefix.data(), *envp, prefix.length()) == 0) goto print;
+		}
+		continue;
+
+	print:
+		stream << *envp << '\n';
+	}
+
+	return info;
+}
+
+QString combinedInfo() {
+	QString info;
+	auto stream = QTextStream(&info);
+
+	stream << "===== Version Information =====\n";
+	stream << "Quickshell: " << qsVersion() << '\n';
+	stream << "Qt: " << qtVersion() << '\n';
+
+	stream << "\n===== Build Information =====\n";
+	stream << "Build Type: " << BUILD_TYPE << '\n';
+	stream << "Compiler: " << COMPILER << '\n';
+	stream << "Compile Flags: " << COMPILE_FLAGS << '\n';
+	stream << "Configuration:\n" << BUILD_CONFIGURATION << '\n';
+
+	stream << "\n===== System Information =====\n";
+	stream << systemInfo();
+
+	stream << "\n===== Environment (trimmed) =====\n";
+	stream << envInfo();
+
+	return info;
+}
+
+} // namespace qs::debuginfo
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <qcontainerfwd.h>
+
+namespace qs::debuginfo {
+
+QString qsVersion();
+QString qtVersion();
+QString gpuInfo();
+QString systemInfo();
+QString envInfo();
+QString combinedInfo();
+
+} // namespace qs::debuginfo
@@ -107,7 +107,10 @@ ParsedDesktopEntryData DesktopEntry::parseText(const QString& id, const QString&
 	auto groupName = QString();
 	auto entries = QHash<QString, QPair<Locale, QString>>();

-	auto finishCategory = [&data, &groupName, &entries]() {
+	auto actionOrder = QStringList();
+	auto pendingActions = QHash<QString, DesktopActionData>();
+
+	auto finishCategory = [&data, &groupName, &entries, &actionOrder, &pendingActions]() {
 		if (groupName == "Desktop Entry") {
 			if (entries.value("Type").second != "Application") return;

@@ -129,9 +132,10 @@ ParsedDesktopEntryData DesktopEntry::parseText(const QString& id, const QString&
 				else if (key == "Terminal") data.terminal = value == "true";
 				else if (key == "Categories") data.categories = value.split(u';', Qt::SkipEmptyParts);
 				else if (key == "Keywords") data.keywords = value.split(u';', Qt::SkipEmptyParts);
+				else if (key == "Actions") actionOrder = value.split(u';', Qt::SkipEmptyParts);
 			}
 		} else if (groupName.startsWith("Desktop Action ")) {
-			auto actionName = groupName.sliced(16);
+			auto actionName = groupName.sliced(15);
 			DesktopActionData action;
 			action.id = actionName;

@@ -147,7 +151,7 @@ ParsedDesktopEntryData DesktopEntry::parseText(const QString& id, const QString&
 				}
 			}

-			data.actions.insert(actionName, action);
+			pendingActions.insert(actionName, action);
 		}

 		entries.clear();
@@ -193,6 +197,13 @@ ParsedDesktopEntryData DesktopEntry::parseText(const QString& id, const QString&
 	}

 	finishCategory();
+
+	for (const auto& actionId: actionOrder) {
+		if (pendingActions.contains(actionId)) {
+			data.actions.append(pendingActions.value(actionId));
+		}
+	}
+
 	return data;
 }

@@ -216,17 +227,18 @@ void DesktopEntry::updateState(const ParsedDesktopEntryData& newState) {
 	this->updateActions(newState.actions);
 }

-void DesktopEntry::updateActions(const QHash<QString, DesktopActionData>& newActions) {
+void DesktopEntry::updateActions(const QVector<DesktopActionData>& newActions) {
 	auto old = this->mActions;
+	this->mActions.clear();

-	for (const auto& [key, d]: newActions.asKeyValueRange()) {
+	for (const auto& d: newActions) {
 		DesktopAction* act = nullptr;
-		if (auto found = old.find(key); found != old.end()) {
-			act = found.value();
+		auto found = std::ranges::find(old, d.id, &DesktopAction::mId);
+		if (found != old.end()) {
+			act = *found;
 			old.erase(found);
 		} else {
 			act = new DesktopAction(d.id, this);
-			this->mActions.insert(key, act);
 		}

 		Qt::beginPropertyUpdateGroup();
@@ -237,6 +249,7 @@ void DesktopEntry::updateActions(const QHash<QString, DesktopActionData>& newAct
 		Qt::endPropertyUpdateGroup();

 		act->mEntries = d.entries;
+		this->mActions.append(act);
 	}

 	for (auto* leftover: old) {
@@ -250,7 +263,7 @@ void DesktopEntry::execute() const {

 bool DesktopEntry::isValid() const { return !this->bName.value().isEmpty(); }

-QVector<DesktopAction*> DesktopEntry::actions() const { return this->mActions.values(); }
+QVector<DesktopAction*> DesktopEntry::actions() const { return this->mActions; }

 QVector<QString> DesktopEntry::parseExecString(const QString& execString) {
 	QVector<QString> arguments;
@@ -43,7 +43,7 @@ struct ParsedDesktopEntryData {
 	QVector<QString> categories;
 	QVector<QString> keywords;
 	QHash<QString, QString> entries;
-	QHash<QString, DesktopActionData> actions;
+	QVector<DesktopActionData> actions;
 };

 /// A desktop entry. See @@DesktopEntries for details.
@@ -164,10 +164,10 @@ public:
 	// clang-format on

 private:
-	void updateActions(const QHash<QString, DesktopActionData>& newActions);
+	void updateActions(const QVector<DesktopActionData>& newActions);

 	ParsedDesktopEntryData state;
-	QHash<QString, DesktopAction*> mActions;
+	QVector<DesktopAction*> mActions;

 	friend class DesktopAction;
 };
@@ -11,6 +11,7 @@
 #include <qlist.h>
 #include <qlogging.h>
 #include <qloggingcategory.h>
+#include <qnamespace.h>
 #include <qobject.h>
 #include <qqmlcontext.h>
 #include <qqmlengine.h>
@@ -62,6 +63,10 @@ EngineGeneration::EngineGeneration(const QDir& rootPath, QmlScanner scanner)
 EngineGeneration::EngineGeneration(): EngineGeneration(QDir(), QmlScanner()) {}

 EngineGeneration::~EngineGeneration() {
+	for (auto* extension: this->extensions.values()) {
+		delete extension;
+	}
+
 	if (this->engine != nullptr) {
 		qFatal() << this << "destroyed without calling destroy()";
 	}
@@ -78,30 +83,37 @@ void EngineGeneration::destroy() {
 		this->watcher = nullptr;
 	}

-	for (auto* extension: this->extensions.values()) {
-		delete extension;
-	}
-
 	if (this->root != nullptr) {
+		// prevent further js execution during teardown of the root's children, gc and the engine.
 		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);
 		});

+		// QObject::destroyed is emitted before the root's children are destroyed.
+		// The engine must outlive them, as objects such as Loaders with in-flight
+		// incubations access it in their destructors.
+		QObject::connect(
+		    this->root,
+		    &QObject::destroyed,
+		    this,
+		    [this]() {
+			    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);
+		    },
+		    Qt::QueuedConnection
+		);
+
 		this->root->deleteLater();
 		this->root = nullptr;
 	} else {
@@ -198,6 +210,7 @@ void EngineGeneration::setWatchingFiles(bool watching) {
 		}
 	} else {
 		if (this->watcher != nullptr) {
+			QObject::disconnect(this->watcher, nullptr, this, nullptr);
 			this->watcher->deleteLater();
 			this->watcher = nullptr;
 		}
@@ -209,6 +222,8 @@ bool EngineGeneration::setExtraWatchedFiles(const QVector<QString>& files) {
 	for (const auto& file: files) {
 		if (!this->scanner.scannedFiles.contains(file)) {
 			this->extraWatchedFiles.append(file);
+			QByteArray data;
+			this->scanner.readAndHashFile(file, data);
 		}
 	}

@@ -229,6 +244,11 @@ void EngineGeneration::onFileChanged(const QString& name) {
 		auto fileInfo = QFileInfo(name);
 		if (fileInfo.isFile() && fileInfo.size() == 0) return;

+		if (!this->scanner.hasFileContentChanged(name)) {
+			qCDebug(logQmlScanner) << "Ignoring file change with unchanged content:" << name;
+			return;
+		}
+
 		emit this->filesChanged();
 	}
 }
@@ -237,6 +257,11 @@ 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()) {
+			if (!this->scanner.hasFileContentChanged(file)) {
+				qCDebug(logQmlScanner) << "Ignoring restored file with unchanged content:" << file;
+				continue;
+			}
+
 			emit this->filesChanged();
 			break;
 		}
@@ -14,7 +14,7 @@

 #include "generation.hpp"

-// QMenu re-calls pixmap() every time the mouse moves so its important to cache it.
+// QMenu re-calls pixmap() every time the mouse moves so it's important to cache it.
 class PixmapCacheIconEngine: public QIconEngine {
 	void paint(
 	    QPainter* /*unused*/,
@@ -3,14 +3,14 @@
 #include <qdatastream.h>

 QDataStream& operator<<(QDataStream& stream, const InstanceInfo& info) {
-	stream << info.instanceId << info.configPath << info.shellId << info.launchTime << info.pid
-	       << info.display;
+	stream << info.instanceId << info.configPath << info.shellId << info.appId << info.launchTime
+	       << info.pid << info.display;
 	return stream;
 }

 QDataStream& operator>>(QDataStream& stream, InstanceInfo& info) {
-	stream >> info.instanceId >> info.configPath >> info.shellId >> info.launchTime >> info.pid
-	    >> info.display;
+	stream >> info.instanceId >> info.configPath >> info.shellId >> info.appId >> info.launchTime
+	    >> info.pid >> info.display;
 	return stream;
 }

@@ -9,6 +9,7 @@ struct InstanceInfo {
 	QString instanceId;
 	QString configPath;
 	QString shellId;
+	QString appId;
 	QDateTime launchTime;
 	pid_t pid = -1;
 	QString display;
@@ -35,6 +36,8 @@ namespace qs::crash {

 struct CrashInfo {
 	int logFd = -1;
+	int traceFd = -1;
+	int infoFd = -1;

 	static CrashInfo INSTANCE; // NOLINT
 };
@@ -14,6 +14,7 @@
 #include <qlist.h>
 #include <qlogging.h>
 #include <qloggingcategory.h>
+#include <qmutex.h>
 #include <qnamespace.h>
 #include <qobject.h>
 #include <qobjectdefs.h>
@@ -31,6 +32,9 @@
 #include <sys/sendfile.h>
 #include <sys/types.h>
 #endif
+#ifdef __FreeBSD__
+#include <unistd.h>
+#endif

 #include "instanceinfo.hpp"
 #include "logcat.hpp"
@@ -67,7 +71,7 @@ bool copyFileData(int sourceFd, int destFd, qint64 size) {
 	return true;
 #else
 	std::array<char, 64 * 1024> buffer = {};
-	auto remaining = totalTarget;
+	auto remaining = usize;

 	while (remaining > 0) {
 		auto chunk = std::min(remaining, buffer.size());
@@ -217,6 +221,7 @@ void LogManager::messageHandler(
 	}

 	if (display) {
+		auto locker = QMutexLocker(&self->stdoutMutex);
 		LogMessage::formatMessage(
 		    self->stdoutStream,
 		    message,
@@ -252,9 +257,21 @@ void LogManager::filterCategory(QLoggingCategory* category) {
 		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);
+	} else {
+		if (instance->lastCategoryFilter) {
+			instance->lastCategoryFilter(category);
+			filter = CategoryFilter(category);
+		}
+
+		// Hides virtual/override property warnings.
+		// Getting rid of this is blocked by https://qt-project.atlassian.net/browse/QTBUG-145977
+		// for internal Quickshell types, and may still be desired for shells that want to maintain
+		// compatibility with Qt versions prior to 6.11.
+		if (categoryName == QLatin1StringView("qt.qml.propertyCache.append")
+		    && !qEnvironmentVariableIsSet("QS_NO_FILTER_QT_LOGS"))
+		{
+			filter.warn = false;
+		}
 	}

 	for (const auto& rule: *instance->rules) {
@@ -287,6 +304,10 @@ void LogManager::init(
    const QString& rules,
    const QString& prefix
 ) {
+	static bool alreadyInitialized = false;
+	if (alreadyInitialized) return;
+	alreadyInitialized = true;
+
 	auto* instance = LogManager::instance();
 	instance->colorLogs = color;
 	instance->timestampLogs = timestamp;
@@ -305,32 +326,42 @@ void LogManager::init(
 		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();
+	if (instance->lastCategoryFilter == &LogManager::filterCategory) {
+		qCFatal(logLogging) << "Quickshell's log filter has been installed twice. This is a bug.";
+		instance->lastCategoryFilter = nullptr;
+	}

-	QMetaObject::invokeMethod(
-	    &instance->threadProxy,
-	    &LoggingThreadProxy::initInThread,
-	    Qt::BlockingQueuedConnection
-	);
+	qInstallMessageHandler(&LogManager::messageHandler);
+
+	instance->threadLogging = new ThreadLogging(instance);
+	instance->threadLogging->init();

 	qCDebug(logLogging) << "Logger initialized.";
 }

+void LogManager::initThreadLogging() {
+	auto* instance = LogManager::instance();
+
+	qCDebug(logLogging) << "Moving logger to dedicated thread...";
+
+	auto* thread = new QThread();
+	instance->threadLogging->setParent(nullptr);
+	instance->threadLogging->moveToThread(thread);
+	thread->start();
+
+	qCDebug(logLogging) << "Logger thread initialized.";
+}
+
 void initLogCategoryLevel(const char* name, QtMsgType defaultLevel) {
 	LogManager::instance()->defaultLevels.insert(QLatin1StringView(name), defaultLevel);
 }

 void LogManager::initFs() {
 	QMetaObject::invokeMethod(
-	    &LogManager::instance()->threadProxy,
-	    "initFs",
+	    LogManager::instance()->threadLogging,
+	    &ThreadLogging::initFs,
 	    Qt::BlockingQueuedConnection
 	);
 }
@@ -343,13 +374,6 @@ 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);

@@ -520,7 +544,7 @@ void ThreadLogging::initFs() {
 	    Qt::QueuedConnection
 	);

-	qCDebug(logLogging) << "Switched threaded logger to queued eventloop connection.";
+	qCDebug(logLogging) << "Switched threaded logger to queued event loop connection.";
 }

 void ThreadLogging::onMessage(const LogMessage& msg, bool showInSparse) {
@@ -10,6 +10,7 @@
 #include <qlatin1stringview.h>
 #include <qlogging.h>
 #include <qloggingcategory.h>
+#include <qmutex.h>
 #include <qobject.h>
 #include <qtmetamacros.h>

@@ -54,20 +55,6 @@ 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;
 }
@@ -103,6 +90,7 @@ public:
 	    const QString& prefix = ""
 	);

+	static void initThreadLogging();
 	static void initFs();
 	static LogManager* instance();

@@ -135,7 +123,8 @@ private:
 	QHash<QLatin1StringView, CategoryFilter> allFilters;

 	QTextStream stdoutStream;
-	LoggingThreadProxy threadProxy;
+	QMutex stdoutMutex;
+	ThreadLogging* threadLogging = nullptr;

 	friend void initLogCategoryLevel(const char* name, QtMsgType defaultLevel);
 };
@@ -114,9 +114,11 @@ public:
 	explicit ThreadLogging(QObject* parent): QObject(parent) {}

 	void init();
-	void initFs();
 	void setupFileLogging();

+public slots:
+	void initFs();
+
 private slots:
 	void onMessage(const LogMessage& msg, bool showInSparse);

@@ -138,6 +138,10 @@ public:
 		qsizetype oi = 0;
 		for (auto* object: newValues) {
 			if (this->mValuesList.length() == oi || this->mValuesList.at(oi) != object) {
+				// object may already be present further down (reorder case);
+				// drop the old row first so the same pointer is not inserted twice.
+				auto old = this->mValuesList.indexOf(object, oi);
+				if (old != -1) this->removeAt(old);
 				this->insertObject(object, oi);
 			}

@@ -1,6 +1,7 @@
 #include "paths.hpp"
 #include <cerrno>
 #include <cstdio>
+#include <tuple>
 #include <utility>

 #include <fcntl.h>
@@ -9,7 +10,6 @@
 #include <qdir.h>
 #include <qlogging.h>
 #include <qloggingcategory.h>
-#include <qpair.h>
 #include <qstandardpaths.h>
 #include <qtenvironmentvariables.h>
 #include <qtversionchecks.h>
@@ -64,7 +64,7 @@ QDir* QsPaths::baseRunDir() {
 	if (this->baseRunState == DirState::Unknown) {
 		auto runtimeDir = qEnvironmentVariable("XDG_RUNTIME_DIR");
 		if (runtimeDir.isEmpty()) {
-			runtimeDir = QString("/run/user/$1").arg(getuid());
+			runtimeDir = QString("/run/user/%1").arg(getuid());
 			qCInfo(logPaths) << "XDG_RUNTIME_DIR was not set, defaulting to" << runtimeDir;
 		}

@@ -412,10 +412,11 @@ bool QsPaths::checkLock(const QString& path, InstanceLockInfo* info, bool allowD
 	return true;
 }

-QPair<QVector<InstanceLockInfo>, QVector<InstanceLockInfo>>
+std::tuple<QVector<InstanceLockInfo>, QVector<InstanceLockInfo>, QVector<InstanceLockInfo>>
 QsPaths::collectInstances(const QString& path, const QString& display) {
 	qCDebug(logPaths) << "Collecting instances from" << path;
 	auto liveInstances = QVector<InstanceLockInfo>();
+	auto mismatchedInstances = QVector<InstanceLockInfo>();
 	auto deadInstances = QVector<InstanceLockInfo>();
 	auto dir = QDir(path);

@@ -427,20 +428,22 @@ QsPaths::collectInstances(const QString& path, const QString& display) {
 			qCDebug(logPaths).nospace() << "Found instance " << info.instance.instanceId << " (pid "
 			                            << info.pid << ") at " << path;

-			if (!display.isEmpty() && info.instance.display != display) {
-				qCDebug(logPaths) << "Skipped instance with mismatched display at" << path;
+			if (info.pid == -1) {
+				deadInstances.push_back(info);
 				continue;
 			}

-			if (info.pid == -1) {
-				deadInstances.push_back(info);
-			} else {
-				liveInstances.push_back(info);
+			if (!display.isEmpty() && info.instance.display != display) {
+				qCDebug(logPaths) << "Skipped instance with mismatched display at" << path;
+				mismatchedInstances.push_back(info);
+				continue;
 			}
+
+			liveInstances.push_back(info);
 		} else {
 			qCDebug(logPaths) << "Skipped potential instance at" << path;
 		}
 	}

-	return qMakePair(liveInstances, deadInstances);
+	return {liveInstances, mismatchedInstances, deadInstances};
 }
@@ -1,4 +1,7 @@
 #pragma once
+#include <tuple>
+
+#include <qcontainerfwd.h>
 #include <qdatetime.h>
 #include <qdir.h>
 #include <qpair.h>
@@ -29,7 +32,7 @@ public:
 	static QString ipcPath(const QString& id);
 	static bool
 	checkLock(const QString& path, InstanceLockInfo* info = nullptr, bool allowDead = false);
-	static QPair<QVector<InstanceLockInfo>, QVector<InstanceLockInfo>>
+	static std::tuple<QVector<InstanceLockInfo>, QVector<InstanceLockInfo>, QVector<InstanceLockInfo>>
 	collectInstances(const QString& path, const QString& display);

 	QDir* baseRunDir();
@@ -18,7 +18,6 @@
 #include <qwindow.h>

 #include "../window/proxywindow.hpp"
-#include "../window/windowinterface.hpp"
 #include "iconprovider.hpp"
 #include "model.hpp"
 #include "platformmenu_p.hpp"
@@ -91,10 +90,8 @@ bool PlatformMenuEntry::display(QObject* parentWindow, int relativeX, int relati
 	} else if (parentWindow == nullptr) {
 		qCritical() << "Cannot display PlatformMenuEntry with null parent window.";
 		return false;
-	} else if (auto* proxy = qobject_cast<ProxyWindowBase*>(parentWindow)) {
+	} else if (auto* proxy = ProxyWindowBase::forObject(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;
@@ -9,6 +9,18 @@ static QVector<QsEnginePlugin*> plugins; // NOLINT

 void QsEnginePlugin::registerPlugin(QsEnginePlugin& plugin) { plugins.push_back(&plugin); }

+void QsEnginePlugin::preinitPluginsOnly() {
+	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->preinit();
+	}
+}
+
 void QsEnginePlugin::initPlugins() {
 	plugins.removeIf([](QsEnginePlugin* plugin) { return !plugin->applies(); });

@@ -16,6 +28,10 @@ void QsEnginePlugin::initPlugins() {
 		return b->dependencies().contains(a->name());
 	});

+	for (QsEnginePlugin* plugin: plugins) {
+		plugin->preinit();
+	}
+
 	for (QsEnginePlugin* plugin: plugins) {
 		plugin->init();
 	}
@@ -18,12 +18,14 @@ public:
 	virtual QString name() { return QString(); }
 	virtual QList<QString> dependencies() { return {}; }
 	virtual bool applies() { return true; }
+	virtual void preinit() {}
 	virtual void init() {}
 	virtual void registerTypes() {}
 	virtual void constructGeneration(EngineGeneration& /*unused*/) {} // NOLINT
 	virtual void onReload() {}

 	static void registerPlugin(QsEnginePlugin& plugin);
+	static void preinitPluginsOnly();
 	static void initPlugins();
 	static void runConstructGeneration(EngineGeneration& generation);
 	static void runOnReload();
@@ -11,7 +11,6 @@
 #include <qwindow.h>

 #include "../window/proxywindow.hpp"
-#include "../window/windowinterface.hpp"
 #include "types.hpp"

 bool PopupAnchorState::operator==(const PopupAnchorState& other) const {
@@ -40,10 +39,8 @@ void PopupAnchor::setWindowInternal(QObject* window) {
 	}

 	if (window) {
-		if (auto* proxy = qobject_cast<ProxyWindowBase*>(window)) {
+		if (auto* proxy = ProxyWindowBase::forObject(window)) {
 			this->bProxyWindow = proxy;
-		} else if (auto* interface = qobject_cast<WindowInterface*>(window)) {
-			this->bProxyWindow = interface->proxyWindow();
 		} else {
 			qWarning() << "Tried to set popup anchor window to" << window
 			           << "which is not a quickshell window.";
@@ -96,6 +93,8 @@ void PopupAnchor::setItem(QQuickItem* item) {
 		QObject::connect(item, &QObject::destroyed, this, &PopupAnchor::onItemDestroyed);
 		QObject::connect(item, &QQuickItem::windowChanged, this, &PopupAnchor::onItemWindowChanged);
 	}
+
+	emit this->itemChanged();
 }

 void PopupAnchor::onWindowDestroyed() {
@@ -112,7 +111,7 @@ void PopupAnchor::onItemDestroyed() {
 }

 void PopupAnchor::onItemWindowChanged() {
-	if (auto* window = qobject_cast<ProxiedWindow*>(this->mItem->window())) {
+	if (auto* window = qobject_cast<ProxiedWindow*>(this->mItem ? this->mItem->window() : nullptr)) {
 		this->setWindowInternal(window->proxy());
 	} else {
 		this->setWindowInternal(nullptr);
@@ -18,14 +18,17 @@
 #include <qscreen.h>
 #include <qtenvironmentvariables.h>
 #include <qtmetamacros.h>
+#include <qtversion.h>
 #include <qtypes.h>
 #include <qvariant.h>
+#include <qversionnumber.h>
 #include <qwindowdefs.h>
 #include <unistd.h>

 #include "../io/processcore.hpp"
 #include "generation.hpp"
 #include "iconimageprovider.hpp"
+#include "instanceinfo.hpp"
 #include "paths.hpp"
 #include "qmlscreen.hpp"
 #include "rootwrapper.hpp"
@@ -60,7 +63,9 @@ void QuickshellSettings::setWorkingDirectory(QString workingDirectory) { // NOLI
 	emit this->workingDirectoryChanged();
 }

-bool QuickshellSettings::watchFiles() const { return this->mWatchFiles; }
+bool QuickshellSettings::watchFiles() const {
+	return this->mWatchFiles && qEnvironmentVariableIsEmpty("QS_DISABLE_FILE_WATCHER");
+}

 void QuickshellSettings::setWatchFiles(bool watchFiles) {
 	if (watchFiles == this->mWatchFiles) return;
@@ -83,6 +88,8 @@ QuickshellTracked::QuickshellTracked() {
 	}
 }

+// FIXME: Some callers can potentially pass a freed QScreen here which is why we don't init a new one.
+// The QuickshellTracked::init() in launch.cpp makes sure our screenAdded handler runs first for now.
 QuickshellScreenInfo* QuickshellTracked::screenInfo(QScreen* screen) const {
 	for (auto* info: this->screens) {
 		if (info->screen == screen) return info;
@@ -91,13 +98,19 @@ QuickshellScreenInfo* QuickshellTracked::screenInfo(QScreen* screen) const {
 	return nullptr;
 }

+namespace {
+static QuickshellTracked* qsTrackedInstance = nullptr; // NOLINT
+}
+
+void QuickshellTracked::init() {
+	if (qsTrackedInstance) qFatal() << "Tried to reinitialize QuickshellTracked";
+	qsTrackedInstance = new QuickshellTracked();
+	QJSEngine::setObjectOwnership(qsTrackedInstance, QJSEngine::CppOwnership);
+}
+
 QuickshellTracked* QuickshellTracked::instance() {
-	static QuickshellTracked* instance = nullptr; // NOLINT
-	if (instance == nullptr) {
-		QJSEngine::setObjectOwnership(instance, QJSEngine::CppOwnership);
-		instance = new QuickshellTracked();
-	}
-	return instance;
+	if (!qsTrackedInstance) qFatal() << "Tried to get QuickshellTracked instance before init";
+	return qsTrackedInstance;
 }

 void QuickshellTracked::updateScreens() {
@@ -151,6 +164,22 @@ qint32 QuickshellGlobal::processId() const { // NOLINT
 	return getpid();
 }

+QString QuickshellGlobal::instanceId() const { // NOLINT
+	return InstanceInfo::CURRENT.instanceId;
+}
+
+QString QuickshellGlobal::shellId() const { // NOLINT
+	return InstanceInfo::CURRENT.shellId;
+}
+
+QString QuickshellGlobal::appId() const { // NOLINT
+	return InstanceInfo::CURRENT.appId;
+}
+
+QDateTime QuickshellGlobal::launchTime() const { // NOLINT
+	return InstanceInfo::CURRENT.launchTime;
+}
+
 qsizetype QuickshellGlobal::screensCount(QQmlListProperty<QuickshellScreenInfo>* /*unused*/) {
 	return QuickshellTracked::instance()->screens.size();
 }
@@ -324,6 +353,12 @@ bool QuickshellGlobal::hasVersion(qint32 major, qint32 minor) {
 	return QuickshellGlobal::hasVersion(major, minor, QStringList());
 }

+bool QuickshellGlobal::hasQtVersion(int major, int minor) {
+	auto qtVersion = QVersionNumber::fromString(qVersion());
+	auto requiredVersion = QVersionNumber(major, minor);
+	return qtVersion >= requiredVersion;
+}
+
 QuickshellGlobal* QuickshellGlobal::create(QQmlEngine* engine, QJSEngine* /*unused*/) {
 	auto* qsg = new QuickshellGlobal();
 	auto* generation = EngineGeneration::findEngineGeneration(engine);
@@ -17,6 +17,7 @@

 #include "../io/processcore.hpp"
 #include "doc.hpp"
+#include "instanceinfo.hpp"
 #include "qmlscreen.hpp"

 ///! Accessor for some options under the Quickshell type.
@@ -69,6 +70,7 @@ public:
 	QVector<QuickshellScreenInfo*> screens;
 	QuickshellScreenInfo* screenInfo(QScreen* screen) const;

+	static void init();
 	static QuickshellTracked* instance();

 private slots:
@@ -83,6 +85,21 @@ class QuickshellGlobal: public QObject {
 	// clang-format off
 	/// Quickshell's process id.
 	Q_PROPERTY(qint32 processId READ processId CONSTANT);
+	/// A unique identifier for this Quickshell instance
+	Q_PROPERTY(QString instanceId READ instanceId CONSTANT)
+	/// The shell ID, used to differentiate between different shell configurations.
+	///
+	/// Defaults to a stable value derived from the config path.
+	/// Can be overridden with `//@ pragma ShellId <id>` in the root qml file.
+	Q_PROPERTY(QString shellId READ shellId CONSTANT)
+	/// The desktop application ID.
+	///
+	/// Defaults to `org.quickshell`.
+	/// Can be overridden with `//@ pragma AppId <id>` in the root qml file
+	/// or the `QS_APP_ID` environment variable.
+	Q_PROPERTY(QString appId READ appId CONSTANT)
+	/// The time at which this Quickshell instance was launched.
+	Q_PROPERTY(QDateTime launchTime READ launchTime CONSTANT)
 	/// All currently connected screens.
 	///
 	/// This property updates as connected screens change.
@@ -149,6 +166,10 @@ class QuickshellGlobal: public QObject {

 public:
 	[[nodiscard]] qint32 processId() const;
+	[[nodiscard]] QString instanceId() const;
+	[[nodiscard]] QString shellId() const;
+	[[nodiscard]] QString appId() const;
+	[[nodiscard]] QDateTime launchTime() const;

 	QQmlListProperty<QuickshellScreenInfo> screens();

@@ -224,7 +245,7 @@ public:
 	/// it is assumed that all unreleased features are present. The unreleased feature list
 	/// may be omitted.
 	///
-	/// > [!NOTE] You can feature gate code blocks using Quickshell's preprocessor which
+	/// > [!NOTE] You can version gate code blocks using Quickshell's preprocessor which
 	/// > has the same function available.
 	/// >
 	/// > ```qml
@@ -234,6 +255,17 @@ public:
 	/// > ```
 	Q_INVOKABLE static bool hasVersion(qint32 major, qint32 minor, const QStringList& features);
 	Q_INVOKABLE static bool hasVersion(qint32 major, qint32 minor);
+	/// Check if Qt's version is at least `major.minor`.
+	///
+	/// > [!NOTE] You can version gate code blocks using Quickshell's preprocessor which
+	/// > has the same function available.
+	/// >
+	/// > ```qml
+	/// > //@ if hasVersion(6, 10)
+	/// > ...
+	/// > //@ endif
+	/// > ```
+	Q_INVOKABLE static bool hasQtVersion(qint32 major, qint32 minor);

 	void clearReloadPopupInhibit() { this->mInhibitReloadPopup = false; }
 	[[nodiscard]] bool isReloadPopupInhibited() const { return this->mInhibitReloadPopup; }
@@ -15,7 +15,7 @@
 /// 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
+/// > [!WARNING] If the monitor is disconnected, then 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.
 ///
@@ -74,6 +74,7 @@ void QsMenuAnchor::onClosed() {
 	this->mOpen = false;

 	if (this->platformMenu) {
+		QObject::disconnect(this->platformMenu, nullptr, this, nullptr);
 		this->platformMenu->deleteLater();
 		this->platformMenu = nullptr;
 	}
@@ -101,7 +102,12 @@ void QsMenuAnchor::setMenu(QsMenuHandle* menu) {
 	if (menu == this->mMenu) return;

 	if (this->mMenu != nullptr) {
-		if (this->platformMenu != nullptr) this->platformMenu->deleteLater();
+		if (this->platformMenu != nullptr) {
+			QObject::disconnect(this->platformMenu, nullptr, this, nullptr);
+			this->platformMenu->deleteLater();
+			this->platformMenu = nullptr;
+		}
+
 		QObject::disconnect(this->mMenu, nullptr, this, nullptr);
 	}

@@ -1,4 +1,5 @@
 #include "region.hpp"
+#include <algorithm>
 #include <cmath>

 #include <qobject.h>
@@ -18,6 +19,11 @@ PendingRegion::PendingRegion(QObject* parent): QObject(parent) {
 	QObject::connect(this, &PendingRegion::yChanged, this, &PendingRegion::changed);
 	QObject::connect(this, &PendingRegion::widthChanged, this, &PendingRegion::changed);
 	QObject::connect(this, &PendingRegion::heightChanged, this, &PendingRegion::changed);
+	QObject::connect(this, &PendingRegion::radiusChanged, this, &PendingRegion::changed);
+	QObject::connect(this, &PendingRegion::topLeftRadiusChanged, this, &PendingRegion::changed);
+	QObject::connect(this, &PendingRegion::topRightRadiusChanged, this, &PendingRegion::changed);
+	QObject::connect(this, &PendingRegion::bottomLeftRadiusChanged, this, &PendingRegion::changed);
+	QObject::connect(this, &PendingRegion::bottomRightRadiusChanged, this, &PendingRegion::changed);
 	QObject::connect(this, &PendingRegion::childrenChanged, this, &PendingRegion::changed);
 }

@@ -45,6 +51,79 @@ void PendingRegion::onItemDestroyed() { this->mItem = nullptr; }

 void PendingRegion::onChildDestroyed() { this->mRegions.removeAll(this->sender()); }

+qint32 PendingRegion::radius() const { return this->mRadius; }
+
+void PendingRegion::setRadius(qint32 radius) {
+	if (radius == this->mRadius) return;
+	this->mRadius = radius;
+	emit this->radiusChanged();
+
+	if (!(this->mCornerOverrides & TopLeft)) emit this->topLeftRadiusChanged();
+	if (!(this->mCornerOverrides & TopRight)) emit this->topRightRadiusChanged();
+	if (!(this->mCornerOverrides & BottomLeft)) emit this->bottomLeftRadiusChanged();
+	if (!(this->mCornerOverrides & BottomRight)) emit this->bottomRightRadiusChanged();
+}
+
+qint32 PendingRegion::topLeftRadius() const {
+	return (this->mCornerOverrides & TopLeft) ? this->mTopLeftRadius : this->mRadius;
+}
+
+void PendingRegion::setTopLeftRadius(qint32 radius) {
+	this->mTopLeftRadius = radius;
+	this->mCornerOverrides |= TopLeft;
+	emit this->topLeftRadiusChanged();
+}
+
+void PendingRegion::resetTopLeftRadius() {
+	this->mCornerOverrides &= ~TopLeft;
+	emit this->topLeftRadiusChanged();
+}
+
+qint32 PendingRegion::topRightRadius() const {
+	return (this->mCornerOverrides & TopRight) ? this->mTopRightRadius : this->mRadius;
+}
+
+void PendingRegion::setTopRightRadius(qint32 radius) {
+	this->mTopRightRadius = radius;
+	this->mCornerOverrides |= TopRight;
+	emit this->topRightRadiusChanged();
+}
+
+void PendingRegion::resetTopRightRadius() {
+	this->mCornerOverrides &= ~TopRight;
+	emit this->topRightRadiusChanged();
+}
+
+qint32 PendingRegion::bottomLeftRadius() const {
+	return (this->mCornerOverrides & BottomLeft) ? this->mBottomLeftRadius : this->mRadius;
+}
+
+void PendingRegion::setBottomLeftRadius(qint32 radius) {
+	this->mBottomLeftRadius = radius;
+	this->mCornerOverrides |= BottomLeft;
+	emit this->bottomLeftRadiusChanged();
+}
+
+void PendingRegion::resetBottomLeftRadius() {
+	this->mCornerOverrides &= ~BottomLeft;
+	emit this->bottomLeftRadiusChanged();
+}
+
+qint32 PendingRegion::bottomRightRadius() const {
+	return (this->mCornerOverrides & BottomRight) ? this->mBottomRightRadius : this->mRadius;
+}
+
+void PendingRegion::setBottomRightRadius(qint32 radius) {
+	this->mBottomRightRadius = radius;
+	this->mCornerOverrides |= BottomRight;
+	emit this->bottomRightRadiusChanged();
+}
+
+void PendingRegion::resetBottomRightRadius() {
+	this->mCornerOverrides &= ~BottomRight;
+	emit this->bottomRightRadiusChanged();
+}
+
 QQmlListProperty<PendingRegion> PendingRegion::regions() {
 	return QQmlListProperty<PendingRegion>(
 	    this,
@@ -90,6 +169,60 @@ QRegion PendingRegion::build() const {
 		region = QRegion(this->mX, this->mY, this->mWidth, this->mHeight, type);
 	}

+	if (this->mShape == RegionShape::Rect && !region.isEmpty()) {
+		auto tl = std::max(this->topLeftRadius(), 0);
+		auto tr = std::max(this->topRightRadius(), 0);
+		auto bl = std::max(this->bottomLeftRadius(), 0);
+		auto br = std::max(this->bottomRightRadius(), 0);
+
+		if (tl > 0 || tr > 0 || bl > 0 || br > 0) {
+			auto rect = region.boundingRect();
+			auto x = rect.x();
+			auto y = rect.y();
+			auto w = rect.width();
+			auto h = rect.height();
+
+			// Normalize so adjacent corners don't exceed their shared edge.
+			// Each corner is scaled by the tightest constraint of its two edges.
+			auto topScale = tl + tr > w ? static_cast<double>(w) / (tl + tr) : 1.0;
+			auto bottomScale = bl + br > w ? static_cast<double>(w) / (bl + br) : 1.0;
+			auto leftScale = tl + bl > h ? static_cast<double>(h) / (tl + bl) : 1.0;
+			auto rightScale = tr + br > h ? static_cast<double>(h) / (tr + br) : 1.0;
+
+			tl = static_cast<qint32>(tl * std::min(topScale, leftScale));
+			tr = static_cast<qint32>(tr * std::min(topScale, rightScale));
+			bl = static_cast<qint32>(bl * std::min(bottomScale, leftScale));
+			br = static_cast<qint32>(br * std::min(bottomScale, rightScale));
+
+			// Unlock each corner: subtract (cornerBox - quarterEllipse) from the
+			// full rect. Each corner only modifies pixels inside its own box,
+			// so no diagonal overlap is possible.
+			if (tl > 0) {
+				auto box = QRegion(x, y, tl, tl);
+				auto ellipse = QRegion(x, y, tl * 2, tl * 2, QRegion::Ellipse);
+				region -= box - (ellipse & box);
+			}
+
+			if (tr > 0) {
+				auto box = QRegion(x + w - tr, y, tr, tr);
+				auto ellipse = QRegion(x + w - tr * 2, y, tr * 2, tr * 2, QRegion::Ellipse);
+				region -= box - (ellipse & box);
+			}
+
+			if (bl > 0) {
+				auto box = QRegion(x, y + h - bl, bl, bl);
+				auto ellipse = QRegion(x, y + h - bl * 2, bl * 2, bl * 2, QRegion::Ellipse);
+				region -= box - (ellipse & box);
+			}
+
+			if (br > 0) {
+				auto box = QRegion(x + w - br, y + h - br, br, br);
+				auto ellipse = QRegion(x + w - br * 2, y + h - br * 2, br * 2, br * 2, QRegion::Ellipse);
+				region -= box - (ellipse & box);
+			}
+		}
+	}
+
 	for (const auto& childRegion: this->mRegions) {
 		region = childRegion->applyTo(region);
 	}
@@ -109,7 +242,7 @@ QRegion PendingRegion::applyTo(QRegion& region) const {
 }

 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 left as the default, don't combine it with the whole rect area, leave it as is.
 	if (this->mIntersection == Intersection::Combine) {
 		return this->build();
 	} else {
@@ -66,6 +66,29 @@ class PendingRegion: public QObject {
 	Q_PROPERTY(qint32 width MEMBER mWidth NOTIFY widthChanged);
 	/// Defaults to 0. Does nothing if @@item is set.
 	Q_PROPERTY(qint32 height MEMBER mHeight NOTIFY heightChanged);
+	// clang-format off
+	/// Corner radius for rounded rectangles. Only applies when @@shape is `Rect`. Defaults to 0.
+	///
+	/// Acts as the default for @@topLeftRadius, @@topRightRadius, @@bottomLeftRadius,
+	/// and @@bottomRightRadius.
+	Q_PROPERTY(qint32 radius READ radius WRITE setRadius NOTIFY radiusChanged);
+	/// Top-left corner radius. Only applies when @@shape is `Rect`.
+	///
+	/// Defaults to @@radius, and may be reset by assigning `undefined`.
+	Q_PROPERTY(qint32 topLeftRadius READ topLeftRadius WRITE setTopLeftRadius RESET resetTopLeftRadius NOTIFY topLeftRadiusChanged);
+	/// Top-right corner radius. Only applies when @@shape is `Rect`.
+	///
+	/// Defaults to @@radius, and may be reset by assigning `undefined`.
+	Q_PROPERTY(qint32 topRightRadius READ topRightRadius WRITE setTopRightRadius RESET resetTopRightRadius NOTIFY topRightRadiusChanged);
+	/// Bottom-left corner radius. Only applies when @@shape is `Rect`.
+	///
+	/// Defaults to @@radius, and may be reset by assigning `undefined`.
+	Q_PROPERTY(qint32 bottomLeftRadius READ bottomLeftRadius WRITE setBottomLeftRadius RESET resetBottomLeftRadius NOTIFY bottomLeftRadiusChanged);
+	/// Bottom-right corner radius. Only applies when @@shape is `Rect`.
+	///
+	/// Defaults to @@radius, and may be reset by assigning `undefined`.
+	Q_PROPERTY(qint32 bottomRightRadius READ bottomRightRadius WRITE setBottomRightRadius RESET resetBottomRightRadius NOTIFY bottomRightRadiusChanged);
+	// clang-format on

 	/// Regions to apply on top of this region.
 	///
@@ -91,6 +114,25 @@ public:

 	void setItem(QQuickItem* item);

+	[[nodiscard]] qint32 radius() const;
+	void setRadius(qint32 radius);
+
+	[[nodiscard]] qint32 topLeftRadius() const;
+	void setTopLeftRadius(qint32 radius);
+	void resetTopLeftRadius();
+
+	[[nodiscard]] qint32 topRightRadius() const;
+	void setTopRightRadius(qint32 radius);
+	void resetTopRightRadius();
+
+	[[nodiscard]] qint32 bottomLeftRadius() const;
+	void setBottomLeftRadius(qint32 radius);
+	void resetBottomLeftRadius();
+
+	[[nodiscard]] qint32 bottomRightRadius() const;
+	void setBottomRightRadius(qint32 radius);
+	void resetBottomRightRadius();
+
 	QQmlListProperty<PendingRegion> regions();

 	[[nodiscard]] bool empty() const;
@@ -109,6 +151,11 @@ signals:
 	void yChanged();
 	void widthChanged();
 	void heightChanged();
+	void radiusChanged();
+	void topLeftRadiusChanged();
+	void topRightRadiusChanged();
+	void bottomLeftRadiusChanged();
+	void bottomRightRadiusChanged();
 	void childrenChanged();

 	/// Triggered when the region's geometry changes.
@@ -130,12 +177,25 @@ private:
 	static void
 	regionsReplace(QQmlListProperty<PendingRegion>* prop, qsizetype i, PendingRegion* region);

+	enum CornerOverride : quint8 {
+		TopLeft = 0b1,
+		TopRight = 0b10,
+		BottomLeft = 0b100,
+		BottomRight = 0b1000,
+	};
+
 	QQuickItem* mItem = nullptr;

 	qint32 mX = 0;
 	qint32 mY = 0;
 	qint32 mWidth = 0;
 	qint32 mHeight = 0;
+	qint32 mRadius = 0;
+	qint32 mTopLeftRadius = 0;
+	qint32 mTopRightRadius = 0;
+	qint32 mBottomLeftRadius = 0;
+	qint32 mBottomRightRadius = 0;
+	quint8 mCornerOverrides = 0;

 	QList<PendingRegion*> mRegions;
 };
@@ -116,7 +116,7 @@ QObject* Reloadable::getChildByReloadId(QObject* parent, const QString& reloadId
 		auto* reloadable = qobject_cast<Reloadable*>(child);
 		if (reloadable != nullptr) {
 			if (reloadable->mReloadableId == reloadId) return reloadable;
-			// if not then don't check its children as thats a seperate reload scope.
+			// if not then don't check its children as that's a separate reload scope.
 		} else {
 			auto* reloadable = Reloadable::getChildByReloadId(child, reloadId);
 			if (reloadable != nullptr) return reloadable;
@@ -21,7 +21,7 @@ class Reloadable
 	/// previous state.
 	///
 	/// Simply keeping a stable identifier across config versions (saves) is
-	/// enough to help the reloader figure out which object in the old revision corrosponds to
+	/// enough to help the reloader figure out which object in the old revision corresponds to
 	/// 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.
@@ -3,6 +3,7 @@
 #include <utility>

 #include <qcontainerfwd.h>
+#include <qcryptographichash.h>
 #include <qdir.h>
 #include <qfileinfo.h>
 #include <qjsengine.h>
@@ -21,6 +22,25 @@

 QS_LOGGING_CATEGORY(logQmlScanner, "quickshell.qmlscanner", QtWarningMsg);

+bool QmlScanner::readAndHashFile(const QString& path, QByteArray& data) {
+	auto file = QFile(path);
+	if (!file.open(QFile::ReadOnly)) return false;
+	data = file.readAll();
+	this->fileHashes.insert(path, QCryptographicHash::hash(data, QCryptographicHash::Md5));
+	return true;
+}
+
+bool QmlScanner::hasFileContentChanged(const QString& path) const {
+	auto it = this->fileHashes.constFind(path);
+	if (it == this->fileHashes.constEnd()) return true;
+
+	auto file = QFile(path);
+	if (!file.open(QFile::ReadOnly)) return true;
+
+	auto newHash = QCryptographicHash::hash(file.readAll(), QCryptographicHash::Md5);
+	return newHash != it.value();
+}
+
 void QmlScanner::scanDir(const QDir& dir) {
 	if (this->scannedDirs.contains(dir)) return;
 	this->scannedDirs.push_back(dir);
@@ -69,7 +89,7 @@ void QmlScanner::scanDir(const QDir& dir) {
 		QString qmldir;
 		auto stream = QTextStream(&qmldir);

-		// cant derive a module name if not in shell path
+		// can't derive a module name if not in shell path
 		if (path.startsWith(this->rootPath.path())) {
 			auto end = path.sliced(this->rootPath.path().length());

@@ -109,13 +129,13 @@ bool QmlScanner::scanQmlFile(const QString& path, bool& singleton, bool& interna

 	qCDebug(logQmlScanner) << "Scanning qml file" << path;

-	auto file = QFile(path);
-	if (!file.open(QFile::ReadOnly | QFile::Text)) {
+	QByteArray fileData;
+	if (!this->readAndHashFile(path, fileData)) {
 		qCWarning(logQmlScanner) << "Failed to open file" << path;
 		return false;
 	}

-	auto stream = QTextStream(&file);
+	auto stream = QTextStream(&fileData);
 	auto imports = QVector<QString>();

 	bool inHeader = true;
@@ -125,10 +145,7 @@ bool QmlScanner::scanQmlFile(const QString& path, bool& singleton, bool& interna
 	QString overrideText;
 	bool isOverridden = false;

-	auto pragmaEngine = QJSEngine();
-	pragmaEngine.globalObject().setPrototype(
-	    pragmaEngine.newQObject(new qs::scan::env::PreprocEnv())
-	);
+	auto& pragmaEngine = *QmlScanner::preprocEngine();

 	auto postError = [&, this](QString error) {
 		this->scanErrors.append({.file = path, .message = std::move(error), .line = lineNum});
@@ -143,7 +160,7 @@ bool QmlScanner::scanQmlFile(const QString& path, bool& singleton, bool& interna
 			if (!singleton && line == "pragma Singleton") {
 				singleton = true;
 			} else if (line.startsWith("import")) {
-				// we dont care about "import qs" as we always load the root folder
+				// we don't care about "import qs" as we always load the root folder
 				if (auto importCursor = line.indexOf(" qs."); importCursor != -1) {
 					importCursor += 4;
 					QString path;
@@ -194,7 +211,7 @@ bool QmlScanner::scanQmlFile(const QString& path, bool& singleton, bool& interna
 				mask = false;
 			}
 			if (!sourceMasked && mask) hideMask = true;
-			mask = sourceMasked || mask; // cant unmask if a nested if passes
+			mask = sourceMasked || mask; // can't unmask if a nested if passes
 			ifScopes.append(mask);
 			if (mask) isOverridden = true;
 			sourceMasked = mask;
@@ -219,8 +236,6 @@ bool QmlScanner::scanQmlFile(const QString& path, bool& singleton, bool& interna
 		postError("unclosed preprocessor if block");
 	}

-	file.close();
-
 	if (isOverridden) {
 		this->fileIntercepts.insert(path, overrideText);
 	}
@@ -257,8 +272,11 @@ bool QmlScanner::scanQmlFile(const QString& path, bool& singleton, bool& interna
 			continue;
 		}

-		if (import.endsWith(".js")) this->scannedFiles.push_back(cpath);
-		else this->scanDir(cpath);
+		if (import.endsWith(".js")) {
+			this->scannedFiles.push_back(cpath);
+			QByteArray jsData;
+			this->readAndHashFile(cpath, jsData);
+		} else this->scanDir(cpath);
 	}

 	return true;
@@ -273,14 +291,12 @@ void QmlScanner::scanQmlRoot(const QString& path) {
 bool QmlScanner::scanQmlJson(const QString& path) {
 	qCDebug(logQmlScanner) << "Scanning qml.json file" << path;

-	auto file = QFile(path);
-	if (!file.open(QFile::ReadOnly | QFile::Text)) {
+	QByteArray data;
+	if (!this->readAndHashFile(path, data)) {
 		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);
@@ -351,3 +367,13 @@ QPair<QString, QString> QmlScanner::jsonToQml(const QJsonValue& value, int inden
 		return qMakePair(QStringLiteral("var"), "null");
 	}
 }
+
+QJSEngine* QmlScanner::preprocEngine() {
+	static auto* engine = [] {
+		auto* engine = new QJSEngine();
+		engine->globalObject().setPrototype(engine->newQObject(new qs::scan::env::PreprocEnv()));
+		return engine;
+	}();
+
+	return engine;
+}
@@ -1,8 +1,10 @@
 #pragma once

+#include <qbytearray.h>
 #include <qcontainerfwd.h>
 #include <qdir.h>
 #include <qhash.h>
+#include <qjsengine.h>
 #include <qloggingcategory.h>
 #include <qvector.h>

@@ -21,6 +23,7 @@ public:

 	QVector<QDir> scannedDirs;
 	QVector<QString> scannedFiles;
+	QHash<QString, QByteArray> fileHashes;
 	QHash<QString, QString> fileIntercepts;

 	struct ScanError {
@@ -31,10 +34,15 @@ public:

 	QVector<ScanError> scanErrors;

+	bool readAndHashFile(const QString& path, QByteArray& data);
+	[[nodiscard]] bool hasFileContentChanged(const QString& path) const;
+
 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);
+
+	static QJSEngine* preprocEngine();
 };
@@ -2,6 +2,8 @@

 #include <qcontainerfwd.h>
 #include <qtenvironmentvariables.h>
+#include <qtversion.h>
+#include <qversionnumber.h>

 #include "build.hpp"

@@ -20,6 +22,12 @@ bool PreprocEnv::hasVersion(int major, int minor, const QStringList& features) {
 	return QS_VERSION_MAJOR == major && QS_VERSION_MINOR == minor;
 }

+bool PreprocEnv::hasQtVersion(int major, int minor) {
+	auto qtVersion = QVersionNumber::fromString(qVersion());
+	auto requiredVersion = QVersionNumber(major, minor);
+	return qtVersion >= requiredVersion;
+}
+
 QString PreprocEnv::env(const QString& variable) {
 	return qEnvironmentVariable(variable.toStdString().c_str());
 }
@@ -12,6 +12,7 @@ class PreprocEnv: public QObject {
 public:
 	Q_INVOKABLE static bool
 	hasVersion(int major, int minor, const QStringList& features = QStringList());
+	Q_INVOKABLE static bool hasQtVersion(int major, int minor);

 	Q_INVOKABLE static QString env(const QString& variable);
 	Q_INVOKABLE static bool isEnvSet(const QString& variable);
@@ -4,39 +4,102 @@

 #include <qabstractitemmodel.h>
 #include <qcontainerfwd.h>
+#include <qjsvalue.h>
+#include <qjsvalueiterator.h>
 #include <qlist.h>
 #include <qnamespace.h>
+#include <qobject.h>
 #include <qtmetamacros.h>
 #include <qtversionchecks.h>
 #include <qtypes.h>
 #include <qvariant.h>

-void ScriptModel::updateValuesUnique(const QVariantList& newValues) {
-	this->hasActiveIterators = true;
+namespace {
+struct RecursionPair {
+	const QJSValue* a;
+	const QJSValue* b;
+	const RecursionPair* previous;
+};
+
+bool qjsValueStructuralEq(
+    const QJSValue& a,
+    const QJSValue& b,
+    const RecursionPair* activePair = nullptr
+) {
+	if (a.strictlyEquals(b)) return true;
+
+	const auto jsValueType = QMetaType::fromType<QJSValue>();
+	const auto aIsNative = a.toVariant(QJSValue::RetainJSObjects).metaType() != jsValueType;
+	const auto bIsNative = b.toVariant(QJSValue::RetainJSObjects).metaType() != jsValueType;
+	if (aIsNative || bIsNative) return false;
+
+	if (!a.isObject() || !b.isObject() || a.isCallable() || b.isCallable()) return false;
+	if (a.isArray() != b.isArray()) return false;
+
+	for (const auto* pair = activePair; pair != nullptr; pair = pair->previous) {
+		if (a.strictlyEquals(*pair->a) || b.strictlyEquals(*pair->b)) return false;
+	}
+
+	const auto nextActivePair = RecursionPair {.a = &a, .b = &b, .previous = activePair};
+
+	auto aIter = QJSValueIterator(a);
+	auto bIter = QJSValueIterator(b);
+
+	while (aIter.hasNext()) {
+		if (!bIter.hasNext()) return false;
+
+		aIter.next();
+		bIter.next();
+
+		const auto aName = aIter.name();
+		const auto bName = bIter.name();
+		const auto aValue = aIter.value();
+
+		if (aName == bName) {
+			const auto bValue = bIter.value();
+			if (!qjsValueStructuralEq(aValue, bValue, &nextActivePair)) return false;
+		} else {
+			if (!b.hasOwnProperty(aName)) return false;
+
+			const auto bValue = b.property(aName);
+			if (!qjsValueStructuralEq(aValue, bValue, &nextActivePair)) return false;
+		}
+	}
+
+	return !bIter.hasNext();
+}
+} // namespace
+
+bool ScriptModel::updateValuesUnique(const QList<QJSValue>& newValues) {
+	auto anyChanges = false;
+
+	this->isModifying = true;
 	this->mValues.reserve(newValues.size());

 	auto iter = this->mValues.begin();
 	auto newIter = newValues.begin();

-	// TODO: cache this
-	auto getCmpKey = [this](const QVariant& v) {
-		if (v.canConvert<QVariantMap>()) {
-			auto vMap = v.value<QVariantMap>();
-			if (vMap.contains(this->cmpKey)) {
-				return vMap.value(this->cmpKey);
-			}
+	auto comparisonValue = [this](const QJSValue& value) {
+		if (value.hasProperty(this->cmpKey)) return value.property(this->cmpKey);
+
+		return value;
+	};
+
+	auto valueCmp = [&, this](const QJSValue& a, const QJSValue& b) {
+		if (a.strictlyEquals(b)) return true;
+
+		const auto aValue = this->cmpKey.isEmpty() ? a : comparisonValue(a);
+		const auto bValue = this->cmpKey.isEmpty() ? b : comparisonValue(b);
+
+		if (this->mComparisonMode == ObjectComparison::Identity) {
+			return aValue.strictlyEquals(bValue);
+		} else {
+			return qjsValueStructuralEq(aValue, bValue);
 		}
-
-		return v;
 	};

-	auto variantCmp = [&, this](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); };
+	auto eqPredicate = [&](const QJSValue& b) {
+		return [&](const QJSValue& a) { return valueCmp(a, b); };
 	};

 	while (true) {
@@ -49,6 +112,7 @@ void ScriptModel::updateValuesUnique(const QVariantList& newValues) {
 			this->beginRemoveRows(QModelIndex(), startIndex, endIndex);
 			this->mValues.erase(iter, this->mValues.end());
 			this->endRemoveRows();
+			anyChanges = true;

 			break;
 		} else if (iter == this->mValues.end()) {
@@ -59,9 +123,10 @@ void ScriptModel::updateValuesUnique(const QVariantList& newValues) {
 			this->beginInsertRows(QModelIndex(), startIndex, endIndex);
 			this->mValues.append(newValues.sliced(startIndex));
 			this->endInsertRows();
+			anyChanges = true;

 			break;
-		} else if (!variantCmp(*newIter, *iter)) {
+		} else if (!valueCmp(*newIter, *iter)) {
 			auto oldIter = std::find_if(iter, this->mValues.end(), eqPredicate(*newIter));

 			if (oldIter != this->mValues.end()) {
@@ -81,6 +146,7 @@ void ScriptModel::updateValuesUnique(const QVariantList& newValues) {
 					this->beginRemoveRows(QModelIndex(), startIndex, index - 1);
 					iter = this->mValues.erase(startIter, iter);
 					this->endRemoveRows();
+					anyChanges = true;
 				} else {
 					// Advance iters to capture a whole move sequence as a single operation if possible.
 					auto oldStartIter = oldIter;
@@ -88,7 +154,7 @@ void ScriptModel::updateValuesUnique(const QVariantList& newValues) {
 						++oldIter;
 						++newIter;
 					} while (oldIter != this->mValues.end() && newIter != newValues.end()
-					         && variantCmp(*oldIter, *newIter));
+					         && valueCmp(*oldIter, *newIter));

 					auto index = static_cast<qint32>(std::distance(this->mValues.begin(), iter));
 					auto oldStartIndex =
@@ -105,6 +171,7 @@ void ScriptModel::updateValuesUnique(const QVariantList& newValues) {

 					iter = this->mValues.begin() + (index + len);
 					this->endMoveRows();
+					anyChanges = true;
 				}
 			} else {
 				auto startNewIter = newIter;
@@ -130,8 +197,9 @@ void ScriptModel::updateValuesUnique(const QVariantList& newValues) {
 				std::move_backward(iter, this->mValues.end() - len, this->mValues.end());
 				iter = std::copy(startNewIter, newIter, iter);
 				this->endInsertRows();
+				anyChanges = true;
 			}
-		} else if (*newIter != *iter) {
+		} else if (!newIter->strictlyEquals(*iter)) {
 			auto first = static_cast<qint32>(std::distance(this->mValues.begin(), iter));
 			auto index = first;

@@ -140,26 +208,42 @@ void ScriptModel::updateValuesUnique(const QVariantList& newValues) {
 				++iter;
 				++newIter;
 				++index;
-			} while (iter != this->mValues.end() && newIter != newValues.end() && *newIter != *iter);
+			} while (iter != this->mValues.end() && newIter != newValues.end()
+			         && !newIter->strictlyEquals(*iter));

 			this->dataChanged(
 			    this->index(first, 0, QModelIndex()),
 			    this->index(index - 1, 0, QModelIndex()),
 			    {Qt::UserRole}
 			);
+
+			anyChanges = true;
 		} else {
 			++iter;
 			++newIter;
 		}
 	}

-	this->hasActiveIterators = false;
+	this->isModifying = false;
+
+	if (this->stagedValues.has_value()) {
+		auto values = *this->stagedValues;
+		this->stagedValues.reset();
+		anyChanges |= this->updateValuesUnique(values);
+	}
+
+	return anyChanges;
 }

-void ScriptModel::setValues(const QVariantList& newValues) {
-	if (newValues == this->mValues) return;
-	this->updateValuesUnique(newValues);
-	emit this->valuesChanged();
+void ScriptModel::setValues(const QList<QJSValue>& newValues) {
+	// Re-entrant modification waits for the original modification to complete to avoid mishandled duplicates.
+	if (this->isModifying) {
+		this->stagedValues = newValues;
+		return;
+	}
+
+	auto changed = this->updateValuesUnique(newValues);
+	if (changed) emit this->valuesChanged();
 }

 void ScriptModel::setObjectProp(const QString& objectProp) {
@@ -169,6 +253,12 @@ void ScriptModel::setObjectProp(const QString& objectProp) {
 	emit this->objectPropChanged();
 }

+void ScriptModel::setComparisonMode(ObjectComparison::Enum comparisonMode) {
+	if (comparisonMode == this->mComparisonMode) return;
+	this->mComparisonMode = comparisonMode;
+	emit this->comparisonModeChanged();
+}
+
 qint32 ScriptModel::rowCount(const QModelIndex& parent) const {
 	if (parent != QModelIndex()) return 0;
 	return static_cast<qint32>(this->mValues.length());
@@ -176,7 +266,7 @@ qint32 ScriptModel::rowCount(const QModelIndex& parent) const {

 QVariant ScriptModel::data(const QModelIndex& index, qint32 role) const {
 	if (role != Qt::UserRole) return QVariant();
-	return this->mValues.at(index.row());
+	return this->mValues.at(index.row()).toVariant(QJSValue::RetainJSObjects);
 }

 QHash<int, QByteArray> ScriptModel::roleNames() const { return {{Qt::UserRole, "modelData"}}; }
@@ -1,10 +1,31 @@
 #pragma once

+#include <optional>
+
 #include <qabstractitemmodel.h>
 #include <qcontainerfwd.h>
+#include <qjsvalue.h>
+#include <qobject.h>
+#include <qobjectdefs.h>
 #include <qproperty.h>
 #include <qqmlintegration.h>
 #include <qtmetamacros.h>
+#include <qtypes.h>
+
+///! @@ScriptModel value comparison mode.
+namespace ObjectComparison { // NOLINT
+Q_NAMESPACE;
+QML_ELEMENT;
+
+enum Enum : quint8 {
+	/// Compare values using strict JavaScript equality.
+	Identity = 0,
+	/// Compare records and arrays structurally.
+	Structure = 1,
+};
+Q_ENUM_NS(Enum);
+
+} // namespace ObjectComparison

 ///! QML model reflecting a javascript expression
 /// ScriptModel is a QML [Data Model] that generates model operations based on changes
@@ -40,6 +61,7 @@
 /// [Data Model]: https://doc.qt.io/qt-6/qtquick-modelviewsdata-modelview.html#qml-data-models
 class ScriptModel: public QAbstractListModel {
 	Q_OBJECT;
+	// clang-format off
 	/// 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.
@@ -66,7 +88,8 @@ class ScriptModel: public QAbstractListModel {
 	/// >   values: [...DesktopEntries.applications.values].sort(...)
 	/// > }
 	/// > ```
-	Q_PROPERTY(QVariantList values READ values WRITE setValues NOTIFY valuesChanged);
+	// TODO: use qjsobject for gc/free checks?
+	Q_PROPERTY(QList<QJSValue> 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
@@ -74,21 +97,30 @@ class ScriptModel: public QAbstractListModel {
 	///
 	/// Defaults to `""`, meaning no key.
 	Q_PROPERTY(QString objectProp READ objectProp WRITE setObjectProp NOTIFY objectPropChanged);
+	/// How values should be compared. Defaults to `ObjectComparison.Structure`.
+	///
+	/// Identity based comparison is faster if usable for a given model, and often
+  /// achievable with @@objectProp.
+	Q_PROPERTY(ObjectComparison::Enum comparisonMode READ comparisonMode WRITE setComparisonMode NOTIFY comparisonModeChanged);
+	// clang-format on
 	QML_ELEMENT;

 public:
-	[[nodiscard]] QVariantList values() const {
+	[[nodiscard]] QList<QJSValue> values() const {
 		auto values = this->mValues;
 		// If not detached, the QML engine will invalidate iterators in updateValuesUnique.
-		if (this->hasActiveIterators) values.detach();
+		if (this->isModifying) values.detach();
 		return values;
 	}

-	void setValues(const QVariantList& newValues);
+	void setValues(const QList<QJSValue>& newValues);

 	[[nodiscard]] QString objectProp() const { return this->cmpKey; }
 	void setObjectProp(const QString& objectProp);

+	[[nodiscard]] ObjectComparison::Enum comparisonMode() const { return this->mComparisonMode; }
+	void setComparisonMode(ObjectComparison::Enum comparisonMode);
+
 	[[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;
@@ -96,11 +128,14 @@ public:
 signals:
 	void valuesChanged();
 	void objectPropChanged();
+	void comparisonModeChanged();

 private:
-	QVariantList mValues;
+	QList<QJSValue> mValues;
 	QString cmpKey;
-	bool hasActiveIterators = false;
+	ObjectComparison::Enum mComparisonMode = ObjectComparison::Structure;
+	bool isModifying = false;
+	std::optional<QList<QJSValue>> stagedValues;

-	void updateValuesUnique(const QVariantList& newValues);
+	bool updateValuesUnique(const QList<QJSValue>& newValues);
 };
@@ -0,0 +1,98 @@
+#include "streamreader.hpp"
+#include <cstring>
+
+#include <qbytearray.h>
+#include <qiodevice.h>
+#include <qtypes.h>
+
+void StreamReader::setDevice(QIODevice* device) {
+	this->reset();
+	this->device = device;
+}
+
+void StreamReader::startTransaction() {
+	this->cursor = 0;
+	this->failed = false;
+}
+
+bool StreamReader::fill() {
+	auto available = this->device->bytesAvailable();
+	if (available <= 0) return false;
+	auto oldSize = this->buffer.size();
+	this->buffer.resize(oldSize + available);
+	auto bytesRead = this->device->read(this->buffer.data() + oldSize, available); // NOLINT
+
+	if (bytesRead <= 0) {
+		this->buffer.resize(oldSize);
+		return false;
+	}
+
+	this->buffer.resize(oldSize + bytesRead);
+	return true;
+}
+
+QByteArray StreamReader::readBytes(qsizetype count) {
+	if (this->failed) return {};
+
+	auto needed = this->cursor + count;
+
+	while (this->buffer.size() < needed) {
+		if (!this->fill()) {
+			this->failed = true;
+			return {};
+		}
+	}
+
+	auto result = this->buffer.mid(this->cursor, count);
+	this->cursor += count;
+	return result;
+}
+
+QByteArray StreamReader::readUntil(char terminator) {
+	if (this->failed) return {};
+
+	auto searchFrom = this->cursor;
+	auto idx = this->buffer.indexOf(terminator, searchFrom);
+
+	while (idx == -1) {
+		searchFrom = this->buffer.size();
+		if (!this->fill()) {
+			this->failed = true;
+			return {};
+		}
+
+		idx = this->buffer.indexOf(terminator, searchFrom);
+	}
+
+	auto length = idx - this->cursor + 1;
+	auto result = this->buffer.mid(this->cursor, length);
+	this->cursor += length;
+	return result;
+}
+
+void StreamReader::readInto(char* ptr, qsizetype count) {
+	auto data = this->readBytes(count);
+	if (!data.isEmpty()) memcpy(ptr, data.data(), count);
+}
+
+qint32 StreamReader::readI32() {
+	qint32 value = 0;
+	this->readInto(reinterpret_cast<char*>(&value), sizeof(qint32));
+	return value;
+}
+
+bool StreamReader::commitTransaction() {
+	if (this->failed) {
+		this->cursor = 0;
+		return false;
+	}
+
+	this->buffer.remove(0, this->cursor);
+	this->cursor = 0;
+	return true;
+}
+
+void StreamReader::reset() {
+	this->buffer.clear();
+	this->cursor = 0;
+}
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <qbytearray.h>
+#include <qiodevice.h>
+#include <qtypes.h>
+
+class StreamReader {
+public:
+	void setDevice(QIODevice* device);
+
+	void startTransaction();
+	QByteArray readBytes(qsizetype count);
+	QByteArray readUntil(char terminator);
+	void readInto(char* ptr, qsizetype count);
+	qint32 readI32();
+	bool commitTransaction();
+	void reset();
+
+private:
+	bool fill();
+
+	QIODevice* device = nullptr;
+	QByteArray buffer;
+	qsizetype cursor = 0;
+	bool failed = false;
+};
@@ -8,3 +8,4 @@ qs_test(transformwatcher transformwatcher.cpp)
 qs_test(ringbuffer ringbuf.cpp)
 qs_test(scriptmodel scriptmodel.cpp)
 qs_test(stacklist stacklist.cpp)
+qs_test(objectmodel objectmodel.cpp)
@@ -0,0 +1,47 @@
+#include "objectmodel.hpp"
+
+#include <qlist.h>
+#include <qobject.h>
+#include <qtest.h>
+#include <qtestcase.h>
+
+#include "../model.hpp"
+
+void TestObjectModel::diffUpdateInsertRemove() {
+	QObject a;
+	QObject b;
+	QObject c;
+	QObject d;
+
+	auto model = ObjectModel<QObject>(nullptr);
+	model.insertObject(&a);
+	model.insertObject(&b);
+	model.insertObject(&c);
+	QCOMPARE(model.valueList(), (QList<QObject*> {&a, &b, &c}));
+
+	// drop b, append d — relative order of survivors unchanged
+	model.diffUpdate({&a, &c, &d});
+	QCOMPARE(model.valueList(), (QList<QObject*> {&a, &c, &d}));
+}
+
+void TestObjectModel::diffUpdateReorder() {
+	QObject a;
+	QObject b;
+	QObject c;
+	QObject d;
+
+	auto model = ObjectModel<QObject>(nullptr);
+	model.insertObject(&d);
+	model.insertObject(&a);
+	model.insertObject(&b);
+	model.insertObject(&c);
+	QCOMPARE(model.valueList(), (QList<QObject*> {&d, &a, &b, &c}));
+
+	// pure permutation: same elements, different order. Previously turned
+	// [d,a,b,c] into [a,b,c,d,a,b,c] because the old row was never removed
+	// before inserting at the new index.
+	model.diffUpdate({&a, &b, &c, &d});
+	QCOMPARE(model.valueList(), (QList<QObject*> {&a, &b, &c, &d}));
+}
+
+QTEST_MAIN(TestObjectModel);
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <qobject.h>
+#include <qtmetamacros.h>
+
+class TestObjectModel: public QObject {
+	Q_OBJECT;
+
+private slots:
+	static void diffUpdateInsertRemove();
+	static void diffUpdateReorder();
+};
@@ -4,10 +4,11 @@
 #include <qabstractitemmodeltester.h>
 #include <qcontainerfwd.h>
 #include <qdebug.h>
+#include <qjsengine.h>
+#include <qjsvalue.h>
 #include <qlist.h>
 #include <qlogging.h>
 #include <qobject.h>
-#include <qsignalspy.h>
 #include <qstring.h>
 #include <qtest.h>
 #include <qtestcase.h>
@@ -15,8 +16,6 @@

 #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;
@@ -44,15 +43,44 @@ QDebug& operator<<(QDebug& debug, const ModelOperation& op) {
 	return debug;
 }

+ChangeObserver::ChangeObserver(QAbstractItemModel* model) {
+	QObject::connect(model, &QAbstractItemModel::rowsInserted, this, &ChangeObserver::onInsert);
+	QObject::connect(model, &QAbstractItemModel::rowsRemoved, this, &ChangeObserver::onRemove);
+	QObject::connect(model, &QAbstractItemModel::rowsMoved, this, &ChangeObserver::onMove);
+}
+
+void ChangeObserver::onInsert(const QModelIndex& parent, int first, int last) {
+	QCOMPARE(parent, QModelIndex());
+	this->mOperations.emplaceBack(ModelOperation::Insert, first, last - first + 1);
+}
+
+void ChangeObserver::onRemove(const QModelIndex& parent, int first, int last) {
+	QCOMPARE(parent, QModelIndex());
+	this->mOperations.emplaceBack(ModelOperation::Remove, first, last - first + 1);
+}
+
+void ChangeObserver::onMove(
+    const QModelIndex& sourceParent,
+    int sourceStart,
+    int sourceEnd,
+    const QModelIndex& destParent,
+    int destStart
+) {
+	QCOMPARE(sourceParent, QModelIndex());
+	QCOMPARE(destParent, QModelIndex());
+	this->mOperations
+	    .emplaceBack(ModelOperation::Move, sourceStart, sourceEnd - sourceStart + 1, destStart);
+}
+
 // NOLINTNEXTLINE(misc-use-internal-linkage)
-QDebug& operator<<(QDebug& debug, const QVariantList& list) {
-	auto str = QString();
+QDebug& operator<<(QDebug& debug, const QJSValueList& list) {
+	QString str;

 	for (const auto& var: list) {
-		if (var.canConvert<QChar>()) {
-			str += var.value<QChar>();
+		if (var.isString()) {
+			str += var.toString();
 		} else {
-			qFatal() << "QVariantList debug overridden in test";
+			qFatal() << "QJSValueList debug overridden in test";
 		}
 	}

@@ -60,6 +88,18 @@ QDebug& operator<<(QDebug& debug, const QVariantList& list) {
 	return debug;
 }

+namespace {
+bool qjsValueListsEqual(const QJSValueList& a, const QJSValueList& b) {
+	if (a.length() != b.length()) return false;
+
+	for (auto i = 0; i != a.length(); i++) {
+		if (!a.at(i).strictlyEquals(b.at(i))) return false;
+	}
+
+	return true;
+}
+} // namespace
+
 void TestScriptModel::unique_data() {
 	QTest::addColumn<QString>("oldstr");
 	QTest::addColumn<QString>("newstr");
@@ -90,7 +130,7 @@ void TestScriptModel::unique_data() {
 	QTest::addRow("move_overlapping")
 	    << "ABCDEFG" << "ABDEFCG" << OpList({{ModelOperation::Move, 3, 3, 2}});

-	// Ensure iterators arent skipping anything at the end of operations by performing
+	// Ensure iterators aren't skipping anything at the end of operations by performing
 	// multiple back to back.

 	QTest::addRow("insert_state_ok") << "ABCDEFG" << "ABXXEFG"
@@ -117,65 +157,127 @@ void TestScriptModel::unique() {
 	QFETCH(const QString, newstr);
 	QFETCH(const OpList, operations);

-	auto strToVariantList = [](const QString& str) -> QVariantList {
-		QVariantList list;
+	auto strToJsValueList = [](const QString& str) -> QJSValueList {
+		QJSValueList list;

 		for (auto c: str) {
-			list.emplace_back(c);
+			list.emplace_back(QString(c));
 		}

 		return list;
 	};

-	auto oldlist = strToVariantList(oldstr);
-	auto newlist = strToVariantList(newstr);
+	auto oldList = strToJsValueList(oldstr);
+	auto newList = strToJsValueList(newstr);

-	auto model = ScriptModel();
+	ScriptModel model;
 	auto modelTester = QAbstractItemModelTester(&model);
+	auto observer = ChangeObserver(&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);
+	model.setValues(oldList);
+	QVERIFY(qjsValueListsEqual(model.values(), oldList));
 	QCOMPARE_EQ(
-	    actualOperations,
-	    OpList({{ModelOperation::Insert, 0, static_cast<qint32>(oldlist.length())}})
+	    observer.operations(),
+	    OpList({{ModelOperation::Insert, 0, static_cast<qint32>(oldList.length())}})
 	);

-	actualOperations.clear();
+	observer.clear();

-	model.setValues(newlist);
-	QCOMPARE_EQ(model.values(), newlist);
-	QCOMPARE_EQ(actualOperations, operations);
+	model.setValues(newList);
+	QVERIFY(qjsValueListsEqual(model.values(), newList));
+	QCOMPARE_EQ(observer.operations(), operations);
+}
+
+void TestScriptModel::structuralEquality() {
+	ScriptModel model;
+	QJSEngine engine;
+
+	auto object = engine.newObject();
+	object.setProperty("foo", "bar");
+	object.setProperty("bar", "baz");
+	object.setProperty("subobject", engine.newObject());
+
+	auto replacement = engine.newObject();
+	replacement.setProperty("subobject", engine.newObject());
+	replacement.setProperty("bar", "baz");
+	replacement.setProperty("foo", "bar");
+
+	auto oldList = QList<QJSValue> {object};
+
+	auto newList = QList<QJSValue> {replacement};
+
+	auto modelTester = QAbstractItemModelTester(&model);
+	auto observer = ChangeObserver(&model);
+
+	model.setValues(oldList);
+	QVERIFY(qjsValueListsEqual(model.values(), oldList));
+	QCOMPARE_EQ(
+	    observer.operations(),
+	    OpList({{ModelOperation::Insert, 0, static_cast<qint32>(oldList.length())}})
+	);
+
+	observer.clear();
+
+	model.setValues(newList);
+	QVERIFY(qjsValueListsEqual(model.values(), newList));
+	QCOMPARE_EQ(observer.operations(), OpList());
+
+	auto structurallyEquals = [](const QJSValue& a, const QJSValue& b) {
+		ScriptModel model;
+		model.setValues({a});
+
+		auto observer = ChangeObserver(&model);
+		model.setValues({b});
+		return observer.operations().isEmpty();
+	};
+
+	auto different = engine.newObject();
+	different.setProperty("foo", "bar");
+	different.setProperty("bar", "baz");
+	auto differentSubobject = engine.newObject();
+	differentSubobject.setProperty("value", 1);
+	different.setProperty("subobject", differentSubobject);
+	QVERIFY(!structurallyEquals(object, different));
+
+	auto cycleA = engine.newObject();
+	cycleA.setProperty("self", cycleA);
+	auto cycleB = engine.newObject();
+	cycleB.setProperty("self", cycleB);
+	QVERIFY(!structurallyEquals(cycleA, cycleB));
+
+	const auto arrayA = engine.evaluate("[1, { value: 'x' }]");
+	const auto arrayB = engine.evaluate("[1, { value: 'x' }]");
+	QVERIFY(structurallyEquals(arrayA, arrayB));
+
+	auto sparseArrayA = engine.newArray(1);
+	auto sparseArrayB = engine.newArray(2);
+	QVERIFY(!structurallyEquals(sparseArrayA, sparseArrayB));
+}
+
+void TestScriptModel::comparisonModes() {
+	QJSEngine engine;
+	auto makeValue = [&engine]() {
+		auto value = engine.newObject();
+		value.setProperty("nested", engine.newObject());
+		return value;
+	};
+
+	ScriptModel model;
+	QCOMPARE_EQ(model.comparisonMode(), ObjectComparison::Structure);
+
+	model.setValues({makeValue()});
+	model.setComparisonMode(ObjectComparison::Identity);
+	QCOMPARE_EQ(model.comparisonMode(), ObjectComparison::Identity);
+
+	auto observer = ChangeObserver(&model);
+	model.setValues({makeValue()});
+	QVERIFY(!observer.operations().isEmpty());
+
+	model.setComparisonMode(ObjectComparison::Structure);
+
+	observer.clear();
+	model.setValues({makeValue()});
+	QCOMPARE_EQ(observer.operations(), OpList());
 }

 QTEST_MAIN(TestScriptModel);
@@ -1,6 +1,8 @@
 #pragma once

+#include <qabstractitemmodel.h>
 #include <qdebug.h>
+#include <qlist.h>
 #include <qobject.h>
 #include <qtmetamacros.h>
 #include <qtypes.h>
@@ -26,6 +28,29 @@ struct ModelOperation {
 	[[nodiscard]] bool operator==(const ModelOperation& other) const;
 };

+using OpList = QList<ModelOperation>;
+
+class ChangeObserver: public QObject {
+public:
+	explicit ChangeObserver(QAbstractItemModel* model);
+
+	[[nodiscard]] const OpList& operations() const { return this->mOperations; }
+	void clear() { this->mOperations.clear(); }
+
+private:
+	void onInsert(const QModelIndex& parent, int first, int last);
+	void onRemove(const QModelIndex& parent, int first, int last);
+	void onMove(
+	    const QModelIndex& sourceParent,
+	    int sourceStart,
+	    int sourceEnd,
+	    const QModelIndex& destParent,
+	    int destStart
+	);
+
+	OpList mOperations;
+};
+
 QDebug& operator<<(QDebug& debug, const ModelOperation& op);

 class TestScriptModel: public QObject {
@@ -34,4 +59,6 @@ class TestScriptModel: public QObject {
 private slots:
 	static void unique_data(); // NOLINT
 	static void unique();
+	static void structuralEquality();
+	static void comparisonModes();
 };
@@ -177,6 +177,8 @@ void QmlToolingSupport::updateToolingFs(
 		auto fileInfo = QFileInfo(path);
 		if (!fileInfo.isFile()) continue;

+		if (scanner.fileIntercepts.contains(path)) continue;
+
 		auto spath = linkDir.filePath(name);
 		auto sFileInfo = QFileInfo(spath);

@@ -205,8 +207,10 @@ void QmlToolingSupport::updateToolingFs(
 		}

 		auto spath = linkDir.filePath(name);
+		QFile::remove(spath);
+
 		auto file = QFile(spath);
-		if (!file.open(QFile::ReadWrite | QFile::Text)) {
+		if (!file.open(QFile::ReadWrite | QFile::Text | QFile::NewOnly)) {
 			qCCritical(logTooling) << "Failed to open injected file" << spath;
 			continue;
 		}
@@ -145,7 +145,7 @@ void Variants::updateVariants() {

 		{
 			if (this->mInstances.contains(variant)) {
-				continue; // we dont need to recreate this one
+				continue; // we don't need to recreate this one
 			}

 			auto variantMap = QVariantMap();
@@ -43,7 +43,7 @@ class Variants: public Reloadable {
 	Q_OBJECT;
 	/// The component to create instances of.
 	///
-	/// The delegate should define a `modelData` property that will be popuplated with a value
+	/// The delegate should define a `modelData` property that will be populated with a value
 	/// from the @@model.
 	Q_PROPERTY(QQmlComponent* delegate MEMBER mDelegate);
 	/// The list of sets of properties to create instances with.
@@ -6,12 +6,51 @@ qt_add_library(quickshell-crash STATIC

 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)
+if (VENDOR_CPPTRACE)
+	message(STATUS "Vendoring cpptrace...")
+	include(FetchContent)
+
+	# For use without internet access see: https://cmake.org/cmake/help/latest/module/FetchContent.html#variable:FETCHCONTENT_SOURCE_DIR_%3CuppercaseName%3E
+	FetchContent_Declare(
+  	cpptrace
+  	GIT_REPOSITORY https://github.com/jeremy-rifkin/cpptrace.git
+  	GIT_TAG        v1.0.4
+	)
+
+	set(CPPTRACE_UNWIND_WITH_LIBUNWIND TRUE)
+	FetchContent_MakeAvailable(cpptrace)
+else ()
+	find_package(cpptrace REQUIRED)
+
+	# useful for cross after you have already checked cpptrace is built correctly
+	if (NOT DO_NOT_CHECK_CPPTRACE_USABILITY)
+		try_run(CPPTRACE_SIGNAL_SAFE_UNWIND CPPTRACE_SIGNAL_SAFE_UNWIND_COMP
+			SOURCE_FROM_CONTENT check.cxx "
+				#include <cpptrace/basic.hpp>
+				int main() {
+					return cpptrace::can_signal_safe_unwind() ? 0 : 1;
+				}
+			"
+			LOG_DESCRIPTION "Checking ${CPPTRACE_SIGNAL_SAFE_UNWIND}"
+			LINK_LIBRARIES cpptrace::cpptrace
+			COMPILE_OUTPUT_VARIABLE CPPTRACE_SIGNAL_SAFE_UNWIND_LOG
+			CXX_STANDARD 20
+			CXX_STANDARD_REQUIRED ON
+		)
+
+		if (NOT CPPTRACE_SIGNAL_SAFE_UNWIND_COMP)
+			message(STATUS "${CPPTRACE_SIGNAL_SAFE_UNWIND_LOG}")
+			message(FATAL_ERROR "Failed to compile cpptrace signal safe unwind tester.")
+		endif()
+
+		if (NOT CPPTRACE_SIGNAL_SAFE_UNWIND EQUAL 0)
+			message(STATUS "Cpptrace signal safe unwind test exited with: ${CPPTRACE_SIGNAL_SAFE_UNWIND}")
+			message(FATAL_ERROR "Cpptrace was built without CPPTRACE_UNWIND_WITH_LIBUNWIND set to true. Enable libunwind support in the package or set VENDOR_CPPTRACE to true when building Quickshell.")
+		endif()
+	endif ()
+endif ()

 # quick linked for pch compat
-target_link_libraries(quickshell-crash PRIVATE quickshell-build Qt::Quick Qt::Widgets)
+target_link_libraries(quickshell-crash PRIVATE quickshell-build Qt::Quick Qt::Widgets cpptrace::cpptrace)

 target_link_libraries(quickshell PRIVATE quickshell-crash)
@@ -1,12 +1,15 @@
 #include "handler.hpp"
+#include <algorithm>
 #include <array>
+#include <cerrno>
+#include <csignal>
 #include <cstdio>
 #include <cstring>
+#include <exception>

-#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 <cpptrace/basic.hpp>
+#include <cpptrace/forward.hpp>
+#include <cpptrace/utils.hpp>
 #include <qdatastream.h>
 #include <qfile.h>
 #include <qlogging.h>
@@ -19,98 +22,77 @@

 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;
+void writeEnvInt(char* buf, const char* name, int value) {
+	// NOLINTBEGIN (cppcoreguidelines-pro-bounds-pointer-arithmetic)
+	while (*name != '\0') *buf++ = *name++;
+	*buf++ = '=';

-	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));
+	if (value < 0) {
+		*buf++ = '-';
+		value = -value;
 	}

-	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.";
+	if (value == 0) {
+		*buf++ = '0';
+		*buf = '\0';
 		return;
 	}

-	QFile file;
-
-	if (!file.open(this->d->infoFd, QFile::ReadWrite)) {
-		qCCritical(
-		    logCrashHandler
-		) << "Failed to open instance info memfd, crash recovery will not work.";
+	auto* start = buf;
+	while (value > 0) {
+		*buf++ = static_cast<char>('0' + (value % 10));
+		value /= 10;
 	}

-	QDataStream ds(&file);
-	ds << info;
-	file.flush();
-
-	qCDebug(logCrashHandler) << "Stored instance info in memfd" << this->d->infoFd;
+	*buf = '\0';
+	std::reverse(start, buf);
+	// NOLINTEND
 }

-CrashHandler::~CrashHandler() {
-	delete this->d->exceptionHandler;
-	delete this->d;
-}
-
-bool CrashHandlerPrivate::minidumpCallback(
-    const MinidumpDescriptor& /*descriptor*/,
-    void* context,
-    bool /*success*/
+void signalHandler(
+    int sig,
+    siginfo_t* /*info*/, // NOLINT (misc-include-cleaner)
+    void*                /*context*/
 ) {
-	// A fork that just dies to ensure the coredump is caught by the system.
-	auto coredumpPid = fork();
+	// NOLINTBEGIN (misc-include-cleaner)
+	sigset_t set;
+	sigfillset(&set);
+	sigprocmask(SIG_UNBLOCK, &set, nullptr);
+	// NOLINTEND

-	if (coredumpPid == 0) {
-		return false;
+	if (CrashInfo::INSTANCE.traceFd != -1) {
+		auto traceBuffer = std::array<cpptrace::frame_ptr, 1024>();
+		auto frameCount = cpptrace::safe_generate_raw_trace(traceBuffer.data(), traceBuffer.size(), 1);
+
+		for (size_t i = 0; i < static_cast<size_t>(frameCount); i++) {
+			auto frame = cpptrace::safe_object_frame();
+			cpptrace::get_safe_object_frame(traceBuffer[i], &frame);
+
+			auto* wptr = reinterpret_cast<char*>(&frame);
+			auto* end = wptr + sizeof(cpptrace::safe_object_frame); // NOLINT
+			while (wptr != end) {
+				auto r = write(CrashInfo::INSTANCE.traceFd, &frame, sizeof(cpptrace::safe_object_frame));
+				if (r < 0 && errno == EINTR) continue;
+				if (r <= 0) goto fail;
+				wptr += r; // NOLINT
+			}
+		}
+
+	fail:;
 	}

-	auto* self = static_cast<CrashHandlerPrivate*>(context);
+	// TODO: coredump fork and crash reporter remain as zombies, fix
+	auto coredumpPid = fork();
+	if (coredumpPid == 0) {
+		raise(sig);
+		_exit(-1);
+	}

 	auto exe = std::array<char, 4096>();
 	if (readlink("/proc/self/exe", exe.data(), exe.size() - 1) == -1) {
@@ -123,17 +105,19 @@ bool CrashHandlerPrivate::minidumpCallback(
 	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);
+	// dup to remove CLOEXEC
+	auto infoFdStr = std::array<char, 48>();
+	writeEnvInt(infoFdStr.data(), "__QUICKSHELL_CRASH_INFO_FD", dup(CrashInfo::INSTANCE.infoFd));
 	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);
+	auto corePidStr = std::array<char, 48>();
+	writeEnvInt(corePidStr.data(), "__QUICKSHELL_CRASH_DUMP_PID", coredumpPid);
 	env[envi++] = corePidStr.data();

+	auto sigStr = std::array<char, 48>();
+	writeEnvInt(sigStr.data(), "__QUICKSHELL_CRASH_SIGNAL", sig);
+	env[envi++] = sigStr.data();
+
 	auto populateEnv = [&]() {
 		auto senvi = 0;
 		while (envi != 4095) {
@@ -145,30 +129,17 @@ bool CrashHandlerPrivate::minidumpCallback(
 		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;
+		_exit(-1);
 	} 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);
+		auto dumpFdStr = std::array<char, 48>();
+		auto logFdStr = std::array<char, 48>();
+		writeEnvInt(dumpFdStr.data(), "__QUICKSHELL_CRASH_DUMP_FD", dup(CrashInfo::INSTANCE.traceFd));
+		writeEnvInt(logFdStr.data(), "__QUICKSHELL_CRASH_LOG_FD", dup(CrashInfo::INSTANCE.logFd));

 		env[envi++] = dumpFdStr.data();
 		env[envi++] = logFdStr.data();
@@ -185,8 +156,99 @@ bool CrashHandlerPrivate::minidumpCallback(
 		perror("Failed to relaunch quickshell.\n");
 		_exit(-1);
 	}
+}

-	return false; // should make sure it hits the system coredump handler
+void handleCppTerminate() {
+	if (auto ptr = std::current_exception()) {
+		try {
+			std::rethrow_exception(ptr);
+		} catch (std::exception& e) {
+			qFatal().nospace() << "Terminate called with C++ exception ("
+			                   << cpptrace::demangle(typeid(e).name()).data() << "): " << e.what();
+		} catch (...) {
+			qFatal() << "Terminate called with non exception object";
+		}
+	}
+
+	qFatal() << "Terminate called without active C++ exception";
+}
+
+} // namespace
+
+void CrashHandler::init() {
+	qCDebug(logCrashHandler) << "Starting crash handler...";
+
+	CrashInfo::INSTANCE.traceFd = memfd_create("quickshell:trace", MFD_CLOEXEC);
+
+	if (CrashInfo::INSTANCE.traceFd == -1) {
+		qCCritical(logCrashHandler) << "Failed to allocate trace memfd, stack traces will not be "
+		                               "available in crash reports.";
+	} else {
+		qCDebug(logCrashHandler) << "Created memfd" << CrashInfo::INSTANCE.traceFd
+		                         << "for holding possible stack traces.";
+	}
+
+	{
+		// Preload anything dynamically linked to avoid malloc etc in the dynamic loader.
+		// See cpptrace documentation for more information.
+		auto buffer = std::array<cpptrace::frame_ptr, 10>();
+		cpptrace::safe_generate_raw_trace(buffer.data(), buffer.size());
+		auto frame = cpptrace::safe_object_frame();
+		cpptrace::get_safe_object_frame(buffer[0], &frame);
+	}
+
+	// NOLINTBEGIN (misc-include-cleaner)
+
+	// Set up alternate signal stack for stack overflow handling
+	auto ss = stack_t();
+	ss.ss_sp = new char[SIGSTKSZ];
+	ss.ss_size = SIGSTKSZ;
+	ss.ss_flags = 0;
+	sigaltstack(&ss, nullptr);
+
+	// Install signal handlers
+	struct sigaction sa {};
+	sa.sa_sigaction = &signalHandler;
+	sa.sa_flags = SA_SIGINFO | SA_ONSTACK | SA_RESETHAND;
+	sigemptyset(&sa.sa_mask);
+
+	sigaction(SIGSEGV, &sa, nullptr);
+	sigaction(SIGABRT, &sa, nullptr);
+	sigaction(SIGFPE, &sa, nullptr);
+	sigaction(SIGILL, &sa, nullptr);
+	sigaction(SIGBUS, &sa, nullptr);
+	sigaction(SIGTRAP, &sa, nullptr);
+
+	// NOLINTEND (misc-include-cleaner)
+
+	std::set_terminate(&handleCppTerminate);
+
+	qCInfo(logCrashHandler) << "Crash handler initialized.";
+}
+
+void CrashHandler::setRelaunchInfo(const RelaunchInfo& info) {
+	CrashInfo::INSTANCE.infoFd = memfd_create("quickshell:instance_info", MFD_CLOEXEC);
+
+	if (CrashInfo::INSTANCE.infoFd == -1) {
+		qCCritical(
+		    logCrashHandler
+		) << "Failed to allocate instance info memfd, crash recovery will not work.";
+		return;
+	}
+
+	QFile file;
+
+	if (!file.open(CrashInfo::INSTANCE.infoFd, QFile::ReadWrite)) {
+		qCCritical(
+		    logCrashHandler
+		) << "Failed to open instance info memfd, crash recovery will not work.";
+	}
+
+	QDataStream ds(&file);
+	ds << info;
+	file.flush();
+
+	qCDebug(logCrashHandler) << "Stored instance info in memfd" << CrashInfo::INSTANCE.infoFd;
 }

 } // namespace qs::crash
@@ -5,19 +5,10 @@
 #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;
+	static void init();
+	static void setRelaunchInfo(const RelaunchInfo& info);
 };

 } // namespace qs::crash
@@ -5,6 +5,7 @@
 #include <qapplication.h>
 #include <qboxlayout.h>
 #include <qconfig.h>
+#include <qcontainerfwd.h>
 #include <qdesktopservices.h>
 #include <qfont.h>
 #include <qfontinfo.h>
@@ -12,11 +13,22 @@
 #include <qnamespace.h>
 #include <qobject.h>
 #include <qpushbutton.h>
+#include <qtenvironmentvariables.h>
 #include <qtversion.h>
 #include <qwidget.h>

 #include "build.hpp"

+namespace {
+QString crashreportUrl() {
+	if (auto url = qEnvironmentVariable("QS_CRASHREPORT_URL"); !url.isEmpty()) {
+		return url;
+	}
+
+	return CRASHREPORT_URL;
+}
+} // namespace
+
 class ReportLabel: public QWidget {
 public:
 	ReportLabel(const QString& label, const QString& content, QWidget* parent): QWidget(parent) {
@@ -67,22 +79,16 @@ CrashReporterGui::CrashReporterGui(QString reportFolder, int pid)

 	if (qtVersionMatches) {
 		mainLayout->addWidget(
-		    new QLabel("Please open a bug report for this issue via github or email.")
+		    new QLabel("Please open a bug report for this issue on the issue tracker.")
 		);
 	} 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."
+		    "If this does not solve the problem, please open a bug report on the issue tracker."
 		));
 	}

-	mainLayout->addWidget(new ReportLabel(
-	    "Github:",
-	    "https://github.com/quickshell-mirror/quickshell/issues/new?template=crash.yml",
-	    this
-	));
-
-	mainLayout->addWidget(new ReportLabel("Email:", "[email protected]", this));
+	mainLayout->addWidget(new ReportLabel("Tracker:", crashreportUrl(), this));

 	auto* buttons = new QWidget(this);
 	buttons->setMinimumWidth(900);
@@ -112,10 +118,5 @@ 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::openReportUrl() { QDesktopServices::openUrl(QUrl(crashreportUrl())); }
 void CrashReporterGui::cancel() { QApplication::quit(); }
@@ -1,9 +1,11 @@
 #include "main.hpp"
 #include <cerrno>
 #include <cstdlib>
+#include <cstring>

+#include <cpptrace/basic.hpp>
+#include <cpptrace/formatting.hpp>
 #include <qapplication.h>
-#include <qconfig.h>
 #include <qcoreapplication.h>
 #include <qdatastream.h>
 #include <qdir.h>
@@ -12,15 +14,19 @@
 #include <qloggingcategory.h>
 #include <qtenvironmentvariables.h>
 #include <qtextstream.h>
-#include <qtversion.h>
+#include <qtypes.h>
 #include <sys/sendfile.h>
 #include <sys/types.h>
+#include <unistd.h>

+#include "../core/debuginfo.hpp"
 #include "../core/instanceinfo.hpp"
 #include "../core/logcat.hpp"
 #include "../core/logging.hpp"
+#include "../core/logging_p.hpp"
 #include "../core/paths.hpp"
-#include "build.hpp"
+#include "../core/plugin.hpp"
+#include "../core/ringbuf.hpp"
 #include "interface.hpp"

 namespace {
@@ -61,6 +67,76 @@ int tryDup(int fd, const QString& path) {
 	return 0;
 }

+QString readRecentLogs(int logFd, int maxLines, qint64 maxAgeSecs) {
+	QFile file;
+	if (!file.open(logFd, QFile::ReadOnly, QFile::AutoCloseHandle)) {
+		return QStringLiteral("(failed to open log fd)\n");
+	}
+
+	file.seek(0);
+
+	qs::log::EncodedLogReader reader;
+	reader.setDevice(&file);
+
+	bool readable = false;
+	quint8 logVersion = 0;
+	quint8 readerVersion = 0;
+	if (!reader.readHeader(&readable, &logVersion, &readerVersion) || !readable) {
+		return QStringLiteral("(failed to read log header)\n");
+	}
+
+	// Read all messages, keeping last maxLines in a ring buffer
+	auto tail = RingBuffer<qs::log::LogMessage>(maxLines);
+	qs::log::LogMessage message;
+	while (reader.read(&message)) {
+		tail.emplace(message);
+	}
+
+	if (tail.size() == 0) {
+		return QStringLiteral("(no logs)\n");
+	}
+
+	// Filter to only messages within maxAgeSecs of the newest message
+	auto cutoff = tail.at(0).time.addSecs(-maxAgeSecs);
+
+	QString result;
+	auto stream = QTextStream(&result);
+	for (auto i = tail.size() - 1; i != -1; i--) {
+		if (tail.at(i).time < cutoff) continue;
+		qs::log::LogMessage::formatMessage(stream, tail.at(i), false, true);
+		stream << '\n';
+	}
+
+	if (result.isEmpty()) {
+		return QStringLiteral("(no recent logs)\n");
+	}
+
+	return result;
+}
+
+cpptrace::stacktrace resolveStacktrace(int dumpFd) {
+	QFile sourceFile;
+	if (!sourceFile.open(dumpFd, QFile::ReadOnly, QFile::AutoCloseHandle)) {
+		qCCritical(logCrashReporter) << "Failed to open trace memfd.";
+		return {};
+	}
+
+	sourceFile.seek(0);
+	auto data = sourceFile.readAll();
+
+	auto frameCount = static_cast<size_t>(data.size()) / sizeof(cpptrace::safe_object_frame);
+	if (frameCount == 0) return {};
+
+	const auto* frames = reinterpret_cast<const cpptrace::safe_object_frame*>(data.constData());
+
+	cpptrace::object_trace objectTrace;
+	for (size_t i = 0; i < frameCount; i++) {
+		objectTrace.frames.push_back(frames[i].resolve()); // NOLINT
+	}
+
+	return objectTrace.resolve();
+}
+
 void recordCrashInfo(const QDir& crashDir, const InstanceInfo& instance) {
 	qCDebug(logCrashReporter) << "Recording crash information at" << crashDir.path();

@@ -71,74 +147,49 @@ void recordCrashInfo(const QDir& crashDir, const InstanceInfo& instance) {
 	}

 	auto crashProc = qEnvironmentVariable("__QUICKSHELL_CRASH_DUMP_PID").toInt();
+	auto crashSignal = qEnvironmentVariable("__QUICKSHELL_CRASH_SIGNAL").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) << "Resolving stacktrace from fd" << dumpFd;
+	auto stacktrace = resolveStacktrace(dumpFd);

-	qCDebug(logCrashReporter) << "Saving log from fd" << logFd;
-	auto logDupStatus = tryDup(logFd, crashDir.filePath("log.qslog.log"));
+	qCDebug(logCrashReporter) << "Reading recent log lines from fd" << logFd;
+	auto logDupFd = dup(logFd);
+	auto recentLogs = readRecentLogs(logFd, 100, 10);
+
+	qCDebug(logCrashReporter) << "Saving log from fd" << logDupFd;
+	auto logDupStatus = tryDup(logDupFd, 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"));
+		auto extraInfoFile = QFile(crashDir.filePath("report.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 << qs::debuginfo::combinedInfo();

-			stream << "\n===== Runtime Information =====\n";
-			stream << "Runtime Qt Version: " << qVersion() << '\n';
+			stream << "\n===== Instance Information =====\n";
+			stream << "Signal: " << strsignal(crashSignal) << " (" << crashSignal << ")\n"; // NOLINT
 			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();
+			stream << "\n===== Stacktrace =====\n";
+			if (stacktrace.empty()) {
+				stream << "(no trace available)\n";
 			} else {
-				stream << "FAILED TO OPEN\n";
+				auto formatter = cpptrace::formatter().header(std::string());
+				auto traceStr = formatter.format(stacktrace);
+				stream << QString::fromStdString(traceStr) << '\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";
-			}
+			stream << "\n===== Log Tail =====\n";
+			stream << recentLogs;

 			extraInfoFile.close();
 		}
@@ -180,12 +231,17 @@ void qsCheckCrash(int argc, char** argv) {
 	);

 	auto app = QApplication(argc, argv);
-	QApplication::setDesktopFileName("org.quickshell");
+	auto desktopId =
+	    info.instance.appId.isEmpty() ? QStringLiteral("org.quickshell") : info.instance.appId;
+	QApplication::setDesktopFileName(desktopId);

 	auto crashDir = QsPaths::crashDir(info.instance.instanceId);

 	qCInfo(logCrashReporter) << "Starting crash reporter...";

+	// Required platform compatibility hooks
+	QsEnginePlugin::preinitPluginsOnly();
+
 	recordCrashInfo(crashDir, info.instance);

 	auto gui = CrashReporterGui(crashDir.path(), crashProc);
@@ -301,6 +301,13 @@ DBusMenu::DBusMenu(const QString& service, const QString& path, QObject* parent)
 	    &DBusMenu::onLayoutUpdated
 	);

+	QObject::connect(
+	    this->interface,
+	    &DBusMenuInterface::ItemsPropertiesUpdated,
+	    this,
+	    &DBusMenu::onItemPropertiesUpdated
+	);
+
 	this->properties.setInterface(this->interface);
 	this->properties.updateAllViaGetAll();
 }
@@ -51,7 +51,7 @@ void SplitParser::parseBytes(QByteArray& incoming, QByteArray& buffer) {
 		return;
 	}

-	// make sure we dont miss any delimiters in the buffer if the delimiter changes
+	// make sure we don't miss any delimiters in the buffer if the delimiter changes
 	if (this->mSplitMarkerChanged) {
 		this->mSplitMarkerChanged = false;
 		this->parseBytes(buffer, buffer);
@@ -495,6 +495,7 @@ 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) {
+		QObject::disconnect(this->watcher, nullptr, this, nullptr);
 		this->watcher->deleteLater();
 		this->watcher = nullptr;
 	}
@@ -29,9 +29,9 @@ class FileViewError: public QObject {

 public:
 	enum Enum : quint8 {
-		/// No error occured.
+		/// No error occurred.
 		Success = 0,
-		/// An unknown error occured. Check the logs for details.
+		/// An unknown error occurred. Check the logs for details.
 		Unknown = 1,
 		/// The file to read does not exist.
 		FileNotFound = 2,
@@ -204,7 +204,7 @@ class FileView: public QObject {
 	///
 	/// > [!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);
+	Q_PROPERTY(bool atomicWrites READ default WRITE default NOTIFY atomicWritesChanged 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);
@@ -1,181 +1,94 @@
 #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 {};
+bool IpcValueSlot::isSupported(const QMetaType& type) { return IpcValueSlot::typeName(type); }

-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();
+const char* IpcValueSlot::typeName(const QMetaType& type) {
+	switch (type.id()) {
+	case QMetaType::Void: return "void";
+	case QMetaType::QString: return "string";
+	case QMetaType::Int: return "int";
+	case QMetaType::Bool: return "bool";
+	case QMetaType::Double: return "real";
+	case QMetaType::QColor: return "color";
+	default: return nullptr;
 	}
 }

-QGenericReturnArgument IpcTypeSlot::asGenericReturnArgument() {
-	if (this->mType) {
-		return QGenericReturnArgument(this->mType->genericArgumentName(), this->get());
-	} else {
-		return QGenericReturnArgument();
+const char* IpcValueSlot::name() const {
+	return this->mValue.isValid() ? IpcValueSlot::typeName(this->mValue.metaType()) : "void";
+}
+
+bool IpcValueSlot::isVoid() const { return !this->mValue.isValid(); }
+
+const QVariant& IpcValueSlot::value() const { return this->mValue; }
+
+bool IpcValueSlot::setString(const QString& string) {
+	switch (this->mValue.typeId()) {
+	case QMetaType::QString: this->mValue = QVariant::fromValue(string); return true;
+	case QMetaType::Int: {
+		auto ok = false;
+		auto value = string.toInt(&ok);
+		if (ok) this->mValue = QVariant::fromValue(value);
+		return ok;
+	}
+	case QMetaType::Bool: {
+		if (string == "true" || string == "false") {
+			this->mValue = QVariant::fromValue(string == "true");
+			return true;
+		}
+
+		auto ok = false;
+		auto value = string.toInt(&ok);
+		if (ok) this->mValue = QVariant::fromValue(value != 0);
+		return ok;
+	}
+	case QMetaType::Double: {
+		auto ok = false;
+		auto value = string.toDouble(&ok);
+		if (ok) this->mValue = QVariant::fromValue(value);
+		return ok;
+	}
+	case QMetaType::QColor: {
+		auto value = QColor::fromString(string);
+		if (!value.isValid() && !string.startsWith('#')) value = QColor::fromString('#' % string);
+		if (value.isValid()) this->mValue = QVariant::fromValue(value);
+		return value.isValid();
+	}
+	default: return false;
 	}
 }

-void IpcTypeSlot::replace(void* value) {
-	if (this->storage != nullptr) {
-		this->mType->destroyStorage(this->storage);
+void IpcValueSlot::setValue(QVariant value) { this->mValue = std::move(value); }
+
+QString IpcValueSlot::toString() const {
+	switch (this->mValue.typeId()) {
+	case QMetaType::UnknownType: return "";
+	case QMetaType::QString: return this->mValue.value<QString>();
+	case QMetaType::Int: return QString::number(this->mValue.value<int>());
+	case QMetaType::Bool: return this->mValue.value<bool>() ? "true" : "false";
+	case QMetaType::Double: return QString::number(this->mValue.value<double>());
+	case QMetaType::QColor: return this->mValue.value<QColor>().name(QColor::HexArgb);
+	default: return "";
 	}
-
-	this->storage = value;
 }

-void IpcTypeSlot::replace(const QVariant& value) {
-	this->replace(this->mType->copyStorage(value.constData()));
+QGenericArgument IpcValueSlot::asGenericArgument() const {
+	return QGenericArgument(this->mValue.metaType().name(), this->mValue.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;
+QGenericReturnArgument IpcValueSlot::asGenericReturnArgument() {
+	if (!this->mValue.isValid()) return QGenericReturnArgument();
+	return QGenericReturnArgument(this->mValue.metaType().name(), this->mValue.data());
 }

-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) {
@@ -1,130 +1,35 @@
 #pragma once

 #include <qcontainerfwd.h>
+#include <qmetatype.h>
 #include <qobjectdefs.h>
-#include <qtclasshelpermacros.h>
 #include <qtypes.h>
+#include <qvariant.h>

 #include "../ipc/ipc.hpp"

 namespace qs::io::ipc {

-class IpcTypeSlot;
-
-class IpcType {
+class IpcValueSlot {
 public:
-	IpcType() = default;
-	virtual ~IpcType() = default;
-	IpcType(const IpcType&) = default;
-	IpcType(IpcType&&) = default;
-	IpcType& operator=(const IpcType&) = default;
-	IpcType& operator=(IpcType&&) = default;
+	IpcValueSlot() = default;
+	explicit IpcValueSlot(QMetaType type): mValue(type) {}

-	[[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;
+	[[nodiscard]] static bool isSupported(const QMetaType& type);
+	[[nodiscard]] static const char* typeName(const QMetaType& type);
+	[[nodiscard]] const char* name() const;
+	[[nodiscard]] bool isVoid() const;
+	[[nodiscard]] const QVariant& value() const;

-	static const IpcType* ipcType(const QMetaType& metaType);
-};
+	bool setString(const QString& string);
+	void setValue(QVariant value);
+	[[nodiscard]] QString toString() const;

-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]] QGenericArgument asGenericArgument() const;
 	[[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;
+	QVariant mValue;
 };

 struct WireFunctionDefinition {
@@ -173,7 +173,7 @@ void StringCallCommand::exec(qs::ipc::IpcServerConnection* conn) const {
 		func->invoke(handler, storage);

 		resp << Completed {
-		    .isVoid = func->returnType == &VoidIpcType::INSTANCE,
+		    .isVoid = func->returnType.isVoid(),
 		    .returnValue = storage.getReturnStr(),
 		};
 	} else {
@@ -269,11 +269,11 @@ void StringPropReadCommand::exec(qs::ipc::IpcServerConnection* conn) const {
 			return;
 		}

-		auto slot = IpcTypeSlot(prop->type);
+		auto slot = IpcValueSlot(prop->type);
 		prop->read(handler, slot);

 		resp << PropertyValue {
-		    .value = slot.type()->toString(slot.get()),
+		    .value = slot.toString(),
 		};
 	} else {
 		conn->respond(StringCallResponse(NoCurrentGeneration()));
@@ -34,9 +34,8 @@ bool IpcFunction::resolve(QString& error) {

 	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) {
+		if (!IpcValueSlot::isSupported(metaType)) {
 			error = QString("Type of argument %1 (%2: %3) cannot be used across IPC.")
 			            .arg(i + 1)
 			            .arg(this->method.parameterNames().value(i))
@@ -45,23 +44,20 @@ bool IpcFunction::resolve(QString& error) {
 			return false;
 		}

-		this->argumentTypes.append(type);
+		this->argumentTypes.emplaceBack(metaType);
 	}

-	const auto& metaType = this->method.returnMetaType();
-	const auto* type = IpcType::ipcType(metaType);
+	auto metaType = this->method.returnMetaType();

-	if (type == nullptr) {
-		// void and var get mixed by qml engine in return types
-		if (metaType.id() == QMetaType::QVariant) type = &VoidIpcType::INSTANCE;
+	// void and var get mixed by qml engine in return types
+	if (metaType.id() == QMetaType::QVariant) metaType = QMetaType::fromType<void>();

-		if (type == nullptr) {
-			error = QString("Return type (%1) cannot be used across IPC.").arg(metaType.name());
-			return false;
-		}
+	if (!IpcValueSlot::isSupported(metaType)) {
+		error = QString("Return type (%1) cannot be used across IPC.").arg(metaType.name());
+		return false;
 	}

-	this->returnType = type;
+	this->returnType = IpcValueSlot(metaType);

 	return true;
 }
@@ -92,52 +88,53 @@ 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();
+		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();
+	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();
+	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());
+		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());
+	const auto& metaType = this->property.metaType();

-	if (!this->type) {
-		error = QString("Type %1 cannot be used across IPC.").arg(this->property.metaType().name());
+	if (!IpcValueSlot::isSupported(metaType)) {
+		error = QString("Type %1 cannot be used across IPC.").arg(metaType.name());
 		return false;
 	}

+	this->type = metaType;
 	return true;
 }

-void IpcProperty::read(QObject* target, IpcTypeSlot& slot) const {
-	slot.replace(this->property.read(target));
+void IpcProperty::read(QObject* target, IpcValueSlot& slot) const {
+	slot.setValue(this->property.read(target));
 }

 QString IpcProperty::toString() const {
-	return QString("property ") % this->property.name() % ": " % this->type->name();
+	return QString("property ") % this->property.name() % ": " % IpcValueSlot::typeName(this->type);
 }

 WirePropertyDefinition IpcProperty::wireDef() const {
 	WirePropertyDefinition wire;
 	wire.name = this->property.name();
-	wire.type = this->type->name();
+	wire.type = IpcValueSlot::typeName(this->type);
 	return wire;
 }

@@ -217,21 +214,15 @@ IpcCallStorage::IpcCallStorage(const IpcFunction& function): returnSlot(function
 }

 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;
+	return this->argumentSlots.at(i).setString(value);
 }

-QString IpcCallStorage::getReturnStr() {
-	return this->returnSlot.type()->toString(this->returnSlot.get());
-}
+QString IpcCallStorage::getReturnStr() { return this->returnSlot.toString(); }

 IpcHandler::~IpcHandler() {
 	if (this->registeredState.enabled) {
 		this->targetState.enabled = false;
-		this->updateRegistration(true);
+		this->updateRegistration();
 	}
 }

@@ -310,28 +301,34 @@ void IpcHandler::onSignalTriggered(const QString& signal, const QString& value)
 	    -> triggered(this->registeredState.target, signal, value);
 }

-void IpcHandler::updateRegistration(bool destroying) {
+void IpcHandler::updateRegistration() {
 	if (!this->complete) return;

-	auto* generation = EngineGeneration::findObjectGeneration(this);
+	IpcHandlerRegistry* registry = nullptr;
+	if (this->registeredState.enabled) {
+		registry = this->registry.get();
+	} else {
+		auto* generation = EngineGeneration::findObjectGeneration(this);

-	if (!generation) {
-		if (!destroying) {
+		if (!generation) {
 			qmlWarning(this) << "Unable to identify engine generation, cannot register.";
+			return;
 		}

-		return;
+		registry = IpcHandlerRegistry::forGeneration(generation);
 	}

-	auto* registry = IpcHandlerRegistry::forGeneration(generation);
+	if (!registry) return;

 	if (this->registeredState.enabled) {
 		registry->deregisterHandler(this);
+		this->registry = nullptr;
 		qCDebug(logIpcHandler) << "Deregistered" << this << "from registry" << registry;
 	}

 	if (this->targetState.enabled && !this->targetState.target.isEmpty()) {
 		registry->registerHandler(this);
+		this->registry = registry;
 		qCDebug(logIpcHandler) << "Registered" << this << "to registry" << registry;
 	}
 }
@@ -11,6 +11,7 @@
 #include <qmetaobject.h>
 #include <qobject.h>
 #include <qobjectdefs.h>
+#include <qpointer.h>
 #include <qqmlintegration.h>
 #include <qqmlparserstatus.h>
 #include <qtclasshelpermacros.h>
@@ -37,8 +38,8 @@ public:
 	[[nodiscard]] WireFunctionDefinition wireDef() const;

 	QMetaMethod method;
-	QVector<const IpcType*> argumentTypes;
-	const IpcType* returnType = nullptr;
+	QVector<IpcValueSlot> argumentTypes;
+	IpcValueSlot returnType;
 };

 class IpcCallStorage {
@@ -49,8 +50,8 @@ public:
 	[[nodiscard]] QString getReturnStr();

 private:
-	std::vector<IpcTypeSlot> argumentSlots;
-	IpcTypeSlot returnSlot;
+	std::vector<IpcValueSlot> argumentSlots;
+	IpcValueSlot returnSlot;

 	friend class IpcFunction;
 };
@@ -60,13 +61,13 @@ public:
 	explicit IpcProperty(QMetaProperty property): property(property) {}

 	bool resolve(QString& error);
-	void read(QObject* target, IpcTypeSlot& slot) const;
+	void read(QObject* target, IpcValueSlot& slot) const;

 	[[nodiscard]] QString toString() const;
 	[[nodiscard]] WirePropertyDefinition wireDef() const;

 	QMetaProperty property;
-	const IpcType* type = nullptr;
+	QMetaType type;
 };

 class IpcSignalListener: public QObject {
@@ -185,7 +186,7 @@ class IpcHandlerRegistry;
 ///
 ///     function getRadius(): int { return rect.radius; }
 ///
-/// 		signal radiusChanged(newRadius: int);
+///     signal radiusChanged(newRadius: int);
 ///   }
 /// }
 /// ```
@@ -254,7 +255,7 @@ public slots:
 	void onSignalTriggered(const QString& signal, const QString& value) const;

 private:
-	void updateRegistration(bool destroying = false);
+	void updateRegistration();

 	struct RegistrationState {
 		explicit RegistrationState(bool enabled = false): enabled(enabled) {}
@@ -271,10 +272,16 @@ private:
 	QHash<QString, IpcProperty> propertyMap;
 	QHash<QString, IpcSignal> signalMap;

+	QPointer<IpcHandlerRegistry> registry;
+
 	friend class IpcHandlerRegistry;
 };

-class IpcHandlerRegistry: public EngineGenerationExt {
+class IpcHandlerRegistry
+    : public QObject
+    , public EngineGenerationExt {
+	Q_OBJECT;
+
 public:
 	static IpcHandlerRegistry* forGeneration(EngineGeneration* generation);

@@ -1,11 +1,13 @@
 #include "jsonadapter.hpp"

+#include <qassociativeiterable.h>
 #include <qcontainerfwd.h>
 #include <qjsonarray.h>
 #include <qjsondocument.h>
 #include <qjsonobject.h>
 #include <qjsonvalue.h>
 #include <qjsvalue.h>
+#include <qmetacontainer.h>
 #include <qmetaobject.h>
 #include <qnamespace.h>
 #include <qobject.h>
@@ -14,6 +16,7 @@
 #include <qqmlengine.h>
 #include <qqmlinfo.h>
 #include <qqmllist.h>
+#include <qsequentialiterable.h>
 #include <qstringview.h>
 #include <qvariant.h>

@@ -131,13 +134,22 @@ QJsonObject JsonAdapter::serializeRec(const QObject* obj, const QMetaObject* bas
 				}

 				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);
+				if (val.canConvert<QJSValue>()) val = val.value<QJSValue>().toVariant();
+
+				auto jsonVal = QJsonValue::fromVariant(val);
+
+				if (jsonVal.isNull() && !val.isNull() && val.isValid()) {
+					if (val.canConvert<QAssociativeIterable>()) {
+						val.convert(QMetaType::fromType<QVariantMap>());
+					} else if (val.canConvert<QSequentialIterable>()) {
+						val.convert(QMetaType::fromType<QVariantList>());
+					}
+
+					jsonVal = QJsonValue::fromVariant(val);
+				}
+
+				json.insert(prop.name(), jsonVal);
 			}
 		}
 	}
@@ -154,14 +166,16 @@ void JsonAdapter::deserializeRec(const QJsonObject& json, QObject* obj, const QM
 			auto jval = json.value(prop.name());

 			if (prop.metaType() == QMetaType::fromType<QVariant>()) {
-				auto variant = jval.toVariant();
-				auto oldValue = prop.read(this).value<QJSValue>();
+				auto newVariant = jval.toVariant();
+				auto oldValue = prop.read(obj);
+				auto oldVariant =
+				    oldValue.canConvert<QJSValue>() ? oldValue.value<QJSValue>().toVariant() : oldValue;

 				// 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));
+				if (newVariant != oldVariant) {
+					auto jsValue = qmlEngine(this)->fromVariant<QJSValue>(newVariant);
+					prop.write(obj, QVariant::fromValue(jsValue));
 				}
 			} else if (QMetaType::canView(prop.metaType(), QMetaType::fromType<JsonObject*>())) {
 				// FIXME: This doesn't support creating descendants of JsonObject, as QMetaType.metaObject()
@@ -196,7 +210,7 @@ void JsonAdapter::deserializeRec(const QJsonObject& json, QObject* obj, const QM
 			               QMetaType::fromType<QQmlListProperty<JsonObject>>()
 			           ))
 			{
-				auto pval = prop.read(this);
+				auto pval = prop.read(obj);

 				if (pval.canConvert<QQmlListProperty<JsonObject>>()) {
 					auto lp = pval.value<QQmlListProperty<JsonObject>>();
@@ -211,15 +225,15 @@ void JsonAdapter::deserializeRec(const QJsonObject& json, QObject* obj, const QM
 						const auto& jsonValue = array.at(i);
 						if (jsonValue.isObject()) {
 							if (isNew) {
-								currentValue = lp.at(&lp, i);
-								if (this->oldCreatedObjects.removeOne(currentValue)) {
-									this->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);
+							} else {
+								currentValue = lp.at(&lp, i);
+								if (this->oldCreatedObjects.removeOne(currentValue)) {
+									this->createdObjects.push_back(currentValue);
+								}
 							}

 							this->deserializeRec(
@@ -247,12 +261,35 @@ void JsonAdapter::deserializeRec(const QJsonObject& json, QObject* obj, const QM
 				}
 			} else {
 				auto variant = jval.toVariant();
+				auto convVariant = variant;

-				if (variant.convert(prop.metaType())) {
-					prop.write(obj, variant);
+				if (convVariant.convert(prop.metaType())) {
+					prop.write(obj, convVariant);
 				} else {
-					qmlWarning(this) << "Failed to deserialize property " << prop.name() << ": expected "
-					                 << prop.metaType().name() << " but got " << jval.toVariant().typeName();
+					auto pval = prop.read(obj);
+					if (variant.canConvert<QSequentialIterable>() && pval.canView<QSequentialIterable>()) {
+						auto targetv = QVariant(pval.metaType());
+						auto target = targetv.view<QSequentialIterable>().metaContainer();
+						auto valueType = target.valueMetaType();
+						auto i = 0;
+
+						for (QVariant item: variant.value<QSequentialIterable>()) {
+							if (item.convert(valueType)) {
+								target.addValueAtEnd(targetv.data(), item.constData());
+							} else {
+								qmlWarning(this) << "Failed to deserialize list member " << i << " of property "
+								                 << prop.name() << ": expected " << valueType.name() << " but got "
+								                 << item.typeName();
+							}
+
+							++i;
+						}
+						prop.write(obj, targetv);
+					} else {
+						qmlWarning(this) << "Failed to deserialize property " << prop.name() << ": expected "
+						                 << prop.metaType().name() << " but got "
+						                 << jval.toVariant().typeName();
+					}
 				}
 			}
 		}
@@ -272,6 +272,7 @@ void Process::onStarted() {
 }

 void Process::onFinished(qint32 exitCode, QProcess::ExitStatus exitStatus) {
+	QObject::disconnect(this->process, nullptr, this, nullptr);
 	this->process->deleteLater();
 	this->process = nullptr;
 	if (this->mStdoutParser) this->mStdoutParser->streamEnded(this->stdoutBuffer);
@@ -290,6 +291,7 @@ void Process::onErrorOccurred(QProcess::ProcessError error) {
 	if (error == QProcess::FailedToStart) { // other cases should be covered by other events
 		qWarning() << "Process failed to start, likely because the binary could not be found. Command:"
 		           << this->mCommand;
+		QObject::disconnect(this->process, nullptr, this, nullptr);
 		this->process->deleteLater();
 		this->process = nullptr;
 		emit this->runningChanged();
@@ -17,7 +17,11 @@
 QS_LOGGING_CATEGORY(logSocket, "quickshell.io.socket", QtWarningMsg);

 void Socket::setSocket(QLocalSocket* socket) {
-	if (this->socket != nullptr) this->socket->deleteLater();
+	if (this->socket != nullptr) {
+		QObject::disconnect(this->socket, nullptr, this, nullptr);
+		this->socket->deleteLater();
+	}
+
 	this->socket = socket;

 	if (socket != nullptr) {
@@ -57,6 +61,7 @@ void Socket::onSocketDisconnected() {
 	qCDebug(logSocket) << "Socket disconnected:" << this;
 	this->connected = false;
 	this->disconnecting = false;
+	QObject::disconnect(this->socket, nullptr, this, nullptr);
 	this->socket->deleteLater();
 	this->socket = nullptr;
 	this->buffer.clear();
@@ -68,6 +73,13 @@ void Socket::onSocketDisconnected() {
 void Socket::onSocketError(QLocalSocket::LocalSocketError error) {
 	qCWarning(logSocket) << "Socket error for" << this << error;
 	emit this->error(error);
+
+	if (!this->connected) {
+		QObject::disconnect(this->socket, nullptr, this, nullptr);
+		this->socket->deleteLater();
+		this->socket = nullptr;
+		this->disconnecting = false;
+	}
 }

 bool Socket::isConnected() const { return this->connected; }
@@ -191,6 +203,7 @@ void SocketServer::disableServer() {
 		}

 		this->mSockets.clear();
+		QObject::disconnect(this->server, nullptr, this, nullptr);
 		this->server->close();
 		this->server->deleteLater();
 		this->server = nullptr;
@@ -96,7 +96,7 @@ class SocketServer: public Reloadable {
 	Q_OBJECT;
 	/// If the socket server is currently active. Defaults to false.
 	///
-	/// Setting this to false will destory all active connections and delete
+	/// Setting this to false will destroy all active connections and delete
 	/// the socket file on disk.
 	///
 	/// If path is empty setting this property will have no effect.
@@ -105,7 +105,7 @@ class SocketServer: public Reloadable {
 	///
 	/// 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 create a @@Socket.
 	///
 	/// 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.)
@@ -3,6 +3,7 @@
 #include <variant>

 #include <qbuffer.h>
+#include <qcoreapplication.h>
 #include <qlocalserver.h>
 #include <qlocalsocket.h>
 #include <qlogging.h>
@@ -61,6 +62,7 @@ IpcServerConnection::IpcServerConnection(QLocalSocket* socket, IpcServer* server

 void IpcServerConnection::onDisconnected() {
 	qCInfo(logIpc) << "IPC connection disconnected" << this;
+	QObject::disconnect(this->socket, nullptr, this, nullptr);
 	this->deleteLater();
 }

@@ -104,11 +106,19 @@ IpcClient::IpcClient(const QString& path) {
 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::waitForDisconnected() {
+	this->waitingForDisconnect = true;
+	this->socket.waitForDisconnected();
+}

-void IpcClient::onError(QLocalSocket::LocalSocketError error) {
+void IpcClient::kill() {
+	this->sendMessage(IpcCommand(IpcKillCommand()));
+	this->waitForDisconnected();
+}
+
+void IpcClient::onError(QLocalSocket::LocalSocketError error) const {
+	if (this->waitingForDisconnect && error == QLocalSocket::PeerClosedError) return;
 	qCCritical(logIpc) << "Socket Error" << error;
 }

@@ -127,7 +137,9 @@ int IpcClient::connect(const QString& id, const std::function<void(IpcClient& cl

 void IpcKillCommand::exec(IpcServerConnection* /*unused*/) {
 	qInfo() << "Exiting due to IPC request.";
-	EngineGeneration::currentGeneration()->quit();
+	auto* generation = EngineGeneration::currentGeneration();
+	if (generation) generation->quit();
+	else QCoreApplication::exit(0);
 }

 } // namespace qs::ipc
@@ -19,7 +19,7 @@

 template <typename... Types>
 constexpr void assertSerializable() {
-	// monostate being zero ensures transactional reads wont break
+	// monostate being zero ensures transactional reads won't 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."
@@ -216,7 +216,10 @@ signals:
 	void disconnected();

 private slots:
-	static void onError(QLocalSocket::LocalSocketError error);
+	void onError(QLocalSocket::LocalSocketError error) const;
+
+private:
+	bool waitingForDisconnect = false;
 };

 } // namespace qs::ipc
@@ -2,6 +2,7 @@
 #include <array>
 #include <cerrno>
 #include <cstring>
+#include <functional>
 #include <utility>

 #include <qconfig.h>
@@ -12,7 +13,6 @@
 #include <qdebug.h>
 #include <qdir.h>
 #include <qfileinfo.h>
-#include <qguiapplication.h>
 #include <qjsonarray.h>
 #include <qjsondocument.h>
 #include <qjsonobject.h>
@@ -25,12 +25,12 @@
 #include <qtversion.h>
 #include <unistd.h>

+#include "../core/debuginfo.hpp"
 #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 {
@@ -120,7 +120,7 @@ int locateConfigFile(CommandState& cmd, QString& path) {
 					return -1;
 				}
 			} else {
-				qCCritical(logBare) << "Could not open maifest at path" << *cmd.config.manifest;
+				qCCritical(logBare) << "Could not open manifest at path" << *cmd.config.manifest;
 				return -1;
 			}
 		} else {
@@ -165,7 +165,12 @@ void sortInstances(QVector<InstanceLockInfo>& list, bool newestFirst) {
 	});
 };

-int selectInstance(CommandState& cmd, InstanceLockInfo* instance, bool deadFallback = false) {
+int selectInstance(
+    CommandState& cmd,
+    InstanceLockInfo* instance,
+    bool deadFallback = false,
+    bool logHelp = true
+) {
 	auto* basePath = QsPaths::instance()->baseRunDir();
 	if (!basePath) return -1;

@@ -174,18 +179,22 @@ int selectInstance(CommandState& cmd, InstanceLockInfo* instance, bool deadFallb
 	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;
+			if (logHelp) 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] =
+		auto [liveInstances, mismatchedInstances, deadInstances] =
 		    QsPaths::collectInstances(path, cmd.config.anyDisplay ? "" : getDisplayConnection());

 		liveInstances.removeIf([&](const InstanceLockInfo& info) {
 			return !info.instance.instanceId.startsWith(*cmd.instance.id);
 		});

+		mismatchedInstances.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);
 		});
@@ -193,27 +202,43 @@ int selectInstance(CommandState& cmd, InstanceLockInfo* instance, bool deadFallb
 		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 (logHelp) {
+				if (!mismatchedInstances.isEmpty()) {
+					qCInfo(logBare) << "No running instances on the current display" << getDisplayConnection()
+					                << "start with" << *cmd.instance.id;

-				if (!deadInstances.isEmpty()) {
-					qCInfo(logBare) << "Some dead instances match:";
+					qCInfo(logBare) << "Some instances on other displays match:";

-					for (auto& instance: deadInstances) {
-						qCInfo(logBare).noquote() << " -" << instance.instance.instanceId;
+					for (auto& instance: mismatchedInstances) {
+						qCInfo(logBare).noquote().nospace() << " - " << instance.instance.instanceId << " ("
+						                                    << instance.instance.display << ')';
+					}
+				}
+
+				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;
+			if (logHelp) {
+				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)" : "");
+				for (auto& instance: instances) {
+					qCInfo(logBare).noquote()
+					    << " -" << instance.instance.instanceId << (instance.pid == -1 ? "(dead)" : "");
+				}
 			}

 			return -1;
@@ -230,7 +255,7 @@ int selectInstance(CommandState& cmd, InstanceLockInfo* instance, bool deadFallb

 		path = QDir(basePath->filePath("by-path")).filePath(pathId);

-		auto [liveInstances, deadInstances] =
+		auto [liveInstances, mismatchedInstances, deadInstances] =
 		    QsPaths::collectInstances(path, cmd.config.anyDisplay ? "" : getDisplayConnection());

 		auto instances = liveInstances;
@@ -244,16 +269,29 @@ int selectInstance(CommandState& cmd, InstanceLockInfo* instance, bool deadFallb
 		);

 		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;
+			if (logHelp) {
+				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 if (!mismatchedInstances.isEmpty()) {
+					qCInfo(logBare) << "No running instances for" << configFilePath
+					                << " present on the current display" << getDisplayConnection();
+
+					qCInfo(logBare) << "Some instances on other displays match:";
+
+					for (auto& instance: mismatchedInstances) {
+						qCInfo(logBare).noquote().nospace() << " - " << instance.instance.instanceId << " ("
+						                                    << instance.instance.display << ')';
+					}
+				} else {
+					qCInfo(logBare) << "No running instances for" << configFilePath;
 				}
-			} else {
-				qCInfo(logBare) << "No running instances for" << configFilePath;
 			}
+
 			return -1;
 		}

@@ -314,7 +352,7 @@ int listInstances(CommandState& cmd) {
 		path = QDir(basePath->filePath("by-path")).filePath(pathId);
 	}

-	auto [liveInstances, deadInstances] = QsPaths::collectInstances(
+	auto [liveInstances, mismatchedInstances, deadInstances] = QsPaths::collectInstances(
 	    path,
 	    cmd.config.anyDisplay || cmd.instance.all ? "" : getDisplayConnection()
 	);
@@ -428,7 +466,7 @@ int ipcCommand(CommandState& cmd) {
 	});
 }

-int launchFromCommand(CommandState& cmd, QCoreApplication* coreApplication) {
+int launchFromCommand(CommandState& cmd) {
 	QString configPath;

 	auto r = locateConfigFile(cmd, configPath);
@@ -436,7 +474,7 @@ int launchFromCommand(CommandState& cmd, QCoreApplication* coreApplication) {

 	{
 		InstanceLockInfo info;
-		if (cmd.misc.noDuplicate && selectInstance(cmd, &info) == 0) {
+		if (cmd.misc.noDuplicate && selectInstance(cmd, &info, false, false) == 0) {
 			qCInfo(logBare) << "An instance of this configuration is already running.";
 			return 0;
 		}
@@ -448,14 +486,13 @@ int launchFromCommand(CommandState& cmd, QCoreApplication* coreApplication) {
 	        .debugPort = cmd.debug.port,
 	        .waitForDebug = cmd.debug.wait,
 	    },
-	    cmd.exec.argv,
-	    coreApplication
+	    cmd.exec.argv
 	);
 }

 } // namespace

-int runCommand(int argc, char** argv, QCoreApplication* coreApplication) {
+int runCommand(int argc, char** argv) {
 	auto state = CommandState();
 	if (auto ret = parseCommand(argc, argv, state); ret != 65535) return ret;

@@ -518,30 +555,24 @@ int runCommand(int argc, char** argv, QCoreApplication* coreApplication) {
 		);
 	}

+	std::function<int(CommandState&)> continuation;
+
 	if (state.misc.printVersion) {
-		qCInfo(logBare).noquote().nospace() << "quickshell " << QS_VERSION << ", 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() << "Quickshell" << qs::debuginfo::qsVersion();
+		} else {
+			qCInfo(logBare).noquote() << qs::debuginfo::combinedInfo();
 		}

-		if (state.log.verbosity > 0) {
-			qCInfo(logBare).noquote() << "\nBuild Type:" << BUILD_TYPE;
-			qCInfo(logBare).noquote() << "Build configuration:";
-			qCInfo(logBare).noquote().nospace() << BUILD_CONFIGURATION;
-		}
+		return 0;
 	} else if (*state.subcommand.log) {
-		return readLogFile(state);
+		continuation = readLogFile;
 	} else if (*state.subcommand.list) {
-		return listInstances(state);
+		continuation = listInstances;
 	} else if (*state.subcommand.kill) {
-		return killInstances(state);
+		continuation = killInstances;
 	} else if (*state.subcommand.msg || *state.ipc.ipc) {
-		return ipcCommand(state);
+		continuation = ipcCommand;
 	} else {
 		if (strcmp(qVersion(), QT_VERSION_STR) != 0) {
 			qWarning() << "\033[31mQuickshell was built against Qt" << QT_VERSION_STR
@@ -550,23 +581,26 @@ int runCommand(int argc, char** argv, QCoreApplication* coreApplication) {
 			              "the quickshell package must be rebuilt.\n";
 		}

-		return launchFromCommand(state, coreApplication);
+		return launchFromCommand(state);
 	}

-	return 0;
+	int qArgc = 1;
+	auto coreApp = QCoreApplication(qArgc, argv);
+	return continuation(state);
 }

 QString getDisplayConnection() {
-	auto platform = qEnvironmentVariable("QT_QPA_PLATFORM");
+	// Doesn't actually have to match what qt picks, but will 99% of the time.
+	// Running quickshell under wayland in x11 mode doesn't really make any sense.
 	auto wlDisplay = qEnvironmentVariable("WAYLAND_DISPLAY");
 	auto xDisplay = qEnvironmentVariable("DISPLAY");

-	if (platform == "wayland" || (platform.isEmpty() && !wlDisplay.isEmpty())) {
-		return "wayland," + wlDisplay;
-	} else if (platform == "xcb" || (platform.isEmpty() && !xDisplay.isEmpty())) {
-		return "x11," + xDisplay;
+	if (!wlDisplay.isEmpty()) {
+		return "wayland/" + wlDisplay;
+	} else if (!xDisplay.isEmpty()) {
+		return "x11/" + xDisplay;
 	} else {
-		return "unk," + QGuiApplication::platformName();
+		return "unk";
 	}
 }

@@ -22,12 +22,13 @@
 #include "../core/logging.hpp"
 #include "../core/paths.hpp"
 #include "../core/plugin.hpp"
+#include "../core/qmlglobal.hpp"
 #include "../core/rootwrapper.hpp"
 #include "../ipc/ipc.hpp"
 #include "build.hpp"
 #include "launch_p.hpp"

-#if CRASH_REPORTER
+#if CRASH_HANDLER
 #include "../crash/handler.hpp"
 #endif

@@ -57,7 +58,7 @@ QString base36Encode(T number) {

 } // namespace

-int launch(const LaunchArgs& args, char** argv, QCoreApplication* coreApplication) {
+int launch(const LaunchArgs& args, char** argv) {
 	auto pathId = QCryptographicHash::hash(args.configPath.toUtf8(), QCryptographicHash::Md5).toHex();
 	auto shellId = QString(pathId);

@@ -76,6 +77,9 @@ int launch(const LaunchArgs& args, char** argv, QCoreApplication* coreApplicatio
 		bool useSystemStyle = false;
 		QString iconTheme = qEnvironmentVariable("QS_ICON_THEME");
 		QHash<QString, QString> envOverrides;
+		QHash<QString, QString> defaultEnv;
+		QString appId = qEnvironmentVariable("QS_APP_ID");
+		bool dropExpensiveFonts = false;
 		QString dataDir;
 		QString stateDir;
 		QString cacheDir;
@@ -87,23 +91,31 @@ int launch(const LaunchArgs& args, char** argv, QCoreApplication* coreApplicatio
 		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('=');
+			auto isEnv = pragma.startsWith("Env ");
+			auto isDefaultEnv = pragma.startsWith("DefaultEnv ");
+
+			if (isEnv || isDefaultEnv) {
+				auto content = pragma.sliced(isDefaultEnv ? 11 : 4);
+				auto splitIdx = content.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);
+				auto var = content.sliced(0, splitIdx).trimmed();
+				auto val = content.sliced(splitIdx + 1).trimmed();
+
+				if (isDefaultEnv) pragmas.defaultEnv.insert(var, val);
+				else pragmas.envOverrides.insert(var, val);
+			} else 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 == "DropExpensiveFonts") pragmas.dropExpensiveFonts = true;
+			else if (pragma.startsWith("IconTheme ")) pragmas.iconTheme = pragma.sliced(10);
+			else if (pragma.startsWith("AppId ")) {
+				pragmas.appId = pragma.sliced(6).trimmed();
 			} else if (pragma.startsWith("ShellId ")) {
 				shellId = pragma.sliced(8).trimmed();
 			} else if (pragma.startsWith("DataDir ")) {
@@ -113,8 +125,7 @@ int launch(const LaunchArgs& args, char** argv, QCoreApplication* coreApplicatio
 			} else if (pragma.startsWith("CacheDir ")) {
 				pragmas.cacheDir = pragma.sliced(9).trimmed();
 			} else {
-				qCritical() << "Unrecognized pragma" << pragma;
-				return -1;
+				qWarning() << "Unrecognized pragma" << pragma;
 			}
 		} else if (line.startsWith("import")) break;
 	}
@@ -128,22 +139,26 @@ int launch(const LaunchArgs& args, char** argv, QCoreApplication* coreApplicatio
 	qInfo() << "Shell ID:" << shellId << "Path ID" << pathId;

 	auto launchTime = qs::Common::LAUNCH_TIME.toSecsSinceEpoch();
+	auto appId = pragmas.appId.isEmpty() ? QStringLiteral("org.quickshell") : pragmas.appId;
+
 	InstanceInfo::CURRENT = InstanceInfo {
 	    .instanceId = base36Encode(getpid()) + base36Encode(launchTime),
 	    .configPath = args.configPath,
 	    .shellId = shellId,
+	    .appId = appId,
 	    .launchTime = qs::Common::LAUNCH_TIME,
 	    .pid = getpid(),
 	    .display = getDisplayConnection(),
 	};

-#if CRASH_REPORTER
-	auto crashHandler = crash::CrashHandler();
-	crashHandler.init();
+#if CRASH_HANDLER
+	if (qEnvironmentVariableIsSet("QS_DISABLE_CRASH_HANDLER")) {
+		qInfo() << "Crash handling disabled.";
+	} else {
+		crash::CrashHandler::init();

-	{
 		auto* log = LogManager::instance();
-		crashHandler.setRelaunchInfo({
+		crash::CrashHandler::setRelaunchInfo({
 		    .instance = InstanceInfo::CURRENT,
 		    .noColor = !log->colorLogs,
 		    .timestamp = log->timestampLogs,
@@ -157,7 +172,6 @@ int launch(const LaunchArgs& args, char** argv, QCoreApplication* coreApplicatio
 	QsPaths::init(shellId, pathId, pragmas.dataDir, pragmas.stateDir, pragmas.cacheDir);
 	QsPaths::instance()->linkRunDir();
 	QsPaths::instance()->linkPathDir();
-	LogManager::initFs();

 	Common::INITIAL_ENVIRONMENT = QProcessEnvironment::systemEnvironment();

@@ -166,10 +180,56 @@ int launch(const LaunchArgs& args, char** argv, QCoreApplication* coreApplicatio
 		qputenv("QT_QUICK_CONTROLS_STYLE", "Fusion");
 	}

+	for (auto [var, val]: pragmas.defaultEnv.asKeyValueRange()) {
+		if (!qEnvironmentVariableIsSet(var.toUtf8())) qputenv(var.toUtf8(), val.toUtf8());
+	}
+
 	for (auto [var, val]: pragmas.envOverrides.asKeyValueRange()) {
 		qputenv(var.toUtf8(), val.toUtf8());
 	}

+	pragmas.dropExpensiveFonts |= qEnvironmentVariableIntValue("QS_DROP_EXPENSIVE_FONTS") == 1;
+
+	if (pragmas.dropExpensiveFonts) {
+		if (auto* runDir = QsPaths::instance()->instanceRunDir()) {
+			auto baseConfigPath = qEnvironmentVariable("FONTCONFIG_FILE");
+			if (baseConfigPath.isEmpty()) baseConfigPath = "/etc/fonts/fonts.conf";
+
+			auto filterPath = runDir->filePath("fonts-override.conf");
+			auto filterFile = QFile(filterPath);
+			if (filterFile.open(QFile::WriteOnly | QFile::Truncate | QFile::Text)) {
+				auto filterTemplate = QStringLiteral(R"(<?xml version="1.0"?>
+<!DOCTYPE fontconfig SYSTEM "urn:fontconfig:fonts.dtd">
+<fontconfig>
+	<include ignore_missing="no">%1</include>
+	<selectfont>
+		<rejectfont>
+			<pattern>
+				<patelt name="fontwrapper">
+					<string>woff</string>
+				</patelt>
+			</pattern>
+			<pattern>
+				<patelt name="fontwrapper">
+					<string>woff2</string>
+				</patelt>
+			</pattern>
+		</rejectfont>
+	</selectfont>
+</fontconfig>
+)");
+
+				QTextStream(&filterFile) << filterTemplate.arg(baseConfigPath);
+				filterFile.close();
+				qputenv("FONTCONFIG_FILE", filterPath.toUtf8());
+			} else {
+				qCritical() << "Could not write fontconfig filter to" << filterPath;
+			}
+		} else {
+			qCritical() << "Could not create fontconfig filter: instance run directory unavailable";
+		}
+	}
+
 	// The qml engine currently refuses to cache non file (qsintercept) paths.

 	// if (auto* cacheDir = QsPaths::instance()->cacheDir()) {
@@ -219,8 +279,6 @@ int launch(const LaunchArgs& args, char** argv, QCoreApplication* coreApplicatio

 	QGuiApplication::setDesktopSettingsAware(pragmas.desktopSettingsAware);

-	delete coreApplication;
-
 	QGuiApplication* app = nullptr;
 	auto qArgC = 0;

@@ -230,7 +288,10 @@ int launch(const LaunchArgs& args, char** argv, QCoreApplication* coreApplicatio
 		app = new QGuiApplication(qArgC, argv);
 	}

-	QGuiApplication::setDesktopFileName("org.quickshell");
+	LogManager::initThreadLogging();
+	LogManager::initFs();
+
+	QGuiApplication::setDesktopFileName(appId);

 	if (args.debugPort != -1) {
 		QQmlDebuggingEnabler::enableDebugging(true);
@@ -239,6 +300,10 @@ int launch(const LaunchArgs& args, char** argv, QCoreApplication* coreApplicatio
 		QQmlDebuggingEnabler::startTcpDebugServer(args.debugPort, wait);
 	}

+	// This needs to run early to get the first connection to QGuiApplication::screenAdded() in Qs.
+	// If we don't do that, attempts to get a QuickshellScreenInfo from a QScreen will fail in screenAdded bindings.
+	QuickshellTracked::init();
+
 	QsEnginePlugin::initPlugins();

 	// Base window transparency appears to be additive.
@@ -107,10 +107,10 @@ struct LaunchArgs {
 void exitDaemon(int code);

 int parseCommand(int argc, char** argv, CommandState& state);
-int runCommand(int argc, char** argv, QCoreApplication* coreApplication);
+int runCommand(int argc, char** argv);

 QString getDisplayConnection();

-int launch(const LaunchArgs& args, char** argv, QCoreApplication* coreApplication);
+int launch(const LaunchArgs& args, char** argv);

 } // namespace qs::launch
@@ -16,7 +16,7 @@
 #include "build.hpp"
 #include "launch_p.hpp"

-#if CRASH_REPORTER
+#if CRASH_HANDLER
 #include "../crash/main.hpp"
 #endif

@@ -24,23 +24,31 @@ namespace qs::launch {

 namespace {

-void checkCrashRelaunch(char** argv, QCoreApplication* coreApplication) {
-#if CRASH_REPORTER
+void checkCrashRelaunch(char** argv) {
+#if CRASH_HANDLER
 	auto lastInfoFdStr = qEnvironmentVariable("__QUICKSHELL_CRASH_INFO_FD");
+	auto dumpPid = qEnvironmentVariable("__QUICKSHELL_CRASH_DUMP_PID").toInt();

 	if (!lastInfoFdStr.isEmpty()) {
 		auto lastInfoFd = lastInfoFdStr.toInt();

-		QFile file;
-		if (!file.open(lastInfoFd, QFile::ReadOnly, QFile::AutoCloseHandle)) {
-			qFatal() << "Failed to open crash info fd. Cannot restart.";
+		RelaunchInfo info;
+
+		{
+			QFile file;
+			if (!file.open(lastInfoFd, QFile::ReadOnly, QFile::AutoCloseHandle)) {
+				qFatal() << "Failed to open crash info fd. Cannot restart.";
+			}
+
+			file.seek(0);
+
+			auto ds = QDataStream(&file);
+			ds >> info;
 		}

-		file.seek(0);
-
-		auto ds = QDataStream(&file);
-		RelaunchInfo info;
-		ds >> info;
+		qunsetenv("__QUICKSHELL_CRASH_INFO_FD");
+		qunsetenv("__QUICKSHELL_CRASH_DUMP_PID");
+		qunsetenv("__QUICKSHELL_CRASH_SIGNAL");

 		LogManager::init(
 		    !info.noColor,
@@ -50,8 +58,7 @@ void checkCrashRelaunch(char** argv, QCoreApplication* coreApplication) {
 		    info.logRules
 		);

-		qCritical().nospace() << "Quickshell has crashed under pid "
-		                      << qEnvironmentVariable("__QUICKSHELL_CRASH_DUMP_PID").toInt()
+		qCritical().nospace() << "Quickshell has crashed under pid " << dumpPid
 		                      << " (Coredumps will be available under that pid.)";

 		qCritical() << "Further crash information is stored under"
@@ -64,7 +71,7 @@ void checkCrashRelaunch(char** argv, QCoreApplication* coreApplication) {
 		} else {
 			qCritical() << "Quickshell has been restarted.";

-			launch({.configPath = info.instance.configPath}, argv, coreApplication);
+			launch({.configPath = info.instance.configPath}, argv);
 		}
 	}
 #endif
@@ -84,35 +91,40 @@ void exitDaemon(int code) {

 	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";
+	auto fd = open("/dev/null", O_RDWR);
+	if (fd == -1) {
+		qCritical().nospace() << "Failed to open /dev/null for daemon stdio" << errno << ": "
+		                      << qt_error_string();
+		return;
 	}

-	if (open("/dev/null", O_WRONLY) != STDOUT_FILENO) { // NOLINT
-		qFatal() << "Failed to open /dev/null on stdout";
+	if (dup2(fd, STDIN_FILENO) != STDIN_FILENO) { // NOLINT
+		qCritical().nospace() << "Failed to set daemon stdin to /dev/null" << errno << ": "
+		                      << qt_error_string();
 	}

-	if (open("/dev/null", O_WRONLY) != STDERR_FILENO) { // NOLINT
-		qFatal() << "Failed to open /dev/null on stderr";
+	if (dup2(fd, STDOUT_FILENO) != STDOUT_FILENO) { // NOLINT
+		qCritical().nospace() << "Failed to set daemon stdout to /dev/null" << errno << ": "
+		                      << qt_error_string();
 	}
+
+	if (dup2(fd, STDERR_FILENO) != STDERR_FILENO) { // NOLINT
+		qCritical().nospace() << "Failed to set daemon stderr to /dev/null" << errno << ": "
+		                      << qt_error_string();
+	}
+
+	close(fd);
 }

 int main(int argc, char** argv) {
 	QCoreApplication::setApplicationName("quickshell");

-#if CRASH_REPORTER
+#if CRASH_HANDLER
 	qsCheckCrash(argc, argv);
 #endif

-	auto qArgC = 1;
-	auto* coreApplication = new QCoreApplication(qArgC, argv);
-
-	checkCrashRelaunch(argv, coreApplication);
-	auto code = runCommand(argc, argv, coreApplication);
+	checkCrashRelaunch(argv);
+	auto code = runCommand(argc, argv);

 	exitDaemon(code);
 	return code;
@@ -3,7 +3,10 @@ add_subdirectory(nm)
 qt_add_library(quickshell-network STATIC
 	network.cpp
 	device.cpp
+	wired.cpp
 	wifi.cpp
+	enums.cpp
+	qml.cpp
 )

 target_include_directories(quickshell-network PRIVATE 
@@ -8,6 +8,8 @@
 #include <qtmetamacros.h>

 #include "../core/logcat.hpp"
+#include "enums.hpp"
+#include "network.hpp"

 namespace qs::network {

@@ -15,49 +17,9 @@ namespace {
 QS_LOGGING_CATEGORY(logNetworkDevice, "quickshell.network.device", QtWarningMsg);
 } // namespace

-QString DeviceConnectionState::toString(DeviceConnectionState::Enum state) {
-	switch (state) {
-	case Unknown: return QStringLiteral("Unknown");
-	case Connecting: return QStringLiteral("Connecting");
-	case Connected: return QStringLiteral("Connected");
-	case Disconnecting: return QStringLiteral("Disconnecting");
-	case Disconnected: return QStringLiteral("Disconnected");
-	default: return QStringLiteral("Unknown");
-	}
-}
-
-QString DeviceType::toString(DeviceType::Enum type) {
-	switch (type) {
-	case None: return QStringLiteral("None");
-	case Wifi: return QStringLiteral("Wifi");
-	default: return QStringLiteral("Unknown");
-	}
-}
-
-QString NMDeviceState::toString(NMDeviceState::Enum state) {
-	switch (state) {
-	case Unknown: return QStringLiteral("Unknown");
-	case Unmanaged: return QStringLiteral("Not managed by NetworkManager");
-	case Unavailable: return QStringLiteral("Unavailable");
-	case Disconnected: return QStringLiteral("Disconnected");
-	case Prepare: return QStringLiteral("Preparing to connect");
-	case Config: return QStringLiteral("Connecting to a network");
-	case NeedAuth: return QStringLiteral("Waiting for authentication");
-	case IPConfig: return QStringLiteral("Requesting IPv4 and/or IPv6 addresses from the network");
-	case IPCheck:
-		return QStringLiteral("Checking if further action is required for the requested connection");
-	case Secondaries:
-		return QStringLiteral("Waiting for a required secondary connection to activate");
-	case Activated: return QStringLiteral("Connected");
-	case Deactivating: return QStringLiteral("Disconnecting");
-	case Failed: return QStringLiteral("Failed to connect");
-	default: return QStringLiteral("Unknown");
-	};
-}
-
 NetworkDevice::NetworkDevice(DeviceType::Enum type, QObject* parent): QObject(parent), mType(type) {
 	this->bindableConnected().setBinding([this]() {
-		return this->bState == DeviceConnectionState::Connected;
+		return this->bState == ConnectionState::Connected;
 	});
 };

@@ -66,12 +28,17 @@ void NetworkDevice::setAutoconnect(bool autoconnect) {
 	emit this->requestSetAutoconnect(autoconnect);
 }

+void NetworkDevice::setNmManaged(bool managed) {
+	if (this->bNmManaged == managed) return;
+	emit this->requestSetNmManaged(managed);
+}
+
 void NetworkDevice::disconnect() {
-	if (this->bState == DeviceConnectionState::Disconnected) {
+	if (this->bState == ConnectionState::Disconnected) {
 		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnected";
 		return;
 	}
-	if (this->bState == DeviceConnectionState::Disconnecting) {
+	if (this->bState == ConnectionState::Disconnecting) {
 		qCCritical(logNetworkDevice) << "Device" << this << "is already disconnecting";
 		return;
 	}
@@ -79,4 +46,7 @@ void NetworkDevice::disconnect() {
 	this->requestDisconnect();
 }

+void NetworkDevice::networkAdded(Network* net) { this->mNetworks.insertObject(net); }
+void NetworkDevice::networkRemoved(Network* net) { this->mNetworks.removeObject(net); }
+
 } // namespace qs::network
@@ -6,88 +6,44 @@
 #include <qtmetamacros.h>
 #include <qtypes.h>

+#include "../core/doc.hpp"
+#include "../core/model.hpp"
+#include "enums.hpp"
+#include "network.hpp"
+
 namespace qs::network {

-///! Connection state of a NetworkDevice.
-class DeviceConnectionState: public QObject {
-	Q_OBJECT;
-	QML_ELEMENT;
-	QML_SINGLETON;
-
-public:
-	enum Enum : quint8 {
-		Unknown = 0,
-		Connecting = 1,
-		Connected = 2,
-		Disconnecting = 3,
-		Disconnected = 4,
-	};
-	Q_ENUM(Enum);
-	Q_INVOKABLE static QString toString(DeviceConnectionState::Enum state);
-};
-
-///! Type of network device.
-class DeviceType: public QObject {
-	Q_OBJECT;
-	QML_ELEMENT;
-	QML_SINGLETON;
-
-public:
-	enum Enum : quint8 {
-		None = 0,
-		Wifi = 1,
-	};
-	Q_ENUM(Enum);
-	Q_INVOKABLE static QString toString(DeviceType::Enum type);
-};
-
-///! NetworkManager-specific device state.
-/// In sync with https://networkmanager.dev/docs/api/latest/nm-dbus-types.html#NMDeviceState.
-class NMDeviceState: public QObject {
-	Q_OBJECT;
-	QML_ELEMENT;
-	QML_SINGLETON;
-
-public:
-	enum Enum : quint8 {
-		Unknown = 0,
-		Unmanaged = 10,
-		Unavailable = 20,
-		Disconnected = 30,
-		Prepare = 40,
-		Config = 50,
-		NeedAuth = 60,
-		IPConfig = 70,
-		IPCheck = 80,
-		Secondaries = 90,
-		Activated = 100,
-		Deactivating = 110,
-		Failed = 120,
-	};
-	Q_ENUM(Enum);
-	Q_INVOKABLE static QString toString(NMDeviceState::Enum state);
-};
-
 ///! A network device.
-/// When @@type is `Wifi`, the device is a @@WifiDevice, which can be used to scan for and connect to access points.
+/// The @@type property may be used to determine if this device is a @@WifiDevice or @@WiredDevice.
 class NetworkDevice: public QObject {
 	Q_OBJECT;
 	QML_ELEMENT;
 	QML_UNCREATABLE("Devices can only be acquired through Network");
 	// clang-format off
 	/// The device type.
+	///
+	/// When the device type is `Wifi`, the device object is a @@WifiDevice.
+	/// When the device type is `Wired`, the device object is a @@WiredDevice.
+	/// connection and scanning.
 	Q_PROPERTY(DeviceType::Enum type READ type CONSTANT);
 	/// The name of the device's control interface.
 	Q_PROPERTY(QString name READ name NOTIFY nameChanged BINDABLE bindableName);
+	/// A list of available or connected networks for this device.
+	///
+	/// When the device type is 'Wifi', this model will only contain @@WifiNetwork.
+	QSDOC_TYPE_OVERRIDE(ObjectModel<Network>*);
+	Q_PROPERTY(UntypedObjectModel* networks READ networks CONSTANT);
 	/// The hardware address of the device in the XX:XX:XX:XX:XX:XX format.
 	Q_PROPERTY(QString address READ default NOTIFY addressChanged BINDABLE bindableAddress);
 	/// True if the device is connected.
 	Q_PROPERTY(bool connected READ default NOTIFY connectedChanged BINDABLE bindableConnected);
 	/// Connection state of the device.
-	Q_PROPERTY(qs::network::DeviceConnectionState::Enum state READ default NOTIFY stateChanged BINDABLE bindableState);
-	/// A more specific device state when the backend is NetworkManager.
-	Q_PROPERTY(qs::network::NMDeviceState::Enum nmState READ default NOTIFY nmStateChanged BINDABLE bindableNmState);
-	/// True if the device is allowed to autoconnect.
+	Q_PROPERTY(qs::network::ConnectionState::Enum state READ default NOTIFY stateChanged BINDABLE bindableState);
+	/// True if the device is managed by NetworkManager.
+	///
+	/// > [!WARNING] Only valid for the NetworkManager backend.
+	Q_PROPERTY(bool nmManaged READ nmManaged WRITE setNmManaged NOTIFY nmManagedChanged)
+	/// True if the device is allowed to autoconnect to a network.
 	Q_PROPERTY(bool autoconnect READ autoconnect WRITE setAutoconnect NOTIFY autoconnectChanged);
 	// clang-format on

@@ -97,35 +53,45 @@ public:
 	/// Disconnects the device and prevents it from automatically activating further connections.
 	Q_INVOKABLE void disconnect();

-	[[nodiscard]] DeviceType::Enum type() const { return this->mType; };
-	QBindable<QString> bindableName() { return &this->bName; };
-	[[nodiscard]] QString name() const { return this->bName; };
-	QBindable<QString> bindableAddress() { return &this->bAddress; };
-	QBindable<bool> bindableConnected() { return &this->bConnected; };
-	QBindable<DeviceConnectionState::Enum> bindableState() { return &this->bState; };
-	QBindable<NMDeviceState::Enum> bindableNmState() { return &this->bNmState; };
-	[[nodiscard]] bool autoconnect() const { return this->bAutoconnect; };
-	QBindable<bool> bindableAutoconnect() { return &this->bAutoconnect; };
+	virtual void networkAdded(Network* net);
+	virtual void networkRemoved(Network* net);
+
+	[[nodiscard]] ObjectModel<Network>* networks() { return &this->mNetworks; }
+	[[nodiscard]] DeviceType::Enum type() const { return this->mType; }
+	QBindable<QString> bindableName() { return &this->bName; }
+	[[nodiscard]] QString name() const { return this->bName; }
+	QBindable<QString> bindableAddress() { return &this->bAddress; }
+	QBindable<bool> bindableConnected() { return &this->bConnected; }
+	QBindable<ConnectionState::Enum> bindableState() { return &this->bState; }
+	QBindable<bool> bindableNmManaged() { return &this->bNmManaged; }
+	[[nodiscard]] bool nmManaged() { return this->bNmManaged; }
+	void setNmManaged(bool managed);
+	QBindable<bool> bindableAutoconnect() { return &this->bAutoconnect; }
+	[[nodiscard]] bool autoconnect() { return this->bAutoconnect; }
 	void setAutoconnect(bool autoconnect);

 signals:
-	void requestDisconnect();
-	void requestSetAutoconnect(bool autoconnect);
+	QSDOC_HIDE void requestDisconnect();
+	QSDOC_HIDE void requestSetAutoconnect(bool autoconnect);
+	QSDOC_HIDE void requestSetNmManaged(bool managed);
 	void nameChanged();
 	void addressChanged();
 	void connectedChanged();
 	void stateChanged();
-	void nmStateChanged();
+	void nmManagedChanged();
 	void autoconnectChanged();

+protected:
+	ObjectModel<Network> mNetworks {this};
+
 private:
 	DeviceType::Enum mType;
 	// clang-format off
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, QString, bName, &NetworkDevice::nameChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, QString, bAddress, &NetworkDevice::addressChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, bool, bConnected, &NetworkDevice::connectedChanged);
-	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, DeviceConnectionState::Enum, bState, &NetworkDevice::stateChanged);
-	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, NMDeviceState::Enum, bNmState, &NetworkDevice::nmStateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, ConnectionState::Enum, bState, &NetworkDevice::stateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, bool, bNmManaged, &NetworkDevice::nmManagedChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(NetworkDevice, bool, bAutoconnect, &NetworkDevice::autoconnectChanged);
 	// clang-format on
 };
@@ -0,0 +1,87 @@
+#include "enums.hpp"
+
+#include <qstring.h>
+
+namespace qs::network {
+
+QString NetworkConnectivity::toString(NetworkConnectivity::Enum conn) {
+	switch (conn) {
+	case Unknown: return QStringLiteral("Unknown");
+	case None: return QStringLiteral("Not connected to a network");
+	case Portal: return QStringLiteral("Connection intercepted by a captive portal");
+	case Limited: return QStringLiteral("Partial internet connectivity");
+	case Full: return QStringLiteral("Full internet connectivity");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+QString NetworkBackendType::toString(NetworkBackendType::Enum type) {
+	switch (type) {
+	case NetworkBackendType::None: return "None";
+	case NetworkBackendType::NetworkManager: return "NetworkManager";
+	default: return "Unknown";
+	}
+}
+
+QString ConnectionState::toString(ConnectionState::Enum state) {
+	switch (state) {
+	case Unknown: return QStringLiteral("Unknown");
+	case Connecting: return QStringLiteral("Connecting");
+	case Connected: return QStringLiteral("Connected");
+	case Disconnecting: return QStringLiteral("Disconnecting");
+	case Disconnected: return QStringLiteral("Disconnected");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+QString ConnectionFailReason::toString(ConnectionFailReason::Enum reason) {
+	switch (reason) {
+	case Unknown: return QStringLiteral("Unknown");
+	case NoSecrets: return QStringLiteral("Secrets were required but not provided");
+	case WifiClientDisconnected: return QStringLiteral("Wi-Fi supplicant disconnected");
+	case WifiClientFailed: return QStringLiteral("Wi-Fi supplicant failed");
+	case WifiAuthTimeout: return QStringLiteral("Wi-Fi connection took too long to authenticate");
+	case WifiNetworkLost: return QStringLiteral("Wi-Fi network could not be found");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+QString DeviceType::toString(DeviceType::Enum type) {
+	switch (type) {
+	case None: return QStringLiteral("None");
+	case Wifi: return QStringLiteral("Wifi");
+	case Wired: return QStringLiteral("Wired");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+QString WifiSecurityType::toString(WifiSecurityType::Enum type) {
+	switch (type) {
+	case Unknown: return QStringLiteral("Unknown");
+	case Wpa3SuiteB192: return QStringLiteral("WPA3 Suite B 192-bit");
+	case Sae: return QStringLiteral("WPA3");
+	case Wpa2Eap: return QStringLiteral("WPA2 Enterprise");
+	case Wpa2Psk: return QStringLiteral("WPA2");
+	case WpaEap: return QStringLiteral("WPA Enterprise");
+	case WpaPsk: return QStringLiteral("WPA");
+	case StaticWep: return QStringLiteral("WEP");
+	case DynamicWep: return QStringLiteral("Dynamic WEP");
+	case Leap: return QStringLiteral("LEAP");
+	case Owe: return QStringLiteral("OWE");
+	case Open: return QStringLiteral("Open");
+	default: return QStringLiteral("Unknown");
+	}
+}
+
+QString WifiDeviceMode::toString(WifiDeviceMode::Enum mode) {
+	switch (mode) {
+	case Unknown: return QStringLiteral("Unknown");
+	case AdHoc: return QStringLiteral("Ad-Hoc");
+	case Station: return QStringLiteral("Station");
+	case AccessPoint: return QStringLiteral("Access Point");
+	case Mesh: return QStringLiteral("Mesh");
+	default: return QStringLiteral("Unknown");
+	};
+}
+
+} // namespace qs::network
@@ -0,0 +1,155 @@
+#pragma once
+
+#include <qobject.h>
+#include <qqmlintegration.h>
+#include <qtypes.h>
+
+namespace qs::network {
+
+///! The degree to which the host can reach the internet.
+class NetworkConnectivity: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		/// Network connectivity is unknown. This means the connectivity checks are disabled or have not run yet.
+		Unknown = 0,
+		/// The host is not connected to any network.
+		None = 1,
+		/// The internet connection is hijacked by a captive portal gateway.
+		/// This indicates the shell should open a sandboxed web browser window for the purpose of authenticating to a gateway.
+		Portal = 2,
+		/// The host is connected to a network but does not appear to be able to reach the full internet.
+		Limited = 3,
+		/// The host is connected to a network and appears to be able to reach the full internet.
+		Full = 4,
+	};
+	Q_ENUM(Enum);
+	Q_INVOKABLE static QString toString(NetworkConnectivity::Enum conn);
+};
+
+///! The backend supplying the Network service.
+class NetworkBackendType: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		None = 0,
+		NetworkManager = 1,
+	};
+	Q_ENUM(Enum);
+	Q_INVOKABLE static QString toString(NetworkBackendType::Enum type);
+};
+
+///! The connection state of a device or network.
+class ConnectionState: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		Unknown = 0,
+		Connecting = 1,
+		Connected = 2,
+		Disconnecting = 3,
+		Disconnected = 4,
+	};
+	Q_ENUM(Enum);
+	Q_INVOKABLE static QString toString(ConnectionState::Enum state);
+};
+
+///! The reason a connection failed.
+class ConnectionFailReason: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		/// The connection failed for an unknown reason.
+		Unknown = 0,
+		/// Secrets were required, but not provided.
+		NoSecrets = 1,
+		/// The Wi-Fi supplicant disconnected.
+		WifiClientDisconnected = 2,
+		/// The Wi-Fi supplicant failed.
+		WifiClientFailed = 3,
+		/// The Wi-Fi connection took too long to authenticate.
+		WifiAuthTimeout = 4,
+		/// The Wi-Fi network could not be found.
+		WifiNetworkLost = 5,
+	};
+	Q_ENUM(Enum);
+	Q_INVOKABLE static QString toString(ConnectionFailReason::Enum reason);
+};
+
+///! Type of a @@NetworkDevice.
+class DeviceType: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		None = 0,
+		Wifi = 1,
+		Wired = 2,
+	};
+	Q_ENUM(Enum);
+	Q_INVOKABLE static QString toString(DeviceType::Enum type);
+};
+
+///! The security type of a @@WifiNetwork.
+class WifiSecurityType: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		Wpa3SuiteB192 = 0,
+		Sae = 1,
+		Wpa2Eap = 2,
+		Wpa2Psk = 3,
+		WpaEap = 4,
+		WpaPsk = 5,
+		StaticWep = 6,
+		DynamicWep = 7,
+		Leap = 8,
+		Owe = 9,
+		Open = 10,
+		Unknown = 11,
+	};
+	Q_ENUM(Enum);
+	Q_INVOKABLE static QString toString(WifiSecurityType::Enum type);
+};
+
+///! The 802.11 mode of a @@WifiDevice.
+class WifiDeviceMode: public QObject {
+	Q_OBJECT;
+	QML_ELEMENT;
+	QML_SINGLETON;
+
+public:
+	enum Enum : quint8 {
+		/// The device is part of an Ad-Hoc network without a central access point.
+		AdHoc = 0,
+		/// The device is a station that can connect to networks.
+		Station = 1,
+		/// The device is a local hotspot/access point.
+		AccessPoint = 2,
+		/// The device is an 802.11s mesh point.
+		Mesh = 3,
+		/// The device mode is unknown.
+		Unknown = 4,
+	};
+	Q_ENUM(Enum);
+	Q_INVOKABLE static QString toString(WifiDeviceMode::Enum mode);
+};
+
+} // namespace qs::network
@@ -1,9 +1,13 @@
 name = "Quickshell.Networking"
 description = "Network API"
 headers = [
+	"qml.hpp",
 	"network.hpp",
 	"device.hpp",
 	"wifi.hpp",
+	"wired.hpp",
+	"enums.hpp",
+	"nm/settings.hpp",
 ]
 -----
 This module exposes Network management APIs provided by a supported network backend.
@@ -1,15 +1,15 @@
 #include "network.hpp"
 #include <utility>

+#include <qdebug.h>
 #include <qlogging.h>
 #include <qloggingcategory.h>
 #include <qobject.h>
 #include <qstring.h>
-#include <qtmetamacros.h>

 #include "../core/logcat.hpp"
-#include "device.hpp"
-#include "nm/backend.hpp"
+#include "enums.hpp"
+#include "nm/settings.hpp"

 namespace qs::network {

@@ -17,49 +17,54 @@ namespace {
 QS_LOGGING_CATEGORY(logNetwork, "quickshell.network", QtWarningMsg);
 } // namespace

-QString NetworkState::toString(NetworkState::Enum state) {
-	switch (state) {
-	case NetworkState::Connecting: return QStringLiteral("Connecting");
-	case NetworkState::Connected: return QStringLiteral("Connected");
-	case NetworkState::Disconnecting: return QStringLiteral("Disconnecting");
-	case NetworkState::Disconnected: return QStringLiteral("Disconnected");
-	default: return QStringLiteral("Unknown");
-	}
-}
-
-Networking::Networking(QObject* parent): QObject(parent) {
-	// Try to create the NetworkManager backend and bind to it.
-	auto* nm = new NetworkManager(this);
-	if (nm->isAvailable()) {
-		QObject::connect(nm, &NetworkManager::deviceAdded, this, &Networking::deviceAdded);
-		QObject::connect(nm, &NetworkManager::deviceRemoved, this, &Networking::deviceRemoved);
-		QObject::connect(this, &Networking::requestSetWifiEnabled, nm, &NetworkManager::setWifiEnabled);
-		this->bindableWifiEnabled().setBinding([nm]() { return nm->wifiEnabled(); });
-		this->bindableWifiHardwareEnabled().setBinding([nm]() { return nm->wifiHardwareEnabled(); });
-
-		this->mBackend = nm;
-		this->mBackendType = NetworkBackendType::NetworkManager;
-		return;
-	} else {
-		delete nm;
-	}
-
-	qCCritical(logNetwork) << "Network will not work. Could not find an available backend.";
-}
-
-void Networking::deviceAdded(NetworkDevice* dev) { this->mDevices.insertObject(dev); }
-void Networking::deviceRemoved(NetworkDevice* dev) { this->mDevices.removeObject(dev); }
-
-void Networking::setWifiEnabled(bool enabled) {
-	if (this->bWifiEnabled == enabled) return;
-	emit this->requestSetWifiEnabled(enabled);
-}
-
-Network::Network(QString name, QObject* parent): QObject(parent), mName(std::move(name)) {
+Network::Network(QString name, NetworkDevice* device, QObject* parent)
+    : QObject(parent)
+    , bName(std::move(name))
+    , mDevice(device) {
 	this->bStateChanging.setBinding([this] {
 		auto state = this->bState.value();
-		return state == NetworkState::Connecting || state == NetworkState::Disconnecting;
+		return state == ConnectionState::Connecting || state == ConnectionState::Disconnecting;
 	});
 };

+void Network::connect() {
+	if (this->bConnected) {
+		qCCritical(logNetwork) << this << "is already connected.";
+		return;
+	}
+	this->requestConnect();
+}
+
+void Network::connectWithSettings(NMSettings* settings) {
+	if (this->bConnected) {
+		qCCritical(logNetwork) << this << "is already connected.";
+		return;
+	}
+	if (this->bNmSettings.value().indexOf(settings) == -1) return;
+	this->requestConnectWithSettings(settings);
+}
+
+void Network::disconnect() {
+	if (!this->bConnected) {
+		qCCritical(logNetwork) << this << "is not currently connected";
+		return;
+	}
+	this->requestDisconnect();
+}
+
+void Network::forget() { this->requestForget(); }
+
+void Network::settingsAdded(NMSettings* settings) {
+	auto list = this->bNmSettings.value();
+	if (list.contains(settings)) return;
+	list.append(settings);
+	this->bNmSettings = list;
+}
+
+void Network::settingsRemoved(NMSettings* settings) {
+	auto list = this->bNmSettings.value();
+	list.removeOne(settings);
+	this->bNmSettings = list;
+}
+
 } // namespace qs::network
@@ -6,137 +6,102 @@
 #include <qtmetamacros.h>
 #include <qtypes.h>

-#include "../core/model.hpp"
-#include "device.hpp"
+#include "../core/doc.hpp"
+#include "enums.hpp"
+#include "nm/settings.hpp"
+
+namespace qs::network {
+class NetworkDevice;
+}

 namespace qs::network {

-///! The connection state of a Network.
-class NetworkState: public QObject {
-	Q_OBJECT;
-	QML_ELEMENT;
-	QML_SINGLETON;
-
-public:
-	enum Enum : quint8 {
-		Unknown = 0,
-		Connecting = 1,
-		Connected = 2,
-		Disconnecting = 3,
-		Disconnected = 4,
-	};
-	Q_ENUM(Enum);
-	Q_INVOKABLE static QString toString(NetworkState::Enum state);
-};
-
-///! The backend supplying the Network service.
-class NetworkBackendType: public QObject {
-	Q_OBJECT;
-	QML_ELEMENT;
-	QML_SINGLETON;
-
-public:
-	enum Enum : quint8 {
-		None = 0,
-		NetworkManager = 1,
-	};
-	Q_ENUM(Enum);
-};
-
-class NetworkBackend: public QObject {
-	Q_OBJECT;
-
-public:
-	[[nodiscard]] virtual bool isAvailable() const = 0;
-
-protected:
-	explicit NetworkBackend(QObject* parent = nullptr): QObject(parent) {};
-};
-
-///! The Network service.
-/// An interface to a network backend (currently only NetworkManager),
-/// which can be used to view, configure, and connect to various networks.
-class Networking: public QObject {
-	Q_OBJECT;
-	QML_SINGLETON;
-	QML_ELEMENT;
-	// clang-format off
-	/// A list of all network devices.
-	QSDOC_TYPE_OVERRIDE(ObjectModel<qs::network::NetworkDevice>*);
-	Q_PROPERTY(UntypedObjectModel* devices READ devices CONSTANT);
-	/// The backend being used to power the Network service.
-	Q_PROPERTY(qs::network::NetworkBackendType::Enum backend READ backend CONSTANT);
-	/// Switch for the rfkill software block of all wireless devices.
-	Q_PROPERTY(bool wifiEnabled READ wifiEnabled WRITE setWifiEnabled NOTIFY wifiEnabledChanged);
-	/// State of the rfkill hardware block of all wireless devices.
-	Q_PROPERTY(bool wifiHardwareEnabled READ default NOTIFY wifiHardwareEnabledChanged BINDABLE bindableWifiHardwareEnabled);
-	// clang-format on
-
-public:
-	explicit Networking(QObject* parent = nullptr);
-
-	[[nodiscard]] ObjectModel<NetworkDevice>* devices() { return &this->mDevices; };
-	[[nodiscard]] NetworkBackendType::Enum backend() const { return this->mBackendType; };
-	QBindable<bool> bindableWifiEnabled() { return &this->bWifiEnabled; };
-	[[nodiscard]] bool wifiEnabled() const { return this->bWifiEnabled; };
-	void setWifiEnabled(bool enabled);
-	QBindable<bool> bindableWifiHardwareEnabled() { return &this->bWifiHardwareEnabled; };
-
-signals:
-	void requestSetWifiEnabled(bool enabled);
-	void wifiEnabledChanged();
-	void wifiHardwareEnabledChanged();
-
-private slots:
-	void deviceAdded(NetworkDevice* dev);
-	void deviceRemoved(NetworkDevice* dev);
-
-private:
-	ObjectModel<NetworkDevice> mDevices {this};
-	NetworkBackend* mBackend = nullptr;
-	NetworkBackendType::Enum mBackendType = NetworkBackendType::None;
-	// clang-format off
-	Q_OBJECT_BINDABLE_PROPERTY(Networking, bool, bWifiEnabled, &Networking::wifiEnabledChanged);
-	Q_OBJECT_BINDABLE_PROPERTY(Networking, bool, bWifiHardwareEnabled, &Networking::wifiHardwareEnabledChanged);
-	// clang-format on
-};
-
 ///! A network.
+/// A network. Networks derived from a @@WifiDevice are @@WifiNetwork instances.
 class Network: public QObject {
 	Q_OBJECT;
 	QML_ELEMENT;
-	QML_UNCREATABLE("BaseNetwork can only be aqcuired through network devices");
+	QML_UNCREATABLE("Network can only be aqcuired through networking devices");

 	// clang-format off
 	/// The name of the network.
-	Q_PROPERTY(QString name READ name CONSTANT);
+	Q_PROPERTY(QString name READ default NOTIFY nameChanged BINDABLE bindableName);
+	/// The device this network belongs to.
+	Q_PROPERTY(NetworkDevice* device READ device CONSTANT);
+	/// A list of NetworkManager connection settings profiles for this network.
+	///
+	/// > [!WARNING] Only valid for the NetworkManager backend. 
+	Q_PROPERTY(QList<NMSettings*> nmSettings READ default NOTIFY nmSettingsChanged BINDABLE bindableNmSettings);
 	/// True if the network is connected.
 	Q_PROPERTY(bool connected READ default NOTIFY connectedChanged BINDABLE bindableConnected);
+	/// True if the wifi network has known connection settings saved.
+	Q_PROPERTY(bool known READ default NOTIFY knownChanged BINDABLE bindableKnown);
 	/// The connectivity state of the network.
-	Q_PROPERTY(NetworkState::Enum state READ default NOTIFY stateChanged BINDABLE bindableState);
+	Q_PROPERTY(ConnectionState::Enum state READ default NOTIFY stateChanged BINDABLE bindableState);
 	/// If the network is currently connecting or disconnecting. Shorthand for checking @@state.
 	Q_PROPERTY(bool stateChanging READ default NOTIFY stateChangingChanged BINDABLE bindableStateChanging);
 	// clang-format on

 public:
-	explicit Network(QString name, QObject* parent = nullptr);
+	explicit Network(QString name, NetworkDevice* device, QObject* parent = nullptr);
+	/// Attempt to connect to the network.
+	///
+	/// > [!NOTE] If the network is a @@WifiNetwork and requires secrets, a @@connectionFailed(s)
+	/// > signal will be emitted with `NoSecrets`.
+	/// > @@WifiNetwork.connectWithPsk() can be used to provide secrets.
+	Q_INVOKABLE void connect();
+	/// Attempt to connect to the network with a specific @@nmSettings entry.
+	///
+	/// > [!WARNING] Only valid for the NetworkManager backend.
+	Q_INVOKABLE void connectWithSettings(NMSettings* settings);
+	/// Disconnect from the network.
+	Q_INVOKABLE void disconnect();
+	/// Forget all connection settings for this network.
+	Q_INVOKABLE void forget();

-	[[nodiscard]] QString name() const { return this->mName; };
+	void settingsAdded(NMSettings* settings);
+	void settingsRemoved(NMSettings* settings);
+
+	// clang-format off
+	[[nodiscard]] QString name() const { return this->bName; }
+	[[nodiscard]] QBindable<QString> bindableName() { return &this->bName; }
+	[[nodiscard]] NetworkDevice* device() const { return this->mDevice; }
+ 	[[nodiscard]] const QList<NMSettings*>& nmSettings() const { return this->bNmSettings; }
+	QBindable<QList<NMSettings*>> bindableNmSettings() const { return &this->bNmSettings; }
 	QBindable<bool> bindableConnected() { return &this->bConnected; }
-	QBindable<NetworkState::Enum> bindableState() { return &this->bState; }
+	QBindable<bool> bindableKnown() { return &this->bKnown; }
+	[[nodiscard]] ConnectionState::Enum state() const { return this->bState; }
+	QBindable<ConnectionState::Enum> bindableState() { return &this->bState; }
 	QBindable<bool> bindableStateChanging() { return &this->bStateChanging; }
+	// clang-format on

 signals:
+	/// Signals that a connection to the network has failed because of the given @@ConnectionFailReason.
+	void connectionFailed(ConnectionFailReason::Enum reason);
+
+	void nameChanged();
 	void connectedChanged();
+	void knownChanged();
 	void stateChanged();
 	void stateChangingChanged();
+	void nmSettingsChanged();
+	QSDOC_HIDE void requestConnect();
+	QSDOC_HIDE void requestConnectWithSettings(NMSettings* settings);
+	QSDOC_HIDE void requestDisconnect();
+	QSDOC_HIDE void requestForget();

 protected:
-	QString mName;
-
+	// clang-format off
+	Q_OBJECT_BINDABLE_PROPERTY(Network, QString, bName, &Network::nameChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(Network, bool, bConnected, &Network::connectedChanged);
-	Q_OBJECT_BINDABLE_PROPERTY(Network, NetworkState::Enum, bState, &Network::stateChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Network, bool, bKnown, &Network::knownChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Network, ConnectionState::Enum, bState, &Network::stateChanged);
 	Q_OBJECT_BINDABLE_PROPERTY(Network, bool, bStateChanging, &Network::stateChangingChanged);
+	Q_OBJECT_BINDABLE_PROPERTY(Network, QList<NMSettings*>, bNmSettings, &Network::nmSettingsChanged);
+	// clang-format on
+
+private:
+	NetworkDevice* mDevice;
 };

 } // namespace qs::network
@@ -29,6 +29,16 @@ qt_add_dbus_interface(NM_DBUS_INTERFACES
 	dbus_nm_wireless
 )

+set_source_files_properties(org.freedesktop.NetworkManager.Device.Wired.xml PROPERTIES
+	CLASSNAME DBusNMWiredProxy
+	NO_NAMESPACE TRUE
+)
+
+qt_add_dbus_interface(NM_DBUS_INTERFACES
+	org.freedesktop.NetworkManager.Device.Wired.xml
+	dbus_nm_wired
+)
+
 set_source_files_properties(org.freedesktop.NetworkManager.AccessPoint.xml PROPERTIES
 	CLASSNAME DBusNMAccessPointProxy
 	NO_NAMESPACE TRUE
@@ -63,10 +73,14 @@ qt_add_dbus_interface(NM_DBUS_INTERFACES
 qt_add_library(quickshell-network-nm STATIC
 	backend.cpp
 	device.cpp
-	connection.cpp
+	active_connection.cpp
+	settings.cpp
 	accesspoint.cpp
 	wireless.cpp
+	wired.cpp
 	utils.cpp
+	dbus_types.cpp
+	network.cpp
 	enums.hpp
 	${NM_DBUS_INTERFACES}
 )
@@ -77,3 +91,4 @@ target_include_directories(quickshell-network-nm PUBLIC

 target_link_libraries(quickshell-network-nm PRIVATE Qt::Qml Qt::DBus)
 qs_add_link_dependencies(quickshell-network-nm quickshell-dbus)
+qs_add_link_dependencies(quickshell-network-nm quickshell-network)
@@ -7,7 +7,7 @@
 #include <qtypes.h>

 #include "../../dbus/properties.hpp"
-#include "../wifi.hpp"
+#include "../enums.hpp"
 #include "dbus_nm_accesspoint.h"
 #include "enums.hpp"

@@ -48,14 +48,14 @@ public:
 	[[nodiscard]] bool isValid() const;
 	[[nodiscard]] QString path() const;
 	[[nodiscard]] QString address() const;
-	[[nodiscard]] QByteArray ssid() const { return this->bSsid; };
-	[[nodiscard]] quint8 signalStrength() const { return this->bSignalStrength; };
-	[[nodiscard]] NM80211ApFlags::Enum flags() const { return this->bFlags; };
-	[[nodiscard]] NM80211ApSecurityFlags::Enum wpaFlags() const { return this->bWpaFlags; };
-	[[nodiscard]] NM80211ApSecurityFlags::Enum rsnFlags() const { return this->bRsnFlags; };
-	[[nodiscard]] NM80211Mode::Enum mode() const { return this->bMode; };
-	[[nodiscard]] QBindable<WifiSecurityType::Enum> bindableSecurity() { return &this->bSecurity; };
-	[[nodiscard]] WifiSecurityType::Enum security() const { return this->bSecurity; };
+	[[nodiscard]] QByteArray ssid() const { return this->bSsid; }
+	[[nodiscard]] quint8 signalStrength() const { return this->bSignalStrength; }
+	[[nodiscard]] NM80211ApFlags::Enum flags() const { return this->bFlags; }
+	[[nodiscard]] NM80211ApSecurityFlags::Enum wpaFlags() const { return this->bWpaFlags; }
+	[[nodiscard]] NM80211ApSecurityFlags::Enum rsnFlags() const { return this->bRsnFlags; }
+	[[nodiscard]] NM80211Mode::Enum mode() const { return this->bMode; }
+	[[nodiscard]] QBindable<WifiSecurityType::Enum> bindableSecurity() { return &this->bSecurity; }
+	[[nodiscard]] WifiSecurityType::Enum security() const { return this->bSecurity; }

 signals:
 	void loaded();
@@ -0,0 +1,68 @@
+#include "active_connection.hpp"
+
+#include <qcontainerfwd.h>
+#include <qdbusconnection.h>
+#include <qdbuspendingcall.h>
+#include <qlogging.h>
+#include <qloggingcategory.h>
+#include <qnamespace.h>
+#include <qobject.h>
+#include <qstring.h>
+#include <qtypes.h>
+
+#include "../../core/logcat.hpp"
+#include "../../dbus/properties.hpp"
+#include "dbus_nm_active_connection.h"
+#include "enums.hpp"
+
+namespace qs::network {
+using namespace qs::dbus;
+
+namespace {
+QS_LOGGING_CATEGORY(logNetworkManager, "quickshell.network.networkmanager", QtWarningMsg);
+}
+
+NMActiveConnection::NMActiveConnection(const QString& path, QObject* parent): QObject(parent) {
+	this->proxy = new DBusNMActiveConnectionProxy(
+	    "org.freedesktop.NetworkManager",
+	    path,
+	    QDBusConnection::systemBus(),
+	    this
+	);
+
+	if (!this->proxy->isValid()) {
+		qCWarning(logNetworkManager) << "Cannot create DBus interface for connection at" << path;
+		return;
+	}
+
+	// clang-format off
+	QObject::connect(&this->activeConnectionProperties, &DBusPropertyGroup::getAllFinished, this, &NMActiveConnection::loaded, Qt::SingleShotConnection);
+	QObject::connect(this->proxy, &DBusNMActiveConnectionProxy::StateChanged, this, &NMActiveConnection::onStateChanged);
+	// clang-format on
+
+	this->activeConnectionProperties.setInterface(this->proxy);
+	this->activeConnectionProperties.updateAllViaGetAll();
+}
+
+void NMActiveConnection::onStateChanged(quint32 /*state*/, quint32 reason) {
+	auto enumReason = static_cast<NMConnectionStateReason::Enum>(reason);
+	if (this->bStateReason == enumReason) return;
+	this->bStateReason = enumReason;
+}
+
+bool NMActiveConnection::isValid() const { return this->proxy && this->proxy->isValid(); }
+QString NMActiveConnection::address() const {
+	return this->proxy ? this->proxy->service() : QString();
+}
+QString NMActiveConnection::path() const { return this->proxy ? this->proxy->path() : QString(); }
+
+} // namespace qs::network
+
+namespace qs::dbus {
+
+DBusResult<qs::network::NMConnectionState::Enum>
+DBusDataTransform<qs::network::NMConnectionState::Enum>::fromWire(quint32 wire) {
+	return DBusResult(static_cast<qs::network::NMConnectionState::Enum>(wire));
+}
+
+} // namespace qs::dbus
Author	SHA1	Message	Date
outfoxxed	4f508be500	version: 0.3.2	2026-10-08 01:42:54 -07:00
outfoxxed	11ca60be22	docs: add PR template and clarify AI usage in pr descriptions	2026-10-05 21:20:58 -07:00
Carson Powers	8fd0e25844	networking: prefer AP security	2026-10-05 11:03:58 -07:00
Cloud0310	5d5d49873f	all: use MOC includes instead of opaque pointer defiinitions Fixes linking issues and Qt 6.12 compatibility.	2026-10-03 04:43:26 -07:00
ayandexyz	41651d7dcd	io/socket: discard sockets which have failed to connect Fixes future connection attempts.	2026-09-25 06:40:25 -07:00
bbedward	4594680eb4	core/generation: destroy the engine after the root's children	2026-09-25 00:15:27 -07:00
faithleysath	25da30db02	pipewire: write route volumes without volume step	2026-09-25 00:11:17 -07:00
outfoxxed	fae96f1a5b	hyprland/ipc: support workspace addresses	2026-09-20 22:04:49 -07:00
outfoxxed	c6a516096d	core/scriptmodel: avoid comparing native types as equal by fields	2026-09-15 01:37:42 -07:00
ZANX3Y	86b4275879	services/notifications: fix action text updates	2026-09-13 18:59:02 -07:00
qaqland	9b4b206961	x11/i3: build the module without requiring X11 BUILD.md documents i3/Sway as having no x11 dependency, but the module was only added from src/x11/CMakeLists.txt, so -DI3=ON -DX11=OFF silently lost Quickshell.I3.	2026-09-13 18:59:02 -07:00
outfoxxed	92cb8909eb	all: ensure deleteLater'd QObjects are disconnected	2026-09-13 18:59:00 -07:00
outfoxxed	2d3b3e9c70	core/generation: destroy generation extensions after js interruption	2026-08-29 02:11:43 -07:00
outfoxxed	ec0be5b36f	launch: initialize QuickshellTracked before almost anything else This fixes consumers like WlSessionLock getting connections to QGuiApplication::screenAdded before QuickshellTracked::updateScreens can run if the user never references the Quickshell singleton from QML first.	2026-08-28 19:27:13 -07:00
outfoxxed	fd116897cf	launch: create a QCoreApplication for non launch command paths Things that need an event loop break without this.	2026-08-28 19:21:49 -07:00
outfoxxed	916a0dd90c	launch: avoid creating multiple QApplications Accessibility hooks created by QQuick module init are destroyed by the QApplication destructor and not recreated by a new QApplication.	2026-08-28 00:48:19 -07:00
Carson Powers	0f9939ca4f	networking: add NetworkManager service watcher	2026-08-25 23:36:53 -07:00
Carson Powers	052059fb7c	networking: handle omitted mode setting in NM	2026-08-25 23:14:48 -07:00
outfoxxed	39e14d3627	service/tray: support /NO_DBUSMENU as a marker for absence of a menu I couldn't find any documentation for this, but it was requested and KDE also does it.	2026-08-25 23:03:30 -07:00
outfoxxed	9f59d0a05d	wayland/lock: add warning on live session lock destruction	2026-08-25 17:22:27 -07:00
outfoxxed	afb2c27cd6	wayland/lock: guard against reentrancy during surface creation	2026-08-25 02:14:21 -07:00
outfoxxed	0fed22a2c4	service/pam: fix free of wrong pointer in pam subprocess messaging	2026-08-22 16:08:41 -07:00
outfoxxed	1a4716cde7	version: 0.3.1	2026-08-20 19:28:55 -07:00
outfoxxed	069e33a93e	core/scriptmodel: structurally compare model entries Comparisons regressed to being identity based when the values list was changed from being a `QList<QVariant>` to `QList<QJSValue>`.	2026-08-20 19:08:57 -07:00
outfoxxed	532a0606ca	core/scriptmodel: handle reentrancy in ScriptModel::setValues	2026-08-16 00:22:04 -07:00
outfoxxed	78672a8405	x11/panelwindow: avoid using destroyed panel stack after free	2026-08-15 20:53:19 -07:00
outfoxxed	990a8badab	core/popupanchor: null check mItem in onItemWindowChanged Also emit itemChanged in PopupAnchor::setItem().	2026-08-15 20:53:19 -07:00
outfoxxed	7e6c7ae3fb	services/pipewire: match node and stream channels in peak sampling Also fixes potentially requeuing a null buffer	2026-08-15 20:53:19 -07:00
outfoxxed	8f1316d0c2	wayland/screencopy: fix bo double free on alloc fail in createDmabuf gbm_bo_free is already called by the WlDmaBuffer destructor	2026-08-15 20:53:19 -07:00
outfoxxed	63eb2ba6ef	core/colorquant: copy source to operations and cancel on destroy Fixes UAFing the source url in ColorQuantizerOperation if the ColorQuantizer is destroyed.	2026-08-15 20:53:18 -07:00
outfoxxed	b1fc3e0740	io/fileview: disconnect deleteLater'd file watchers immediately Without this disconnect, the watcher can send a signal whose handler references the (now null) watcher pointer before the watcher is deleted.	2026-08-15 16:04:18 -07:00
outfoxxed	21fec77de7	wayland/toplevel: null check window passed to Toplevel::setRectangle Fixes Toplevel::unsetRectangle, which passes a null.	2026-08-15 15:55:46 -07:00
outfoxxed	d9cbc90a8c	io/fileview: fix swapped new/old branch in JsonAdapter deserialize	2026-08-15 14:44:52 -07:00
outfoxxed	28771c7c74	ipc: ensure handler deregistration upon destruction Deregistration when an engine generation lookup fails has been reported as an issue but couldn't be reproduced. This is a speculative fix.	2026-08-02 13:53:41 -07:00
outfoxxed	43d4fa9e88	crash: strip crash env and avoid leaking crash info fd on launch	2026-07-26 23:37:18 -07:00
outfoxxed	10b439fc6e	launch: prevent double initialization of logger	2026-07-23 02:42:56 -07:00
outfoxxed	e649d24749	launch: don't print dead instance help logs from --no-duplicate	2026-07-20 19:22:17 -07:00
outfoxxed	025c709e94	ipc: wait for remote process to exit before returning from kill	2026-07-20 19:21:27 -07:00
outfoxxed	4df562dfb2	service/notifications: emit NotificationClosed after Notify returns	2026-07-10 01:58:38 -07:00
outfoxxed	98b6d0b7e7	io/ipchandler: stop reimplementing QVariant in ipc value slots	2026-07-10 01:26:48 -07:00
outfoxxed	25eb04fb06	tooling: use QList<QJSValue> over QJSValueList QJSValueList is not currently a defined QML type, breaking qmllint and qmlls.	2026-07-08 01:23:01 -07:00
outfoxxed	ead3b00afd	networking: fix UAFs in NMWirelessNetwork ap/setting destroy handler	2026-07-07 00:34:06 -07:00
outfoxxed	a611932352	core/scriptmodel: represent members as a QJSValueList Fixes UAFs caused by access to pointers stored either directly or contained in an object inside a ScriptModel which were freed and then accessed. These accesses could be observed by not setting `values` to a binding, access before updateValuesUnique finished, or randomly before a binding had been fully updated.	2026-07-06 23:45:42 -07:00
outfoxxed	1661ef100a	wm: recompute WindowsetProjection.screens on each usage Fixes potential UAF from destroyed screens not yet removed by a wayland commit.	2026-06-30 02:31:19 -07:00
bbedward	68c2c85c33	core/window: render a frame when re-enabling updatesEnabled	2026-06-18 22:43:11 -07:00
luke	897fcdaa99	wayland/lock: avoid creating lock surfaces for uninited wl screens	2026-06-17 22:59:12 -07:00
outfoxxed	d99d87d5e5	crash: remove logs from crash template	2026-06-09 18:04:48 -07:00
outfoxxed	b66495fcc5	all: add/fix property change signals on various properties - FileView.atomicWrites notified on blockWrites - StatusNotifierItem.onlyMenu missing notification - MarginWrapper.extraMargin missing notification - MarginWrapper.resizeChild missing notification - PopupWindow.grabFocus missing notification	2026-06-01 01:48:57 -07:00
outfoxxed	eaba6c8b62	services/mpris: fix minRate and maxRate returning rate	2026-06-01 01:37:19 -07:00
outfoxxed	4b4fca3224	docs: document private ABI usage	2026-05-21 23:14:12 -07:00
outfoxxed	7d1c9a9c67	wayland/toplevel: reorganize toplevel management	2026-05-11 01:38:16 -07:00
Aditya Alok	d1760ed1f3	wayland/lock: add window null check in surface isVisible	2026-05-07 23:40:27 -07:00
outfoxxed	b93d61385f	wayland/lock: run scenegraph callbacks for lock surfaces Fixes ScreencopyView never initializing if only using lock surfaces.	2026-05-07 03:08:57 -07:00
outfoxxed	59e9c47b0e	version: 0.3.0	2026-05-03 22:09:49 -07:00
outfoxxed	ffe95f06ac	guix: drop Hard to keep the package up to date without an active maintainer.	2026-05-03 18:50:15 -07:00
outfoxxed	8db8ca1fec	core/log: mask virtual/override property warnings	2026-05-02 00:15:59 -07:00
outfoxxed	0baa81aa03	all: fix typos	2026-04-27 18:56:41 -07:00
outfoxxed	01834e9c8f	hyprland/ipc: add lua ipc support	2026-04-27 18:56:39 -07:00
outfoxxed	2ba2ae48b4	core: add qt version check in preprocessor	2026-04-27 02:18:32 -07:00
Jörg Thalheim	055e384668	core/model: make diffUpdate handle reordering without duplicating rows diffUpdate inserted an element at its target index without removing it from its previous index, so a pure permutation like [d,a,b,c] -> [a,b,c,d] left every misplaced element in the model twice and the removal pass never reclaimed them because their pointer is still in newValues. Any caller that re-sorts an existing list (dbusmenu re-layout, desktopentry re-scan) can hit this. Found via a downstream niri workspace backend where a monitor hot-plug re-sorts the model.	2026-04-26 12:59:02 +02:00
outfoxxed	11a71d233a	dbus/dbusmenu: connect onItemPropertiesUpdated Evidently this was broken at some point or never connected.	2026-04-24 21:01:49 -07:00
outfoxxed	e162429b6f	wayland/toplevel: track global screen removals Screen removal events aren't necessarily emitted at a protocol level when a screen is removed globally. This would have caused UAFs if the pointer was ever dereferenced, but in practice it was only compared against.	2026-04-24 01:30:59 -07:00
outfoxxed	783c953987	services/pipewire: assume default channels in channelMap if unset Pw-pulse seems to have stopped sending these at some point. This copies the logic that pipewire's tools use to decide the default channels.	2026-04-22 03:34:08 -07:00
outfoxxed	b850b8a1a9	core: add DefaultEnv pragma	2026-04-22 01:12:10 -07:00
Carson Powers	d60498adc0	networking: add wired device support	2026-04-21 01:48:20 -07:00
outfoxxed	9a54119893	core/command: warn on mismatch when other displays have instances	2026-04-19 02:01:41 -07:00
outfoxxed	18075d1218	core/command: ignore QT_QPA_PLATFORM in display check	2026-04-19 02:01:19 -07:00
outfoxxed	fb08eced44	wayland/screencopy: intersect dmabuf and render formats + cleanup Fixes 99% of MGPU cases.	2026-04-13 00:41:08 -07:00
outfoxxed	d4c92973b5	i3/ipc: ensure monitor/workspace pointers are nulled on destroy	2026-04-09 00:34:57 -07:00
outfoxxed	7f7ab6bc8a	launch: use dup2 to reset daemon stdio over close+open	2026-04-09 00:10:49 -07:00
outfoxxed	7208f68bb7	core: add QS_DROP_EXPENSIVE_FONTS env var	2026-04-08 01:35:15 -07:00
outfoxxed	f0d0216b3d	core: add DropExpensiveFonts pragma disabling woff and woff2 fonts	2026-04-08 00:48:58 -07:00
outfoxxed	7c5a6c4bd4	core/log: crash if Quickshell's log filter is installed twice Crashes from recursion inside filterCategories through the old filter have been observed. Presumably this means the log filter is getting installed twice somehow. This should catch it.	2026-04-06 00:45:26 -07:00
outfoxxed	5bf6a412b0	core: correctly construct runtime path when XDG_RUNTIME_DIR missing Fixes a typo of % as $, which broke string substitution.	2026-04-06 00:43:02 -07:00
outfoxxed	13fe9b0d98	services/pipewire: avoid blanket disconnect for default nodes The same nodes can be both default and default configured nodes. When the default and default configured node are not changed in unison, a blanket disconnect will also disconnect the other's destroy handler, causing a crash if the other is accessed after the node is destroyed.	2026-04-06 00:42:29 -07:00
outfoxxed	ad5fd9116e	wm: add nullptr guard to WindowManager::screenProjection	2026-04-04 13:51:32 -07:00
outfoxxed	49d4f46cf1	io/fileview: handle deserialization to list<T> properties	2026-04-04 13:05:33 -07:00
outfoxxed	9b98d10178	io/fileview: try to convert values to json before handling sequences The previous code was interpreting a string as a list of characters and therefore a sequence.	2026-04-04 12:28:40 -07:00
outfoxxed	854088c48c	io/fileview: convert containers to QVariantList/Map before serialize QJsonValue::fromVariant doesn't do this automatically for some reason.	2026-04-04 02:06:22 -07:00
bbedward	b4e71cb2c0	core/window: add parentWindow property to FloatingWindow	2026-04-03 21:36:18 -07:00
outfoxxed	ceac3c6cfa	io/fileview: use QVariant when QJSValue cast fails in adapter prop read A QVariant(QVariantMap) does not convert implicitly to a QVaraint(QJSValue), causing extra signals to be emitted if the old value was not updated by js (replaced by a QJSValue) before deserializing again.	2026-04-03 21:36:02 -07:00
outfoxxed	aaff22f4b0	io/fileview: write values into correct JsonObjects in deserialize Property writes were being done on the JsonAdapter and not the child JsonObject, resulting in the data of children being set on the adapter's props, and occasional crashes.	2026-04-03 21:35:11 -07:00
HigherOrderLogic	50cdf98868	core/colorquant: add imageRect option for cropping image	2026-04-03 00:30:27 -07:00
outfoxxed	4b751ccb0d	wayland/screencopy: use linear texture filtering over nearest Fixes pixelated views at scaled resolutions.	2026-04-03 00:03:27 -07:00
Carson Powers	20c691cdf1	networking: add PSK, settings and connection status support	2026-04-02 20:26:08 -07:00
outfoxxed	92b336c80c	tooling: ensure intercepts do not overwrite symlinks to cfg files Intercept-file writes could end up opening an existing vfs symlink back to the user's actual config instead of creating a new file in the vfs.	2026-04-02 03:25:42 -07:00
2 * r + 2 * t	d612227740	core/qmlglobal: add shellId, instanceId, appId and launchTime props	2026-03-31 02:49:24 -07:00
outfoxxed	b83c39c8af	services/pipewire: add -fno-strict-overflow to fix PCH with pipewire Unclear how this should be handled long term.	2026-03-30 21:42:08 -07:00
Mia Herkt	ee1100eb98	wayland/buffer: drop unused GLESv3 include That one is often in a separate Mesa package and contrary to GLESv2 doesn’t come with a pkg-config file. Mildly annoying…	2026-03-29 09:31:28 +02:00
outfoxxed	9bf752ac33	crash: add std::terminate handler	2026-03-28 23:07:37 -07:00
outfoxxed	313f4e47f6	core: track XDG_CURRENT_DESKTOP in debuginfo	2026-03-28 20:28:03 -07:00
outfoxxed	6ef86dd5aa	crash: run platform compat hooks in crash reporter init For some reason, QtWayland crashes we work around trigger in this path. This was previously masked when the crash reporter didn't unmask signals, as long as the original process crashed with SIGSEGV.	2026-03-28 20:27:57 -07:00
outfoxxed	308f1e249b	crash: unmask signals before reexec Signals were previously left masked before reexec, causing UB if a child were to crash again, instead of triggering the reporter. This might've been responsible for a number of unexplainable bugs.	2026-03-28 20:27:48 -07:00
outfoxxed	08058326f0	core: reuse global pragma parsing js engine during scanning QJSEngine cleanup is not fast or clean and results in speed degradation over time if too many are destroyed.	2026-03-25 00:16:36 -07:00
bbedward	6a244c3c56	core/region: add per-corner radius support	2026-03-19 23:42:32 -07:00
bbedward	d745184823	wayland/background-effect: add ext-background-effect-v1 support	2026-03-19 23:39:21 -07:00
bbedward	77c04a9447	launch: add ability to override AppId via pragma or QS_APP_ID	2026-03-19 22:33:32 -07:00
Dan Aloni	eb6eaf59c7	core/log: add a mutex to protect stdoutStream QTextStream is not thread safe.	2026-03-19 03:36:12 -07:00
Mia Herkt	7511545ee2	build: add missing wayland-client CFLAGS Fixes #276	2026-03-19 03:30:11 -07:00
outfoxxed	0cb62920a7	hyprland/focus_grab: handle destruction of tracked windows	2026-03-18 02:39:22 -07:00
outfoxxed	3520c85d77	wayland: remove --require-defined linker argument Not supported by lld	2026-03-17 19:42:47 -07:00
outfoxxed	3cf65af49f	docs: ask users not to submit v1 crash reports	2026-03-17 10:10:01 -07:00
-k	a51dcd0a01	wayland: use patched surfaceRole accessor on FreeBSD	2026-03-17 00:08:25 -07:00
-k	97b2688ad6	core/log: fix non-linux typo and import unistd on freebsd	2026-03-17 00:01:34 -07:00
-k	0a859d51f2	service/pam: include `signal.h` on freebsd	2026-03-17 00:01:24 -07:00
outfoxxed	1bd5b083cb	hyprland/ipc: add null checks and ws preinit to toplevel object init Previously HyprlandToplevel::updateFromObject did not call findWorkspaceByName with createIfMissing=true, leaving bWorkspace null for a later insertToplevel call from HyprlandIpc::refreshToplevels.	2026-03-16 22:47:01 -07:00
outfoxxedandLemmy	365bf16b1e	wayland: hook wl_proxy_get_listener avoiding QTBUG-145022 crash Co-authored-by: Lemmy <[email protected]>	2026-03-16 21:42:20 -07:00
outfoxxed	6705e2da77	wm: add WindowManager module with ext-workspace support	2026-03-16 01:08:26 -07:00
outfoxxed	9e8eecf2b8	core: log qt related environment variables in debuginfo	2026-03-15 21:13:35 -07:00
outfoxxed	1b2519d9f3	core: log gpu information in debuginfo	2026-03-14 02:31:47 -07:00
outfoxxed	1123d5ab4f	core: move crash/version debug info to one place	2026-03-14 02:31:28 -07:00
outfoxxed	4b77936c80	crash: allow overriding crash reporter url	2026-03-13 02:04:01 -07:00
outfoxxed	e32b909354	core: add disable env vars for file watcher and crash handler	2026-03-13 01:10:09 -07:00
outfoxxed	178c04b59c	docs: revise contribution policy and related files	2026-03-13 00:33:36 -07:00
outfoxxed	706d6de7b0	crash: unmask signals in coredump fork Fixes the fork just sticking around and not dumping a core.	2026-03-12 04:02:24 -07:00
outfoxxed	9a9c605250	core: hash scanned files and don't trigger a reload if matching Nix builds often trip QFileSystemWatcher, causing random reloads.	2026-03-11 21:52:13 -07:00
outfoxxed	bd62179277	all: retry incomplete socket reads Fixes greetd and hyprland ipc sockets reads being incomplete and breaking said integrations on slow machines.	2026-03-10 00:54:45 -07:00
-k	cf1a2aeb2d	wayland/toplevel: clear activeToplevel on deactivation	2026-03-09 19:37:15 -07:00
outfoxxed	15a8409765	ipc: handle null currentGeneration in IpcKillCommand::exec	2026-03-07 15:19:36 -08:00
Moraxyc	6bcd3d9bbf	nix: use libxcb directly	2026-03-06 03:15:20 -08:00
outfoxxed	c030300191	core/desktopentry: preserve desktop action order	2026-03-06 01:40:02 -08:00
outfoxxed	5721955686	services/pipewire: ignore ENOENT errors Pipewire describes all errors as fatal, however these just aren't, don't seem to be squashable, and resetting for them breaks users.	2026-03-04 23:26:33 -08:00
outfoxxed	a849a88893	build: remove DISTRIBUTOR_DEBUGINFO_AVAILABLE	2026-03-03 00:40:36 -08:00
outfoxxed	cdde4c63f4	crash: switch to cpptrace from breakpad	2026-03-02 19:35:38 -08:00
Carson Powers	cddb4f061b	build: fix lint-staged to ignore deleted files	2026-02-24 01:43:02 -08:00
outfoxxed	6e17efab83	wayland/screencopy: enable vulkan dmabuf support on session locks Also reformat dmabuf	2026-02-24 00:05:20 -08:00