release 0.5.0

fresh watch style
openxr: toggle for space rotate axis lock
2026-10-28 23:03:28 +01:00 · 2024-09-19 05:29:27 +09:00 · 2024-09-19 03:09:09 +09:00 · 2024-09-18 04:06:37 +09:00 · 2024-09-16 07:05:26 +09:00 · 2024-09-16 05:09:10 +09:00
71 changed files with 9788 additions and 3379 deletions
@@ -0,0 +1,51 @@
+name: Build AppImage
+
+on:
+  push:
+    branches:
+      - 'main'
+
+env:
+  APPDIR: WlxOverlay-S.AppDir
+  CARGO_TERM_COLOR: always
+  SCCACHE_GHA_ENABLED: "true"
+  RUSTC_WRAPPER: "sccache"
+  
+jobs:
+  build_appimage:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup sccache
+        uses: mozilla-actions/sccache-action@v0.0.3
+      - name: Prepare Environment
+        run: |
+          sudo add-apt-repository -syn universe
+          sudo add-apt-repository -syn ppa:pipewire-debian/pipewire-upstream || sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 25088A0359807596
+          sudo apt-get update
+          sudo apt-get install -y fuse cmake pkg-config fontconfig libasound2-dev libxkbcommon-dev libxkbcommon-x11-0 libxkbcommon-x11-dev libopenxr-dev libfontconfig-dev libdbus-1-dev libpipewire-0.3-0 libpipewire-0.3-dev libspa-0.2-dev libx11-6 libxext6 libxrandr2 libx11-dev libxext-dev libxrandr-dev libopenvr-dev libopenvr-api1
+          rustup update
+          
+          test -f linuxdeploy-x86_64.AppImage || wget -q "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage"
+          chmod +x linuxdeploy-x86_64.AppImage
+          
+          test -d ${APPDIR} && rm -rf ${APPDIR}
+          mkdir -p ${APPDIR}/usr/bin 
+          
+      - name: Cargo Build
+        run: |
+          cargo build --release
+          mv target/release/wlx-overlay-s ${APPDIR}/usr/bin
+          chmod +x ${APPDIR}/usr/bin/wlx-overlay-s
+
+      - name: Package AppImage
+        run: |
+          export VERSION=$GITHUB_REF_NAME
+          ./linuxdeploy-x86_64.AppImage -dwlx-overlay-s.desktop -iwlx-overlay-s.png --appdir=${APPDIR} --output appimage --exclude-library '*libpipewire*'
+          mv WlxOverlay-S-$VERSION-x86_64.AppImage WlxOverlay-S-x86_64.AppImage
+
+      - name: Upload AppImage
+        uses: actions/upload-artifact@v4
+        with:
+          name: WlxOverlay-S-${{ github.ref_name }}-x86_64.AppImage
+          path: ./WlxOverlay-S-x86_64.AppImage
@@ -0,0 +1,28 @@
+name: Check Full
+
+on:
+  pull_request:
+    branches: [ "!main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+  SCCACHE_GHA_ENABLED: "true"
+  RUSTC_WRAPPER: "sccache"
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup sccache
+      uses: mozilla-actions/sccache-action@v0.0.3
+    - name: Prepare Environment
+      run: |
+        sudo add-apt-repository -syn universe
+        sudo add-apt-repository -syn ppa:pipewire-debian/pipewire-upstream || sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 25088A0359807596
+        sudo apt-get update -y
+        sudo apt-get install -y fuse cmake pkg-config fontconfig libasound2-dev libxkbcommon-dev libxkbcommon-x11-0 libxkbcommon-x11-dev libopenxr-dev libfontconfig-dev libdbus-1-dev libpipewire-0.3-0 libpipewire-0.3-dev libspa-0.2-dev libx11-6 libxext6 libxrandr2 libx11-dev libxext-dev libxrandr-dev libopenvr-dev libopenvr-api1
+    - name: Build
+      run: cargo build --verbose
+    - name: Run tests
+      run: cargo test --verbose
@@ -0,0 +1,28 @@
+name: Check Wayland+OpenVR
+
+on:
+  pull_request:
+    #branches: [ "main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+  SCCACHE_GHA_ENABLED: "true"
+  RUSTC_WRAPPER: "sccache"
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup sccache
+      uses: mozilla-actions/sccache-action@v0.0.3
+    - name: Prepare Environment
+      run: |
+        sudo add-apt-repository -syn universe
+        sudo add-apt-repository -syn ppa:pipewire-debian/pipewire-upstream || sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 25088A0359807596
+        sudo apt-get update -y
+        sudo apt-get install -y fuse cmake pkg-config fontconfig libasound2-dev libxkbcommon-dev libxkbcommon-x11-0 libxkbcommon-x11-dev libopenxr-dev libfontconfig-dev libdbus-1-dev libpipewire-0.3-0 libpipewire-0.3-dev libspa-0.2-dev libx11-6 libxext6 libxrandr2 libx11-dev libxext-dev libxrandr-dev libopenvr-dev libopenvr-api1
+    - name: Build
+      run: cargo build --verbose --no-default-features --features=wayland,openvr
+    - name: Run tests
+      run: cargo test --verbose --no-default-features --features=wayland,openvr
@@ -0,0 +1,28 @@
+name: Check Wayland+OpenXR
+
+on:
+  pull_request:
+    #branches: [ "main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+  SCCACHE_GHA_ENABLED: "true"
+  RUSTC_WRAPPER: "sccache"
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup sccache
+      uses: mozilla-actions/sccache-action@v0.0.3
+    - name: Prepare Environment
+      run: |
+        sudo add-apt-repository -syn universe
+        sudo add-apt-repository -syn ppa:pipewire-debian/pipewire-upstream || sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 25088A0359807596
+        sudo apt-get update -y
+        sudo apt-get install -y fuse cmake pkg-config fontconfig libasound2-dev libxkbcommon-dev libxkbcommon-x11-0 libxkbcommon-x11-dev libopenxr-dev libfontconfig-dev libdbus-1-dev libpipewire-0.3-0 libpipewire-0.3-dev libspa-0.2-dev libx11-6 libxext6 libxrandr2 libx11-dev libxext-dev libxrandr-dev libopenvr-dev libopenvr-api1
+    - name: Build
+      run: cargo build --verbose --no-default-features --features=wayland,openxr
+    - name: Run tests
+      run: cargo test --verbose --no-default-features --features=wayland,openxr
@@ -0,0 +1,28 @@
+name: Check X11+OpenVR
+
+on:
+  pull_request:
+    #branches: [ "main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+  SCCACHE_GHA_ENABLED: "true"
+  RUSTC_WRAPPER: "sccache"
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup sccache
+      uses: mozilla-actions/sccache-action@v0.0.3
+    - name: Prepare Environment
+      run: |
+        sudo add-apt-repository -syn universe
+        sudo add-apt-repository -syn ppa:pipewire-debian/pipewire-upstream || sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 25088A0359807596
+        sudo apt-get update -y
+        sudo apt-get install -y fuse cmake pkg-config fontconfig libasound2-dev libxkbcommon-dev libxkbcommon-x11-0 libxkbcommon-x11-dev libopenxr-dev libfontconfig-dev libdbus-1-dev libpipewire-0.3-0 libpipewire-0.3-dev libspa-0.2-dev libx11-6 libxext6 libxrandr2 libx11-dev libxext-dev libxrandr-dev libopenvr-dev libopenvr-api1
+    - name: Build
+      run: cargo build --verbose --no-default-features --features=x11,openvr
+    - name: Run tests
+      run: cargo test --verbose --no-default-features --features=x11,openvr
@@ -0,0 +1,28 @@
+name: Check X11+OpenXR
+
+on:
+  pull_request:
+    #branches: [ "main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+  SCCACHE_GHA_ENABLED: "true"
+  RUSTC_WRAPPER: "sccache"
+
+jobs:
+  build:
+    runs-on: ubuntu-22.04
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup sccache
+      uses: mozilla-actions/sccache-action@v0.0.3
+    - name: Prepare Environment
+      run: |
+        sudo add-apt-repository -syn universe
+        sudo add-apt-repository -syn ppa:pipewire-debian/pipewire-upstream || sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 25088A0359807596
+        sudo apt-get update -y
+        sudo apt-get install -y fuse cmake pkg-config fontconfig libasound2-dev libxkbcommon-dev libxkbcommon-x11-0 libxkbcommon-x11-dev libopenxr-dev libfontconfig-dev libdbus-1-dev libpipewire-0.3-0 libpipewire-0.3-dev libspa-0.2-dev libx11-6 libxext6 libxrandr2 libx11-dev libxext-dev libxrandr-dev libopenvr-dev libopenvr-api1
+    - name: Build
+      run: cargo build --verbose --no-default-features --features=x11,openxr
+    - name: Run tests
+      run: cargo test --verbose --no-default-features --features=x11,openxr
@@ -7,19 +7,23 @@ on:

 env:
  APPDIR: WlxOverlay-S.AppDir
+  CARGO_TERM_COLOR: always
+  SCCACHE_GHA_ENABLED: "true"
+  RUSTC_WRAPPER: "sccache"
  
 jobs:
  make_release:
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v3
-      
+      - name: Setup sccache
+        uses: mozilla-actions/sccache-action@v0.0.3
      - name: Prepare Environment
        run: |
          sudo add-apt-repository -syn universe
          sudo add-apt-repository -syn ppa:pipewire-debian/pipewire-upstream || sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 25088A0359807596
          sudo apt-get update
-          sudo apt-get install fuse cmake pkg-config fontconfig libasound2-dev libxkbcommon-dev libopenxr-dev libfontconfig-dev libdbus-1-dev libpipewire-0.3-0 libpipewire-0.3-dev libspa-0.2-dev libx11-6 libxext6 libxrandr2 libx11-dev libxext-dev libxrandr-dev libopenvr-dev libopenvr-api1
+          sudo apt-get install -y fuse cmake pkg-config fontconfig libasound2-dev libxkbcommon-dev libxkbcommon-x11-0 libxkbcommon-x11-dev libopenxr-dev libfontconfig-dev libdbus-1-dev libpipewire-0.3-0 libpipewire-0.3-dev libspa-0.2-dev libx11-6 libxext6 libxrandr2 libx11-dev libxext-dev libxrandr-dev libopenvr-dev libopenvr-api1
          rustup update
          
          test -f linuxdeploy-x86_64.AppImage || wget -q "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage"
@@ -4,53 +4,83 @@ debug = true

 [package]
 name = "wlx-overlay-s"
-version = "0.2.6"
+version = "0.5.0"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-anyhow = "1.0.79"
-ash = "^0.37.2"
-chrono = "0.4.29"
-chrono-tz = "0.8.5"
-clap = { version = "4.5.1", features = ["derive"] }
-cstr = "0.2.11"
-ctrlc = { version = "3.4.2", features = ["termination"] }
+anyhow = "1.0.86"
+ash = "^0.38.0"
+chrono = "0.4.38"
+chrono-tz = "0.9.0"
+clap = { version = "4.5.6", features = ["derive"] }
+config = "0.14.0"
+cstr = "0.2.12"
+ctrlc = { version = "3.4.4", features = ["termination"] }
 dbus = { version = "0.9.7" }
-flexi_logger = "0.27.4"
+flexi_logger = "0.28.1"
 fontconfig-rs = "0.1.1"
-freetype-rs = "0.32.0"
-futures = "0.3.29"
-glam = { version = "0.24.1", features = ["approx"] }
-idmap = "0.2.21"
+freetype-rs = "0.36.0" # latest version supported on ubuntu 22.04
+futures = "0.3.30"
+glam = { version = "0.28.0", features = ["approx", "mint", "serde"] }
+idmap = { version = "0.2.21", features = ["serde"] }
 idmap-derive = "0.1.2"
-input-linux = "0.6.0"
+input-linux = "0.7.0"
 json = { version = "0.12.4", optional = true }
-libc = "0.2.147"
-log = "0.4.20"
-once_cell = "1.18.0"
-openxr = { version = "0.17.1", features = ["linked"], optional = true }
-ovr_overlay = { features = ["ovr_input", "ovr_system"], git = "https://github.com/galister/ovr_overlay_oyasumi", optional = true }
-regex = "1.9.5"
-rodio = { version = "0.17.1", default-features = false, features = ["wav", "hound"] }
+json5 = "0.4.1"
+libc = "0.2.155"
+log = "0.4.21"
+once_cell = "1.19.0"
+openxr = { git = "https://github.com/galister/openxrs", rev = "af4a55d", features = [
+  "linked",
+  "mint",
+], optional = true }
+ovr_overlay = { features = [
+  "ovr_input",
+  "ovr_system",
+], git = "https://github.com/galister/ovr_overlay_oyasumi", optional = true }
+regex = "1.10.4"
+rodio = { version = "0.19.0", default-features = false, features = [
+  "wav",
+  "hound",
+] }
 rosc = { version = "0.10.1", optional = true }
-serde = { version = "1.0.188", features = ["derive", "rc"] }
-serde_json = "1.0.113"
-serde_yaml = "0.9.25"
-smallvec = "1.11.0"
-strum = { version = "0.25.0", features = ["derive"] }
-thiserror = "1.0.56"
-vulkano = { git = "https://github.com/vulkano-rs/vulkano", rev = "94f50f1" }
-vulkano-shaders = { git = "https://github.com/vulkano-rs/vulkano", rev = "94f50f1" }
-wlx-capture = { git = "https://github.com/galister/wlx-capture", default-features = false }
+serde = { version = "1.0.203", features = ["derive", "rc"] }
+serde_json = "1.0.117"
+serde_yaml = "0.9.34"
+smallvec = "1.13.2"
+strum = { version = "0.26.2", features = ["derive"] }
+sysinfo = { version = "0.31.2" }
+thiserror = "1.0.61"
+vulkano = { git = "https://github.com/vulkano-rs/vulkano", rev = "b9f3e89" }
+vulkano-shaders = { git = "https://github.com/vulkano-rs/vulkano", rev = "b9f3e89" }
+wlx-capture = { git = "https://github.com/galister/wlx-capture", tag = "v0.3.13", default-features = false }
+libmonado-rs = { git = "https://github.com/technobaboo/libmonado-rs", rev = "a495f6d", optional = true }
+winit = { version = "0.30.0", optional = true }
 xdg = "2.5.2"
+log-panics = { version = "2.1.0", features = ["with-backtrace"] }
+serde_json5 = "0.1.0"
+xkbcommon = { version = "0.8.0" }
+xcb = { version = "1.4.0", optional = true, features = [
+  "as-raw-xcb-connection",
+] }
+image_dds = { version = "0.6.0", default-features = false, features = [
+  "ddsfile",
+] }
+mint = "0.5.9"
+
+[build-dependencies]
+regex = { version = "*" }

 [features]
-default = ["openvr", "openxr", "osc", "x11", "wayland"] 
+default = ["openvr", "openxr", "osc", "x11", "wayland"]
 openvr = ["dep:ovr_overlay", "dep:json"]
-openxr = ["dep:openxr"]
+openxr = ["dep:openxr", "dep:libmonado-rs"]
 osc = ["dep:rosc"]
-x11 = ["wlx-capture/xshm"]
-wayland = ["wlx-capture/pipewire", "wlx-capture/wlr"]
-
+x11 = ["dep:xcb", "wlx-capture/xshm", "xkbcommon/x11"]
+wayland = ["pipewire", "wlx-capture/wlr", "xkbcommon/wayland"]
+pipewire = ["wlx-capture/pipewire"]
+uidev = ["dep:winit"]
+xcb = ["dep:xcb"]
+as-raw-xcb-connection = []
@@ -4,12 +4,14 @@ A lightweight OpenXR/OpenVR overlay for Wayland and X11 desktops, inspired by XS

 WlxOverlay-S allows you to access your desktop screens while in VR.

-Compared to similar software, WlxOverlay-S aims to run alongside your other VR games or experiences and have as little performance impact as possible. The UI looks and rendering methods are kept simple and efficient as much as possible.
+In comparison to similar overlays, WlxOverlay-S aims to run alongside VR games and experiences while having as little performance impact as possible. The UI appearance and rendering techniques are kept as simple and efficient as possible, while still allowing a high degree of customizability.

 This is the coming-together of two of my previous projects:
 - [WlxOverlay](https://github.com/galister/WlxOverlay) (SteamVR overlay written in C#)
 - [WlxOverlay-X](https://github.com/galister/wlx-overlay-x) (OpenXR overlay using StereoKit, written in Rust)

+![Screenshot of WlxOverlay-S in Action](https://github.com/galister/wlx-overlay-s/blob/guide/wlx-s.png?raw=true)
+
 # Join the Linux VR Community

 We are available on either:
@@ -22,7 +24,7 @@ Questions/issues specific to WlxOverlay-S will be handled in the `wlxoverlay` ch

 1. Grab the latest AppImage from [Releases](https://github.com/galister/wlx-overlay-s/releases).
 1. `chmod +x WlxOverlay-S-*.AppImage`
-1. Start Monado or SteamVR.
+1. Start Monado, WiVRn or SteamVR.
 1. Run the overlay

 AUR package is [wlx-overlay-s-git](https://aur.archlinux.org/packages/wlx-overlay-s-git).
@@ -33,12 +35,25 @@ You may also want to [build from source](https://github.com/galister/wlx-overlay

 **If you get a screen share pop-up, check the terminal and select the screens in the order it tells you to.**

+If you selected the screens in the wrong order:
+  - `rm ~/.config/wlxoverlay/conf.d/pw_tokens.yaml` then restart
+
 SteamVR users: WlxOverlay-S will register itself for auto-start, so you will not need to start it every time.

 **Please continue reading the guide below.**

 # Getting Started

+### Working Set
+
+Your working set consists of your currently selected overlays; screens, mirrors, keyboard, etc.
+
+The working set appears in front of you when shown, and can be re-centered by hiding and showing again.
+
+Show and hide your working set using:
+- Non-vive controller: double-tap B or Y on your left controller.
+- Vive controller: double-tap the menu button on your left controller (OpenXR, for SteamVR, you might need to bind `showhide` yourself.)
+
 ### Pointer Modes AKA Laser Colors

 Much of the functionality in WlxOverlay-S depends on what color of laser you are using to interact with a UI element. \
@@ -67,7 +82,9 @@ The click depends on the laser color:
 - Purple laser: Middle click
 - Stick up/down: Scroll wheel

-See the bindings section on how to grab, move and resize screens.
+To **curve a screen**, grab it with one hand. Then, using your other hand, hover the laser over the screen and use the scroll action.
+
+See the [bindings](#default-bindings) section on how to grab, move and resize screens.

 ### The keyboard

@@ -90,20 +107,29 @@ Typing
 If your bindings are not supported, please reach out. \
 We would like to work with you and include additional bindings.

+# Troubleshooting
+
+Check [here](https://github.com/galister/wlx-overlay-s/wiki/Troubleshooting) for tips.
+
 # Known Issues

-## SteamVR: laser pointers not visible
+## Mouse is not where it should be
+Hyprland users: Hyprland v0.41.0 changed their absolute input implementation to one that does not respect existing absolute input standards. Make your voice heard: [Hyprland#6023](https://github.com/hyprwm/Hyprland/issues/6023)・[Hyprland#6889](https://github.com/hyprwm/Hyprland/issues/6889)

-This seems to be a rare issue with SteamVR startup overlays. Restarting the overlay will fix the issue.
+Niri users: use on Niri 0.1.7 or later.

-## Scroll wheel doesn't work
+Other desktops: You may have selected the screens in the wrong order, see [First Start](#first-start).

-This seems to be an issue specific to Electron apps (Discord, Element, Slack, Spotify) on Wayland. Scrolling will work when using these in your web browser.
+## Space-drag crashes SteamVR

-## WiVRn support
+This has been idenfitied as an issue with SteamVR versions 2.5.5 and above (latest tested 2.7.2). One way to avoid the crash is by switching to the `temp-v1.27.5` branch of SteamVR (via beta selection) and selecting [Steam-Play-None](https://github.com/Scrumplex/Steam-Play-None) under the compatibility tab.

-While WiVRn technically supports EXTX_overlay, I do not recommend using this software with WiVRn at this time, due to WiVRn not being optimized for overlay apps. You will likely get ghosting or stuttering while rotating your head.
+## Modifiers get stuck in weird ways
+
+This is a rare issue that can make your desktop not react to click or keys due to a modifier being stuck somewhere. Restarting the overlay fixes this.

 ## X11 limitations
-
-DPI scaling and upright screens are not supported on X11. These might display incorrectly or mess up your mouse position.
+- X11 capture can generally seem slow. This is because zero-copy GPU capture is not supported on the general X11 desktop. Consider trying Wayland or Picom.
+- DPI scaling is not supported and may cause the mouse to not follow the laser properly.
+- Upright screens are not supported and can cause the mouse to act weirdly.
+- Screen changes (connecting / disconnecting a display, resolution changes, etc) are not handled at runtime. Restart the overlay for these to take effect.
@@ -0,0 +1,40 @@
+use regex::Regex;
+use std::process::Command;
+
+fn main() {
+    let mut wlx_build = get_version().unwrap_or(format!("{}-unknown", env!("CARGO_PKG_VERSION")));
+
+    match std::env::var("GITHUB_JOB").as_deref() {
+        Ok("make_release") => {
+            wlx_build = format!("{} (Release)", &wlx_build);
+        }
+        Ok("build_appimage") => {
+            wlx_build = format!("{} (AppImage)", &wlx_build);
+        }
+        _ => {}
+    }
+    println!("cargo:rustc-env=WLX_BUILD={}", &wlx_build);
+}
+
+fn get_version() -> Result<String, Box<dyn std::error::Error>> {
+    let re = Regex::new(r"v([0-9.]+)-([0-9]+)-g([a-f0-9]+)").unwrap(); // safe
+    let output = Command::new("git")
+        .args(["describe", "--tags", "--abbrev=7", "--dirty"])
+        .output()?;
+
+    let mut output_str = String::from_utf8(output.stdout)?;
+
+    if output_str.is_empty() {
+        let output = Command::new("git")
+            .args(["describe", "--tags", "--abbrev=7", "--dirty", "--always"])
+            .output()?;
+
+        output_str = format!(
+            "{}-{}",
+            env!("CARGO_PKG_VERSION"),
+            String::from_utf8(output.stdout)?
+        );
+    }
+
+    Ok(re.replace_all(&output_str, "${1}.r${2}.${3}").into_owned())
+}
@@ -1,26 +1,27 @@
-use std::{
-    collections::{BinaryHeap, VecDeque},
-    sync::Arc,
-    time::Instant,
-};
+use std::sync::Arc;

+use once_cell::sync::Lazy;
 #[cfg(feature = "openxr")]
 use openxr as xr;

-use glam::{Affine3A, Vec2, Vec3A};
+use glam::{Affine3A, Vec3, Vec3A};
 use idmap::IdMap;
 use serde::Deserialize;
 use thiserror::Error;

 use crate::{
+    config::AStrSetExt,
+    hid::{get_keymap_wl, get_keymap_x11},
    overlays::{
+        anchor::create_anchor,
        keyboard::create_keyboard,
+        screen::WlxClientAlias,
        watch::{create_watch, WATCH_NAME},
    },
-    state::{AppState, ScreenMeta},
+    state::AppState,
 };

-use super::overlay::{OverlayBackend, OverlayData, OverlayState};
+use super::overlay::OverlayData;

 #[derive(Error, Debug)]
 pub enum BackendError {
@@ -37,12 +38,22 @@ pub enum BackendError {
    Fatal(#[from] anyhow::Error),
 }

+#[cfg(feature = "wayland")]
+fn create_wl_client() -> Option<WlxClientAlias> {
+    wlx_capture::wayland::WlxClient::new()
+}
+
+#[cfg(not(feature = "wayland"))]
+fn create_wl_client() -> Option<WlxClientAlias> {
+    None
+}
+
 pub struct OverlayContainer<T>
 where
    T: Default,
 {
    overlays: IdMap<usize, OverlayData<T>>,
-    pub extent: Vec2,
+    wl: Option<WlxClientAlias>,
 }

 impl<T> OverlayContainer<T>
@@ -51,44 +62,203 @@ where
 {
    pub fn new(app: &mut AppState) -> anyhow::Result<Self> {
        let mut overlays = IdMap::new();
-        let (screens, extent) = if std::env::var("WAYLAND_DISPLAY").is_ok() {
-            crate::overlays::screen::get_screens_wayland(&app.session)?
-        } else {
-            crate::overlays::screen::get_screens_x11(&app.session)?
-        };
+        let mut wl = create_wl_client();
+
+        let keymap;

        app.screens.clear();
-        for screen in screens.iter() {
-            app.screens.push(ScreenMeta {
-                name: screen.state.name.clone(),
-                id: screen.state.id,
-            });
+        let data = if let Some(wl) = wl.as_mut() {
+            keymap = get_keymap_wl()
+                .map_err(|f| log::warn!("Could not load keyboard layout: {}", f))
+                .ok();
+            crate::overlays::screen::create_screens_wayland(wl, app)?
+        } else {
+            keymap = get_keymap_x11()
+                .map_err(|f| log::warn!("Could not load keyboard layout: {}", f))
+                .ok();
+            match crate::overlays::screen::create_screens_x11pw(app) {
+                Ok(data) => data,
+                Err(e) => {
+                    log::info!("Will not use PipeWire capture: {:?}", e);
+                    crate::overlays::screen::create_screens_xshm(app)?
+                }
+            }
+        };
+
+        let mut show_screens = app.session.config.show_screens.clone();
+        if show_screens.is_empty() {
+            if let Some((_, s, _)) = data.screens.first() {
+                show_screens.arc_set(s.name.clone());
+            }
        }

+        for (meta, mut state, backend) in data.screens {
+            if show_screens.arc_get(state.name.as_ref()) {
+                state.show_hide = true;
+            }
+            overlays.insert(
+                state.id,
+                OverlayData::<T> {
+                    state,
+                    backend,
+                    ..Default::default()
+                },
+            );
+            app.screens.push(meta);
+        }
+
+        let anchor = create_anchor(app)?;
+        overlays.insert(anchor.state.id, anchor);
+
        let mut watch = create_watch::<T>(app)?;
        watch.state.want_visible = true;
        overlays.insert(watch.state.id, watch);

-        let mut keyboard = create_keyboard(app)?;
+        let mut keyboard = create_keyboard(app, keymap)?;
        keyboard.state.show_hide = true;
        keyboard.state.want_visible = false;
        overlays.insert(keyboard.state.id, keyboard);

-        let mut show_screens = app.session.config.show_screens.clone();
-        if show_screens.is_empty() {
-            if let Some(s) = screens.first() {
-                show_screens.push(s.state.name.clone());
+        Ok(Self { overlays, wl })
+    }
+
+    #[cfg(not(feature = "wayland"))]
+    pub fn update(&mut self, _app: &mut AppState) -> anyhow::Result<Vec<OverlayData<T>>> {
+        Ok(vec![])
+    }
+    #[cfg(feature = "wayland")]
+    pub fn update(&mut self, app: &mut AppState) -> anyhow::Result<Vec<OverlayData<T>>> {
+        use crate::overlays::{
+            screen::{create_screen_interaction, create_screen_renderer_wl, load_pw_token_config},
+            watch::create_watch_canvas,
+        };
+        use glam::vec2;
+        use wlx_capture::wayland::OutputChangeEvent;
+
+        let mut removed_overlays = vec![];
+        let Some(wl) = self.wl.as_mut() else {
+            return Ok(removed_overlays);
+        };
+
+        wl.dispatch_pending();
+
+        let mut create_ran = false;
+        let mut extent_dirty = false;
+        let mut watch_dirty = false;
+
+        let mut maybe_token_store = None;
+
+        for ev in wl.iter_events().collect::<Vec<_>>() {
+            match ev {
+                OutputChangeEvent::Create(_) => {
+                    if create_ran {
+                        continue;
+                    }
+                    let data = crate::overlays::screen::create_screens_wayland(wl, app)?;
+                    create_ran = true;
+                    for (meta, state, backend) in data.screens {
+                        self.overlays.insert(
+                            state.id,
+                            OverlayData::<T> {
+                                state,
+                                backend,
+                                ..Default::default()
+                            },
+                        );
+                        app.screens.push(meta);
+                        watch_dirty = true;
+                    }
+                }
+                OutputChangeEvent::Destroy(id) => {
+                    let Some(idx) = app.screens.iter().position(|s| s.native_handle == id) else {
+                        continue;
+                    };
+
+                    let meta = &app.screens[idx];
+                    let removed = self.overlays.remove(meta.id).unwrap();
+                    removed_overlays.push(removed);
+                    log::info!("{}: Destroyed", meta.name);
+                    app.screens.remove(idx);
+                    watch_dirty = true;
+                    extent_dirty = true;
+                }
+                OutputChangeEvent::Logical(id) => {
+                    let Some(meta) = app.screens.iter().find(|s| s.native_handle == id) else {
+                        continue;
+                    };
+                    let output = wl.outputs.get(id).unwrap();
+                    let Some(overlay) = self.overlays.get_mut(meta.id) else {
+                        continue;
+                    };
+                    let logical_pos =
+                        vec2(output.logical_pos.0 as f32, output.logical_pos.1 as f32);
+                    let logical_size =
+                        vec2(output.logical_size.0 as f32, output.logical_size.1 as f32);
+                    let transform = output.transform.into();
+                    overlay
+                        .backend
+                        .set_interaction(Box::new(create_screen_interaction(
+                            logical_pos,
+                            logical_size,
+                            transform,
+                        )));
+                    extent_dirty = true;
+                }
+                OutputChangeEvent::Physical(id) => {
+                    let Some(meta) = app.screens.iter().find(|s| s.native_handle == id) else {
+                        continue;
+                    };
+                    let output = wl.outputs.get(id).unwrap();
+                    let Some(overlay) = self.overlays.get_mut(meta.id) else {
+                        continue;
+                    };
+
+                    let has_wlr_dmabuf = wl.maybe_wlr_dmabuf_mgr.is_some();
+                    let has_wlr_screencopy = wl.maybe_wlr_screencopy_mgr.is_some();
+
+                    let pw_token_store = maybe_token_store.get_or_insert_with(|| {
+                        load_pw_token_config().unwrap_or_else(|e| {
+                            log::warn!("Failed to load PipeWire token config: {:?}", e);
+                            Default::default()
+                        })
+                    });
+
+                    if let Some(renderer) = create_screen_renderer_wl(
+                        output,
+                        has_wlr_dmabuf,
+                        has_wlr_screencopy,
+                        pw_token_store,
+                        &app.session,
+                    ) {
+                        overlay.backend.set_renderer(Box::new(renderer));
+                    }
+                    extent_dirty = true;
+                }
            }
        }

-        for mut screen in screens {
-            if show_screens.contains(&screen.state.name) {
-                screen.state.show_hide = true;
-                screen.state.want_visible = false;
-            }
-            overlays.insert(screen.state.id, screen);
+        if extent_dirty && !create_ran {
+            let extent = wl.get_desktop_extent();
+            let origin = wl.get_desktop_origin();
+            app.hid_provider
+                .set_desktop_extent(vec2(extent.0 as f32, extent.1 as f32));
+            app.hid_provider
+                .set_desktop_origin(vec2(origin.0 as f32, origin.1 as f32));
        }
-        Ok(Self { overlays, extent })
+
+        if watch_dirty {
+            let watch = self.mut_by_name(WATCH_NAME).unwrap(); // want panic
+            match create_watch_canvas(None, app) {
+                Ok(canvas) => {
+                    watch.backend = Box::new(canvas);
+                }
+                Err(e) => {
+                    log::error!("Failed to create watch canvas: {}", e);
+                }
+            }
+        }
+
+        Ok(removed_overlays)
    }

    pub fn mut_by_selector(&mut self, selector: &OverlaySelector) -> Option<&mut OverlayData<T>> {
@@ -146,10 +316,20 @@ where
            .values()
            .any(|o| o.state.show_hide && o.state.want_visible);

+        if !any_shown {
+            static ANCHOR_LOCAL: Lazy<Affine3A> =
+                Lazy::new(|| Affine3A::from_translation(Vec3::NEG_Z));
+            let hmd = snap_upright(app.input_state.hmd, Vec3A::Y);
+            app.anchor = hmd * *ANCHOR_LOCAL;
+        }
+
        self.overlays.values_mut().for_each(|o| {
            if o.state.show_hide {
                o.state.want_visible = !any_shown;
-                if o.state.want_visible && o.state.recenter {
+                if o.state.want_visible
+                    && app.session.config.realign_on_showhide
+                    && o.state.recenter
+                {
                    o.state.reset(app, false);
                }
            }
@@ -161,114 +341,29 @@ where
    }
 }

-#[derive(Clone, Deserialize)]
+#[derive(Clone, Deserialize, Debug)]
 #[serde(untagged)]
 pub enum OverlaySelector {
    Id(usize),
    Name(Arc<str>),
 }

-struct AppTask {
-    pub not_before: Instant,
-    pub task: TaskType,
-}
+pub fn snap_upright(transform: Affine3A, up_dir: Vec3A) -> Affine3A {
+    if transform.x_axis.dot(up_dir).abs() < 0.2 {
+        let scale = transform.x_axis.length();
+        let col_z = transform.z_axis.normalize();
+        let col_y = up_dir;
+        let col_x = col_y.cross(col_z);
+        let col_y = col_z.cross(col_x).normalize();
+        let col_x = col_x.normalize();

-impl PartialEq<AppTask> for AppTask {
-    fn eq(&self, other: &Self) -> bool {
-        self.not_before == other.not_before
+        Affine3A::from_cols(
+            col_x * scale,
+            col_y * scale,
+            col_z * scale,
+            transform.translation,
+        )
+    } else {
+        transform
    }
 }
-impl PartialOrd<AppTask> for AppTask {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-impl Eq for AppTask {}
-impl Ord for AppTask {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.not_before.cmp(&other.not_before).reverse()
-    }
-}
-
-pub enum SystemTask {
-    ColorGain(ColorChannel, f32),
-    ResetPlayspace,
-    FixFloor,
-}
-
-pub type OverlayTask = dyn FnOnce(&mut AppState, &mut OverlayState) + Send;
-pub type CreateOverlayTask =
-    dyn FnOnce(&mut AppState) -> Option<(OverlayState, Box<dyn OverlayBackend>)> + Send;
-
-pub enum TaskType {
-    Global(Box<dyn FnOnce(&mut AppState) + Send>),
-    Overlay(OverlaySelector, Box<OverlayTask>),
-    CreateOverlay(OverlaySelector, Box<CreateOverlayTask>),
-    DropOverlay(OverlaySelector),
-    System(SystemTask),
-}
-
-#[derive(Deserialize, Clone, Copy)]
-pub enum ColorChannel {
-    R,
-    G,
-    B,
-    All,
-}
-
-pub struct TaskContainer {
-    tasks: BinaryHeap<AppTask>,
-}
-
-impl TaskContainer {
-    pub fn new() -> Self {
-        Self {
-            tasks: BinaryHeap::new(),
-        }
-    }
-
-    pub fn enqueue(&mut self, task: TaskType) {
-        self.tasks.push(AppTask {
-            not_before: Instant::now(),
-            task,
-        });
-    }
-
-    pub fn enqueue_at(&mut self, task: TaskType, not_before: Instant) {
-        self.tasks.push(AppTask { not_before, task });
-    }
-
-    pub fn retrieve_due(&mut self, dest_buf: &mut VecDeque<TaskType>) {
-        let now = Instant::now();
-
-        while let Some(task) = self.tasks.peek() {
-            if task.not_before > now {
-                break;
-            }
-
-            // Safe unwrap because we peeked.
-            dest_buf.push_back(self.tasks.pop().unwrap().task);
-        }
-    }
-}
-
-pub fn raycast(
-    source: &Affine3A,
-    source_fwd: Vec3A,
-    plane: &Affine3A,
-    plane_norm: Vec3A,
-) -> Option<(Vec3A, f32)> {
-    let plane_normal = plane.transform_vector3a(plane_norm);
-    let ray_dir = source.transform_vector3a(source_fwd);
-
-    let d = plane.translation.dot(-plane_normal);
-    let dist = -(d + source.translation.dot(plane_normal)) / ray_dir.dot(plane_normal);
-
-    if dist < 0.0 {
-        // plane is behind the caster
-        return None;
-    }
-
-    let hit_pos = source.translation + ray_dir * dist;
-    Some((hit_pos, dist))
-}
@@ -1,22 +1,19 @@
+use std::f32::consts::PI;
 use std::{collections::VecDeque, time::Instant};

-use glam::{Affine3A, Vec2, Vec3A};
+use glam::{Affine3A, Vec2, Vec3, Vec3A, Vec3Swizzles};

-#[cfg(feature = "openvr")]
-use ovr_overlay::TrackedDeviceIndex;
 use smallvec::{smallvec, SmallVec};

+use crate::backend::common::{snap_upright, OverlaySelector};
+use crate::config::{AStrMapExt, GeneralConfig};
+use crate::overlays::anchor::ANCHOR_NAME;
 use crate::state::AppState;

-use super::{
-    common::{raycast, OverlayContainer},
-    overlay::OverlayData,
-};
+use super::task::{TaskContainer, TaskType};
+use super::{common::OverlayContainer, overlay::OverlayData};

 pub struct TrackedDevice {
-    #[cfg(feature = "openvr")]
-    pub index: TrackedDeviceIndex,
-    pub valid: bool,
    pub soc: Option<f32>,
    pub charging: bool,
    pub role: TrackedDeviceRole,
@@ -34,6 +31,7 @@ pub enum TrackedDeviceRole {

 pub struct InputState {
    pub hmd: Affine3A,
+    pub ipd: f32,
    pub pointers: [Pointer; 2],
    pub devices: Vec<TrackedDevice>,
 }
@@ -42,6 +40,7 @@ impl InputState {
    pub fn new() -> Self {
        Self {
            hmd: Affine3A::IDENTITY,
+            ipd: 0.0,
            pointers: [Pointer::new(0), Pointer::new(1)],
            devices: Vec::new(),
        }
@@ -71,6 +70,12 @@ impl InputState {
                if hand.now.space_drag != hand.before.space_drag {
                    log::debug!("Hand {}: space_drag {}", hand.idx, hand.now.space_drag);
                }
+                if hand.now.space_rotate != hand.before.space_rotate {
+                    log::debug!("Hand {}: space_rotate {}", hand.idx, hand.now.space_rotate);
+                }
+                if hand.now.space_reset != hand.before.space_reset {
+                    log::debug!("Hand {}: space_reset {}", hand.idx, hand.now.space_reset);
+                }
                if hand.now.click_modifier_right != hand.before.click_modifier_right {
                    log::debug!(
                        "Hand {}: click_modifier_right {}",
@@ -189,8 +194,11 @@ pub struct PointerState {
    pub alt_click: bool,
    pub show_hide: bool,
    pub space_drag: bool,
+    pub space_rotate: bool,
+    pub space_reset: bool,
    pub click_modifier_right: bool,
    pub click_modifier_middle: bool,
+    pub move_mouse: bool,
 }

 #[derive(Debug, Clone, Copy, Default)]
@@ -230,7 +238,8 @@ impl InteractionHandler for DummyInteractionHandler {
 #[derive(Debug, Clone, Copy, Default)]
 struct RayHit {
    overlay: usize,
-    hit_pos: Vec3A,
+    global_pos: Vec3A,
+    local_pos: Vec2,
    dist: f32,
 }

@@ -238,6 +247,8 @@ struct RayHit {
 pub struct GrabData {
    pub offset: Vec3A,
    pub grabbed_id: usize,
+    pub old_curvature: Option<f32>,
+    pub grab_all: bool,
 }

 #[repr(u8)]
@@ -276,11 +287,17 @@ fn interact_hand<O>(
 where
    O: Default,
 {
-    let hmd = &app.input_state.hmd;
+    let hmd = app.input_state.hmd;
    let mut pointer = &mut app.input_state.pointers[idx];
    if let Some(grab_data) = pointer.interaction.grabbed {
        if let Some(grabbed) = overlays.mut_by_id(grab_data.grabbed_id) {
-            pointer.handle_grabbed(grabbed, hmd);
+            pointer.handle_grabbed(
+                grabbed,
+                &hmd,
+                &app.anchor,
+                &mut app.tasks,
+                &mut app.session.config,
+            );
        } else {
            log::warn!("Grabbed overlay {} does not exist", grab_data.grabbed_id);
            pointer.interaction.grabbed = None;
@@ -342,7 +359,7 @@ where
    log::trace!("Hit: {} {:?}", hovered.state.name, hit);

    if pointer.now.grab && !pointer.before.grab && hovered.state.grabbable {
-        pointer.start_grab(hovered);
+        pointer.start_grab(hovered, &mut app.tasks);
        return (
            hit.dist,
            Some(Haptics {
@@ -353,12 +370,35 @@ where
        );
    }

+    // Pass mouse motion events only if not scrolling
+    // (allows scrolling on all Chromium-based applications)
    let haptics = hovered.backend.on_hover(app, &hit);
+
    pointer = &mut app.input_state.pointers[idx];

    if pointer.now.scroll.abs() > 0.1 {
        let scroll = pointer.now.scroll;
-        hovered.backend.on_scroll(app, &hit, scroll);
+        if app.input_state.pointers[1 - idx]
+            .interaction
+            .grabbed
+            .is_some_and(|x| x.grabbed_id == hit.overlay)
+        {
+            let can_curve = hovered.extent().is_some_and(|e| e[0] >= e[1]);
+
+            if can_curve {
+                let cur = hovered.state.curvature.unwrap_or(0.0);
+                let new = (cur - scroll * 0.01).min(0.35);
+                if new <= f32::EPSILON {
+                    hovered.state.curvature = None;
+                } else {
+                    hovered.state.curvature = Some(new);
+                }
+            } else {
+                hovered.state.curvature = None;
+            }
+        } else {
+            hovered.backend.on_scroll(app, &hit, scroll);
+        }
        pointer = &mut app.input_state.pointers[idx];
    }

@@ -389,7 +429,11 @@ impl Pointer {
                continue;
            }

-            if let Some(hit) = self.ray_test(overlay.state.id, &overlay.state.transform) {
+            if let Some(hit) = self.ray_test(
+                overlay.state.id,
+                &overlay.state.transform,
+                &overlay.state.curvature,
+            ) {
                if hit.dist.is_infinite() || hit.dist.is_nan() {
                    continue;
                }
@@ -404,12 +448,8 @@ impl Pointer {

            let uv = overlay
                .state
-                .transform
-                .inverse()
-                .transform_point3a(hit.hit_pos)
-                .truncate();
-
-            let uv = overlay.state.interaction_transform.transform_point2(uv);
+                .interaction_transform
+                .transform_point2(hit.local_pos);

            if uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0 {
                continue;
@@ -428,7 +468,7 @@ impl Pointer {
        None
    }

-    fn start_grab<O>(&mut self, overlay: &mut OverlayData<O>)
+    fn start_grab<O>(&mut self, overlay: &mut OverlayData<O>, tasks: &mut TaskContainer)
    where
        O: Default,
    {
@@ -440,12 +480,33 @@ impl Pointer {
        self.interaction.grabbed = Some(GrabData {
            offset,
            grabbed_id: overlay.state.id,
+            old_curvature: overlay.state.curvature,
+            grab_all: matches!(self.interaction.mode, PointerMode::Right),
        });
+        tasks.enqueue(TaskType::Overlay(
+            OverlaySelector::Name(ANCHOR_NAME.clone()),
+            Box::new(|app, o| {
+                o.transform = app.anchor
+                    * Affine3A::from_scale_rotation_translation(
+                        Vec3::ONE * o.spawn_scale,
+                        o.spawn_rotation,
+                        o.spawn_point.into(),
+                    );
+                o.dirty = true;
+                o.want_visible = true;
+            }),
+        ));
        log::info!("Hand {}: grabbed {}", self.idx, overlay.state.name);
    }

-    fn handle_grabbed<O>(&mut self, overlay: &mut OverlayData<O>, hmd: &Affine3A)
-    where
+    fn handle_grabbed<O>(
+        &mut self,
+        overlay: &mut OverlayData<O>,
+        hmd: &Affine3A,
+        anchor: &Affine3A,
+        tasks: &mut TaskContainer,
+        config: &mut GeneralConfig,
+    ) where
        O: Default,
    {
        if self.now.grab {
@@ -465,7 +526,7 @@ impl Pointer {
                        .transform
                        .matrix3
                        .mul_scalar(1.0 - 0.025 * self.now.scroll);
-                } else {
+                } else if config.allow_sliding && self.now.scroll.is_finite() {
                    grab_data.offset.z -= self.now.scroll * 0.05;
                }
                overlay.state.transform.translation = self.pose.transform_point3a(grab_data.offset);
@@ -476,24 +537,135 @@ impl Pointer {
                self.interaction.grabbed = None;
            }
        } else {
-            overlay.state.saved_point = Some(
-                hmd.inverse()
-                    .transform_point3a(overlay.state.transform.translation),
-            );
+            if overlay.state.anchored {
+                overlay.state.saved_transform =
+                    Some(snap_upright(*anchor, Vec3A::Y).inverse() * overlay.state.transform);
+
+                if let Some(grab_data) = self.interaction.grabbed.as_ref() {
+                    if overlay.state.curvature != grab_data.old_curvature {
+                        if let Some(val) = overlay.state.curvature {
+                            config.curve_values.arc_set(overlay.state.name.clone(), val);
+                        } else {
+                            let ref_name = overlay.state.name.as_ref();
+                            config.curve_values.arc_rm(ref_name);
+                        }
+                    }
+                }
+                config.transform_values.arc_set(
+                    overlay.state.name.clone(),
+                    overlay.state.saved_transform.unwrap(), // safe
+                );
+            }
+
            self.interaction.grabbed = None;
+            tasks.enqueue(TaskType::Overlay(
+                OverlaySelector::Name(ANCHOR_NAME.clone()),
+                Box::new(|_app, o| {
+                    o.want_visible = false;
+                }),
+            ));
            log::info!("Hand {}: dropped {}", self.idx, overlay.state.name);
        }
    }

-    fn ray_test(&self, overlay: usize, plane: &Affine3A) -> Option<RayHit> {
-        let Some((hit_pos, dist)) = raycast(&self.pose, Vec3A::NEG_Z, plane, Vec3A::NEG_Z) else {
+    fn ray_test(
+        &self,
+        overlay: usize,
+        transform: &Affine3A,
+        curvature: &Option<f32>,
+    ) -> Option<RayHit> {
+        let (dist, local_pos) = match curvature {
+            Some(curvature) => raycast_cylinder(&self.pose, Vec3A::NEG_Z, transform, *curvature),
+            _ => raycast_plane(&self.pose, Vec3A::NEG_Z, transform, Vec3A::NEG_Z),
+        }?;
+
+        if dist < 0.0 {
+            // hit is behind us
            return None;
-        };
+        }

        Some(RayHit {
            overlay,
-            hit_pos,
+            global_pos: self.pose.transform_point3a(Vec3A::NEG_Z * dist),
+            local_pos,
            dist,
        })
    }
 }
+
+fn raycast_plane(
+    source: &Affine3A,
+    source_fwd: Vec3A,
+    plane: &Affine3A,
+    plane_norm: Vec3A,
+) -> Option<(f32, Vec2)> {
+    let plane_normal = plane.transform_vector3a(plane_norm);
+    let ray_dir = source.transform_vector3a(source_fwd);
+
+    let d = plane.translation.dot(-plane_normal);
+    let dist = -(d + source.translation.dot(plane_normal)) / ray_dir.dot(plane_normal);
+
+    let hit_local = plane
+        .inverse()
+        .transform_point3a(source.translation + ray_dir * dist)
+        .xy();
+
+    Some((dist, hit_local))
+}
+
+fn raycast_cylinder(
+    source: &Affine3A,
+    source_fwd: Vec3A,
+    plane: &Affine3A,
+    curvature: f32,
+) -> Option<(f32, Vec2)> {
+    // this is solved locally; (0,0) is the center of the cylinder, and the cylinder is aligned with the Y axis
+    let size = plane.x_axis.length();
+    let to_local = Affine3A {
+        matrix3: plane.matrix3.mul_scalar(1.0 / size),
+        translation: plane.translation,
+    }
+    .inverse();
+
+    let r = size / (2.0 * PI * curvature);
+
+    let ray_dir = to_local.transform_vector3a(source.transform_vector3a(source_fwd));
+    let ray_origin = to_local.transform_point3a(source.translation) + Vec3A::NEG_Z * r;
+
+    let d = ray_dir.xz();
+    let s = ray_origin.xz();
+
+    let a = d.dot(d);
+    let b = d.dot(s);
+    let c = s.dot(s) - r * r;
+
+    let d = (b * b) - (a * c);
+    if d < f32::EPSILON {
+        return None;
+    }
+
+    let sqrt_d = d.sqrt();
+
+    let t1 = (-b - sqrt_d) / a;
+    let t2 = (-b + sqrt_d) / a;
+
+    let t = t1.max(t2);
+
+    if t < f32::EPSILON {
+        return None;
+    }
+
+    let mut hit_local = ray_origin + ray_dir * t;
+    if hit_local.z > 0.0 {
+        // hitting the opposite half of the cylinder
+        return None;
+    }
+
+    let max_angle = 2.0 * (size / (2.0 * r));
+    let x_angle = (hit_local.x / r).asin();
+
+    hit_local.x = x_angle / max_angle;
+    hit_local.y /= size;
+
+    Some((t, hit_local.xy()))
+}
@@ -8,7 +8,12 @@ pub mod openvr;
 #[cfg(feature = "openxr")]
 pub mod openxr;

+#[cfg(feature = "uidev")]
+pub mod uidev;
+
 #[cfg(feature = "osc")]
 pub mod osc;

 pub mod overlay;
+
+pub mod task;
@@ -1,17 +1,23 @@
 use dbus::{blocking::Connection, channel::MatchingReceiver, message::MatchRule};
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 use std::{
-    path::PathBuf,
-    sync::{mpsc, Arc},
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        mpsc, Arc,
+    },
    time::Duration,
 };

-use crate::{config::def_true, config_io, overlays::toast::Toast, state::AppState};
+use crate::{
+    overlays::toast::{Toast, ToastTopic},
+    state::AppState,
+};

 pub struct NotificationManager {
    rx_toast: mpsc::Receiver<Toast>,
    tx_toast: mpsc::SyncSender<Toast>,
    dbus_data: Option<Connection>,
+    running: Arc<AtomicBool>,
 }

 impl NotificationManager {
@@ -21,6 +27,7 @@ impl NotificationManager {
            rx_toast,
            tx_toast,
            dbus_data: None,
+            running: Arc::new(AtomicBool::new(true)),
        }
    }

@@ -125,7 +132,7 @@ impl NotificationManager {

    pub fn run_udp(&mut self) {
        let sender = self.tx_toast.clone();
-        // NOTE: We're detaching the thread, as there's no simple way to gracefully stop it other than app shutdown.
+        let running = self.running.clone();
        let _ = std::thread::spawn(move || {
            let addr = "127.0.0.1:42069";
            let socket = match std::net::UdpSocket::bind(addr) {
@@ -135,9 +142,13 @@ impl NotificationManager {
                    return;
                }
            };
+            if let Err(err) = socket.set_read_timeout(Some(Duration::from_millis(200))) {
+                log::error!("Failed to set read timeout: {:?}", err);
+            }
+
            let mut buf = [0u8; 1024 * 16]; // vrcx embeds icons as b64

-            loop {
+            while running.load(Ordering::Relaxed) {
                if let Ok((num_bytes, _)) = socket.recv_from(&mut buf) {
                    let json_str = match std::str::from_utf8(&buf[..num_bytes]) {
                        Ok(s) => s,
@@ -158,9 +169,13 @@ impl NotificationManager {
                        continue;
                    }

-                    let toast = Toast::new(msg.title, msg.content.unwrap_or_else(|| "".into()))
-                        .with_timeout(msg.timeout.unwrap_or(5.))
-                        .with_sound(msg.volume.unwrap_or(-1.) >= 0.); // XSOverlay still plays at 0,
+                    let toast = Toast::new(
+                        ToastTopic::XSNotification,
+                        msg.title,
+                        msg.content.unwrap_or_else(|| "".into()),
+                    )
+                    .with_timeout(msg.timeout.unwrap_or(5.))
+                    .with_sound(msg.volume.unwrap_or(-1.) >= 0.); // XSOverlay still plays at 0,

                    match sender.try_send(toast) {
                        Ok(_) => {}
@@ -170,10 +185,17 @@ impl NotificationManager {
                    }
                }
            }
+            log::info!("Notification listener stopped.");
        });
    }
 }

+impl Drop for NotificationManager {
+    fn drop(&mut self) {
+        self.running.store(false, Ordering::Relaxed);
+    }
+}
+
 fn parse_dbus(msg: &dbus::Message) -> anyhow::Result<Toast> {
    let mut args = msg.iter_init();
    let app_name: String = args.read()?;
@@ -188,9 +210,11 @@ fn parse_dbus(msg: &dbus::Message) -> anyhow::Result<Toast> {
        summary
    };

-    Ok(Toast::new(title.into(), body.into())
-        .with_timeout(5.0)
-        .with_opacity(1.0))
+    Ok(
+        Toast::new(ToastTopic::DesktopNotification, title.into(), body.into())
+            .with_timeout(5.0)
+            .with_opacity(1.0),
+    )
    // leave the audio part to the desktop env
 }

@@ -211,29 +235,3 @@ struct XsoMessage {
    sourceApp: Option<Arc<str>>,
    alwaysShow: Option<bool>,
 }
-
-#[derive(Deserialize, Serialize)]
-pub struct NotifiConf {
-    #[serde(default = "def_true")]
-    pub notifications_enabled: bool,
-
-    #[serde(default = "def_true")]
-    pub notifications_sound_enabled: bool,
-}
-
-fn get_config_path() -> PathBuf {
-    let mut path = config_io::get_conf_d_path();
-    path.push("notifications.yaml");
-    path
-}
-pub fn save_notifications(app: &mut AppState) -> anyhow::Result<()> {
-    let conf = NotifiConf {
-        notifications_enabled: app.session.config.notifications_enabled,
-        notifications_sound_enabled: app.session.config.notifications_sound_enabled,
-    };
-
-    let yaml = serde_yaml::to_string(&conf)?;
-    std::fs::write(get_config_path(), yaml)?;
-
-    Ok(())
-}
@@ -4,7 +4,7 @@ use glam::Affine3A;
 use ovr_overlay::{pose::Matrix3x4, settings::SettingsManager, sys::HmdMatrix34_t};
 use thiserror::Error;

-use crate::backend::common::{BackendError, ColorChannel};
+use crate::backend::{common::BackendError, task::ColorChannel};

 pub trait Affine3AConvert {
    fn from_affine(affine: &Affine3A) -> Self;
@@ -36,8 +36,10 @@ const PATH_SCROLL: &str = "/actions/default/in/Scroll";
 const PATH_ALT_CLICK: &str = "/actions/default/in/AltClick";
 const PATH_SHOW_HIDE: &str = "/actions/default/in/ShowHide";
 const PATH_SPACE_DRAG: &str = "/actions/default/in/SpaceDrag";
+const PATH_SPACE_ROTATE: &str = "/actions/default/in/SpaceRotate";
 const PATH_CLICK_MODIFIER_RIGHT: &str = "/actions/default/in/ClickModifierRight";
 const PATH_CLICK_MODIFIER_MIDDLE: &str = "/actions/default/in/ClickModifierMiddle";
+const PATH_MOVE_MOUSE: &str = "/actions/default/in/MoveMouse";

 const INPUT_ANY: InputValueHandle = InputValueHandle(ovr_overlay::sys::k_ulInvalidInputValueHandle);

@@ -50,8 +52,10 @@ pub(super) struct OpenVrInputSource {
    alt_click_hnd: ActionHandle,
    show_hide_hnd: ActionHandle,
    space_drag_hnd: ActionHandle,
+    space_rotate_hnd: ActionHandle,
    click_modifier_right_hnd: ActionHandle,
    click_modifier_middle_hnd: ActionHandle,
+    move_mouse_hnd: ActionHandle,
 }

 pub(super) struct OpenVrHandSource {
@@ -72,8 +76,10 @@ impl OpenVrInputSource {
        let alt_click_hnd = input.get_action_handle(PATH_ALT_CLICK)?;
        let show_hide_hnd = input.get_action_handle(PATH_SHOW_HIDE)?;
        let space_drag_hnd = input.get_action_handle(PATH_SPACE_DRAG)?;
+        let space_rotate_hnd = input.get_action_handle(PATH_SPACE_ROTATE)?;
        let click_modifier_right_hnd = input.get_action_handle(PATH_CLICK_MODIFIER_RIGHT)?;
        let click_modifier_middle_hnd = input.get_action_handle(PATH_CLICK_MODIFIER_MIDDLE)?;
+        let move_mouse_hnd = input.get_action_handle(PATH_MOVE_MOUSE)?;

        let input_hnd: Vec<InputValueHandle> = INPUT_SOURCES
            .iter()
@@ -106,8 +112,10 @@ impl OpenVrInputSource {
            alt_click_hnd,
            show_hide_hnd,
            space_drag_hnd,
+            space_rotate_hnd,
            click_modifier_right_hnd,
            click_modifier_middle_hnd,
+            move_mouse_hnd,
            hands,
        })
    }
@@ -193,6 +201,11 @@ impl OpenVrInputSource {
                .map(|x| x.0.bState)
                .unwrap_or(false);

+            app_hand.now.space_rotate = input
+                .get_digital_action_data(self.space_rotate_hnd, hand.input_hnd)
+                .map(|x| x.0.bState)
+                .unwrap_or(false);
+
            app_hand.now.click_modifier_right = input
                .get_digital_action_data(self.click_modifier_right_hnd, hand.input_hnd)
                .map(|x| x.0.bState)
@@ -203,6 +216,11 @@ impl OpenVrInputSource {
                .map(|x| x.0.bState)
                .unwrap_or(false);

+            app_hand.now.move_mouse = input
+                .get_digital_action_data(self.move_mouse_hnd, hand.input_hnd)
+                .map(|x| x.0.bState)
+                .unwrap_or(false);
+
            app_hand.now.scroll = input
                .get_analog_action_data(self.scroll_hnd, hand.input_hnd)
                .map(|x| x.0.y)
@@ -291,8 +309,6 @@ fn get_tracked_device(
    }

    Some(TrackedDevice {
-        valid: true,
-        index,
        soc,
        charging,
        role,
@@ -302,8 +318,10 @@ fn get_tracked_device(
 pub fn set_action_manifest(input: &mut InputManager) -> anyhow::Result<()> {
    let action_path = CONFIG_ROOT_PATH.join("actions.json");

-    if !action_path.is_file() {
-        File::create(&action_path)?.write_all(include_bytes!("../../res/actions.json"))?;
+    if let Err(e) = File::create(&action_path)
+        .and_then(|mut f| f.write_all(include_bytes!("../../res/actions.json")))
+    {
+        log::warn!("Could not write action manifest: {}", e);
    }

    let binding_path = CONFIG_ROOT_PATH.join("actions_binding_knuckles.json");
@@ -32,7 +32,7 @@ impl LinePool {

        let buf = vec![255; 16];

-        let texture = command_buffer.texture2d(2, 2, Format::R8G8B8A8_UNORM, &buf)?;
+        let texture = command_buffer.texture2d_raw(2, 2, Format::R8G8B8A8_UNORM, &buf)?;
        command_buffer.build_and_execute_now()?;

        graphics
@@ -75,11 +75,12 @@ impl LinePool {
            }),
            data: OpenVrOverlayData {
                width: 0.002,
+                override_width: true,
                ..Default::default()
            },
            ..Default::default()
        };
-        data.data.sort_order = 69;
+        data.state.z_order = 69;
        data.state.dirty = true;

        self.lines.insert(id, data);
@@ -160,6 +161,12 @@ impl LinePool {
        }
        Ok(())
    }
+
+    pub fn mark_dirty(&mut self) {
+        for data in self.lines.values_mut() {
+            data.state.dirty = true;
+        }
+    }
 }

 struct StaticRenderer {
@@ -182,4 +189,7 @@ impl OverlayRenderer for StaticRenderer {
    fn view(&mut self) -> Option<Arc<ImageView>> {
        Some(self.view.clone())
    }
+    fn extent(&mut self) -> Option<[u32; 3]> {
+        Some(self.view.image().extent())
+    }
 }
@@ -1,5 +1,6 @@
 use std::{
    collections::VecDeque,
+    ops::Add,
    sync::{
        atomic::{AtomicBool, AtomicUsize, Ordering},
        Arc,
@@ -20,7 +21,7 @@ use vulkano::{

 use crate::{
    backend::{
-        common::SystemTask,
+        common::{BackendError, OverlayContainer},
        input::interact,
        notifications::NotificationManager,
        openvr::{
@@ -31,14 +32,16 @@ use crate::{
            overlay::OpenVrOverlayData,
        },
        overlay::OverlayData,
+        task::{SystemTask, TaskType},
    },
    graphics::WlxGraphics,
-    overlays::watch::{watch_fade, WATCH_NAME},
+    overlays::{
+        toast::{Toast, ToastTopic},
+        watch::{watch_fade, WATCH_NAME},
+    },
    state::AppState,
 };

-use super::common::{BackendError, OverlayContainer, TaskType};
-
 pub mod helpers;
 pub mod input;
 pub mod lines;
@@ -59,7 +62,7 @@ pub fn openvr_uninstall() {
    let _ = uninstall_manifest(&mut app_mgr);
 }

-pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
+pub fn openvr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(), BackendError> {
    let app_type = EVRApplicationType::VRApplication_Overlay;
    let Ok(context) = ovr_overlay::Context::init(app_type) else {
        log::warn!("Will not use OpenVR: Context init failed");
@@ -93,6 +96,21 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
        AppState::from_graphics(graphics)?
    };

+    if show_by_default {
+        state.tasks.enqueue_at(
+            TaskType::System(SystemTask::ShowHide),
+            Instant::now().add(Duration::from_secs(1)),
+        )
+    }
+
+    if let Ok(ipd) = system_mgr.get_tracked_device_property::<f32>(
+        TrackedDeviceIndex::HMD,
+        ETrackedDeviceProperty::Prop_UserIpdMeters_Float,
+    ) {
+        state.input_state.ipd = (ipd * 10000.0).round() * 0.1;
+        log::info!("IPD: {:.1} mm", state.input_state.ipd);
+    }
+
    let _ = install_manifest(&mut app_mgr);

    let mut overlays = OverlayContainer::<OpenVrOverlayData>::new(&mut state)?;
@@ -107,8 +125,6 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
    let mut osc_sender =
        crate::backend::osc::OscSender::new(state.session.config.osc_out_port).ok();

-    state.hid_provider.set_desktop_extent(overlays.extent);
-
    set_action_manifest(&mut input_mgr)?;

    let mut input_source = OpenVrInputSource::new(&mut input_mgr)?;
@@ -158,9 +174,28 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
                }
                EVREventType::VREvent_SeatedZeroPoseReset
                | EVREventType::VREvent_StandingZeroPoseReset
-                | EVREventType::VREvent_ChaperoneUniverseHasChanged => {
+                | EVREventType::VREvent_ChaperoneUniverseHasChanged
+                | EVREventType::VREvent_SceneApplicationChanged => {
                    playspace.playspace_changed(&mut compositor_mgr, &mut chaperone_mgr);
                }
+                EVREventType::VREvent_IpdChanged => {
+                    if let Ok(ipd) = system_mgr.get_tracked_device_property::<f32>(
+                        TrackedDeviceIndex::HMD,
+                        ETrackedDeviceProperty::Prop_UserIpdMeters_Float,
+                    ) {
+                        let ipd = (ipd * 10000.0).round() * 0.1;
+                        if (ipd - state.input_state.ipd).abs() > 0.05 {
+                            log::info!("IPD: {:.1} mm -> {:.1} mm", state.input_state.ipd, ipd);
+                            Toast::new(
+                                ToastTopic::IpdChange,
+                                "IPD".into(),
+                                format!("{:.1} mm", ipd).into(),
+                            )
+                            .submit(&mut state);
+                        }
+                        state.input_state.ipd = ipd;
+                    }
+                }
                _ => {}
            }
        }
@@ -173,12 +208,20 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
        notifications.submit_pending(&mut state);

        state.tasks.retrieve_due(&mut due_tasks);
+
+        let mut removed_overlays = overlays.update(&mut state)?;
+        for o in removed_overlays.iter_mut() {
+            o.destroy(&mut overlay_mgr);
+        }
+
        while let Some(task) = due_tasks.pop_front() {
            match task {
                TaskType::Global(f) => f(&mut state),
                TaskType::Overlay(sel, f) => {
                    if let Some(o) = overlays.mut_by_selector(&sel) {
                        f(&mut state, &mut o.state);
+                    } else {
+                        log::warn!("Overlay not found for task: {:?}", sel);
                    }
                }
                TaskType::CreateOverlay(sel, f) => {
@@ -213,7 +256,10 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
                        playspace.fix_floor(&mut chaperone_mgr, &state.input_state);
                    }
                    SystemTask::ResetPlayspace => {
-                        playspace.reset_offset(&mut chaperone_mgr);
+                        playspace.reset_offset(&mut chaperone_mgr, &state.input_state);
+                    }
+                    SystemTask::ShowHide => {
+                        overlays.show_hide(&mut state);
                    }
                },
            }
@@ -236,6 +282,7 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
            .iter()
            .any(|p| p.now.show_hide && !p.before.show_hide)
        {
+            lines.mark_dirty(); // workaround to prevent lines from not showing
            overlays.show_hide(&mut state);
        }

@@ -260,6 +307,8 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
            }
        }

+        state.hid_provider.commit();
+
        lines.update(universe.clone(), &mut overlay_mgr, &mut state)?;

        for o in overlays.iter_mut() {
@@ -288,8 +337,6 @@ pub fn openvr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
        // chaperone

        // close font handles?
-
-        state.hid_provider.on_new_frame();
    }

    log::warn!("OpenVR shutdown");
@@ -1,3 +1,5 @@
+use core::f32;
+
 use glam::Vec4;
 use ovr_overlay::{
    overlay::{OverlayHandle, OverlayManager},
@@ -9,7 +11,6 @@ use vulkano::{Handle, VulkanObject};
 use crate::{
    backend::overlay::{OverlayData, RelativeTo},
    graphics::WlxGraphics,
-    overlays::watch::WATCH_NAME,
    state::AppState,
 };

@@ -21,9 +22,8 @@ pub(super) struct OpenVrOverlayData {
    pub(super) last_image: Option<u64>,
    pub(super) visible: bool,
    pub(super) color: Vec4,
-    pub(super) curvature: f32,
-    pub(super) sort_order: u32,
    pub(crate) width: f32,
+    pub(super) override_width: bool,
    pub(super) relative_to: RelativeTo,
 }

@@ -43,11 +43,6 @@ impl OverlayData<OpenVrOverlayData> {
        };
        log::debug!("{}: initialize", self.state.name);

-        //watch
-        if *self.state.name == *WATCH_NAME {
-            self.data.sort_order = 68;
-        }
-
        self.data.handle = Some(handle);
        self.data.color = Vec4::ONE;

@@ -87,6 +82,8 @@ impl OverlayData<OpenVrOverlayData> {
    ) {
        if self.data.visible {
            if self.state.dirty {
+                self.upload_curvature(overlay);
+
                self.upload_transform(universe, overlay);
                self.upload_alpha(overlay);
                self.state.dirty = false;
@@ -171,7 +168,7 @@ impl OverlayData<OpenVrOverlayData> {
            log::debug!("{}: No overlay handle", self.state.name);
            return;
        };
-        if let Err(e) = overlay.set_curvature(handle, self.data.curvature) {
+        if let Err(e) = overlay.set_curvature(handle, self.state.curvature.unwrap_or(0.0)) {
            log::error!(
                "{}: Failed to set overlay curvature: {}",
                self.state.name,
@@ -185,7 +182,7 @@ impl OverlayData<OpenVrOverlayData> {
            log::debug!("{}: No overlay handle", self.state.name);
            return;
        };
-        if let Err(e) = overlay.set_sort_order(handle, self.data.sort_order) {
+        if let Err(e) = overlay.set_sort_order(handle, self.state.z_order) {
            log::error!("{}: Failed to set overlay z order: {}", self.state.name, e);
        }
    }
@@ -233,6 +230,15 @@ impl OverlayData<OpenVrOverlayData> {
        }

        let dimensions = image.extent();
+        if !self.data.override_width {
+            let new_width = ((dimensions[0] as f32) / (dimensions[1] as f32)).min(1.0);
+            if (new_width - self.data.width).abs() > f32::EPSILON {
+                log::info!("{}: New width {}", self.state.name, new_width);
+                self.data.width = new_width;
+                self.upload_width(overlay);
+            }
+        }
+
        let format = image.format();

        let mut texture = VRVulkanTextureData_t {
@@ -247,7 +253,7 @@ impl OverlayData<OpenVrOverlayData> {
            m_pQueue: graphics.queue.handle().as_raw() as *mut _,
            m_nQueueFamilyIndex: graphics.queue.queue_family_index(),
        };
-        log::debug!(
+        log::trace!(
            "{}: UploadTex {:?}, {}x{}, {:?}",
            self.state.name,
            format,
@@ -1,8 +1,8 @@
-use glam::{Affine3A, Vec3A};
+use glam::{Affine3A, Quat, Vec3, Vec3A};
 use ovr_overlay::{
    chaperone_setup::ChaperoneSetupManager,
    compositor::CompositorManager,
-    sys::{EChaperoneConfigFile, ETrackingUniverseOrigin, HmdMatrix34_t, HmdVector3_t},
+    sys::{EChaperoneConfigFile, ETrackingUniverseOrigin, HmdMatrix34_t},
 };

 use crate::{
@@ -12,22 +12,24 @@ use crate::{

 use super::{helpers::Affine3AConvert, overlay::OpenVrOverlayData};

-struct DragData {
+struct MoverData<T> {
    pose: Affine3A,
    hand: usize,
-    hand_pos: Vec3A,
+    hand_pose: T,
 }

 pub(super) struct PlayspaceMover {
    universe: ETrackingUniverseOrigin,
-    last: Option<DragData>,
+    drag: Option<MoverData<Vec3A>>,
+    rotate: Option<MoverData<Quat>>,
 }

 impl PlayspaceMover {
    pub fn new() -> Self {
        Self {
            universe: ETrackingUniverseOrigin::TrackingUniverseRawAndUncalibrated,
-            last: None,
+            drag: None,
+            rotate: None,
        }
    }

@@ -38,10 +40,73 @@ impl PlayspaceMover {
        state: &AppState,
    ) {
        let universe = self.universe.clone();
-        if let Some(data) = self.last.as_mut() {
+
+        if let Some(data) = self.rotate.as_mut() {
+            let pointer = &state.input_state.pointers[data.hand];
+            if !pointer.now.space_rotate {
+                self.rotate = None;
+                log::info!("End space rotate");
+                return;
+            }
+
+            let new_hand =
+                Quat::from_affine3(&(data.pose * state.input_state.pointers[data.hand].raw_pose));
+
+            let dq = new_hand * data.hand_pose.conjugate();
+            let rel_y = f32::atan2(
+                2.0 * (dq.y * dq.w + dq.x * dq.z),
+                (2.0 * (dq.w * dq.w + dq.x * dq.x)) - 1.0,
+            );
+
+            let mut space_transform = Affine3A::from_rotation_y(rel_y);
+            let offset = (space_transform.transform_vector3a(state.input_state.hmd.translation)
+                - state.input_state.hmd.translation)
+                * -1.0;
+            let mut overlay_transform = Affine3A::from_rotation_y(-rel_y);
+
+            overlay_transform.translation = offset;
+            space_transform.translation = offset;
+
+            overlays.iter_mut().for_each(|overlay| {
+                if overlay.state.grabbable {
+                    overlay.state.dirty = true;
+                    overlay.state.transform.translation =
+                        overlay_transform.transform_point3a(overlay.state.transform.translation);
+                }
+            });
+
+            data.pose *= space_transform;
+            data.hand_pose = new_hand;
+
+            if self.universe == ETrackingUniverseOrigin::TrackingUniverseStanding {
+                apply_chaperone_transform(space_transform.inverse(), chaperone_mgr);
+            }
+            set_working_copy(&universe, chaperone_mgr, &data.pose);
+            chaperone_mgr.commit_working_copy(EChaperoneConfigFile::EChaperoneConfigFile_Live);
+        } else {
+            for (i, pointer) in state.input_state.pointers.iter().enumerate() {
+                if pointer.now.space_rotate {
+                    let Some(mat) = get_working_copy(&universe, chaperone_mgr) else {
+                        log::warn!("Can't space rotate - failed to get zero pose");
+                        return;
+                    };
+                    let hand_pose = Quat::from_affine3(&(mat * pointer.raw_pose));
+                    self.rotate = Some(MoverData {
+                        pose: mat,
+                        hand: i,
+                        hand_pose,
+                    });
+                    self.drag = None;
+                    log::info!("Start space rotate");
+                    return;
+                }
+            }
+        }
+
+        if let Some(data) = self.drag.as_mut() {
            let pointer = &state.input_state.pointers[data.hand];
            if !pointer.now.space_drag {
-                self.last = None;
+                self.drag = None;
                log::info!("End space drag");
                return;
            }
@@ -49,27 +114,29 @@ impl PlayspaceMover {
            let new_hand = data
                .pose
                .transform_point3a(state.input_state.pointers[data.hand].raw_pose.translation);
-            let relative_pos = new_hand - data.hand_pos;
+            let relative_pos =
+                (new_hand - data.hand_pose) * state.session.config.space_drag_multiplier;

            if relative_pos.length_squared() > 1000.0 {
                log::warn!("Space drag too fast, ignoring");
                return;
            }

-            let overlay_offset = data.pose.inverse().transform_vector3a(relative_pos);
+            let overlay_offset = data.pose.inverse().transform_vector3a(relative_pos) * -1.0;

            overlays.iter_mut().for_each(|overlay| {
                if overlay.state.grabbable {
                    overlay.state.dirty = true;
-                    overlay.state.transform.translation -= overlay_offset;
+                    overlay.state.transform.translation += overlay_offset;
                }
            });
-            chaperone_mgr.revert_working_copy();
-            apply_chaperone_offset(overlay_offset, chaperone_mgr);

            data.pose.translation += relative_pos;
-            data.hand_pos = new_hand;
+            data.hand_pose = new_hand;

+            if self.universe == ETrackingUniverseOrigin::TrackingUniverseStanding {
+                apply_chaperone_offset(overlay_offset, chaperone_mgr);
+            }
            set_working_copy(&universe, chaperone_mgr, &data.pose);
            chaperone_mgr.commit_working_copy(EChaperoneConfigFile::EChaperoneConfigFile_Live);
        } else {
@@ -80,25 +147,44 @@ impl PlayspaceMover {
                        return;
                    };
                    let hand_pos = mat.transform_point3a(pointer.raw_pose.translation);
-                    self.last = Some(DragData {
+                    self.drag = Some(MoverData {
                        pose: mat,
                        hand: i,
-                        hand_pos,
+                        hand_pose: hand_pos,
                    });
+                    self.rotate = None;
                    log::info!("Start space drag");
-                    break;
+                    return;
                }
            }
        }
    }

-    pub fn reset_offset(&mut self, chaperone_mgr: &mut ChaperoneSetupManager) {
-        set_working_copy(&self.universe, chaperone_mgr, &Affine3A::IDENTITY);
+    pub fn reset_offset(&mut self, chaperone_mgr: &mut ChaperoneSetupManager, input: &InputState) {
+        let mut height = 1.6;
+        if let Some(mat) = get_working_copy(&self.universe, chaperone_mgr) {
+            height = input.hmd.translation.y - mat.translation.y;
+            if self.universe == ETrackingUniverseOrigin::TrackingUniverseStanding {
+                apply_chaperone_transform(mat, chaperone_mgr);
+            }
+        }
+
+        let xform = if self.universe == ETrackingUniverseOrigin::TrackingUniverseSeated {
+            Affine3A::from_translation(Vec3::NEG_Y * height)
+        } else {
+            Affine3A::IDENTITY
+        };
+
+        set_working_copy(&self.universe, chaperone_mgr, &xform);
        chaperone_mgr.commit_working_copy(EChaperoneConfigFile::EChaperoneConfigFile_Live);

-        if self.last.is_some() {
+        if self.drag.is_some() {
            log::info!("Space drag interrupted by manual reset");
-            self.last = None;
+            self.drag = None;
+        }
+        if self.rotate.is_some() {
+            log::info!("Space rotate interrupted by manual reset");
+            self.rotate = None;
        }
    }

@@ -109,9 +195,20 @@ impl PlayspaceMover {
            log::warn!("Can't fix floor - failed to get zero pose");
            return;
        };
-        mat.translation.y += y1.min(y2) - 0.03;
+        let offset = y1.min(y2) - 0.03;
+        mat.translation.y += offset;
+
        set_working_copy(&self.universe, chaperone_mgr, &mat);
        chaperone_mgr.commit_working_copy(EChaperoneConfigFile::EChaperoneConfigFile_Live);
+
+        if self.drag.is_some() {
+            log::info!("Space drag interrupted by fix floor");
+            self.drag = None;
+        }
+        if self.rotate.is_some() {
+            log::info!("Space rotate interrupted by fix floor");
+            self.rotate = None;
+        }
    }

    pub fn playspace_changed(
@@ -129,9 +226,13 @@ impl PlayspaceMover {
            self.universe = new_universe;
        }

-        if self.last.is_some() {
+        if self.drag.is_some() {
            log::info!("Space drag interrupted by external change");
-            self.last = None;
+            self.drag = None;
+        }
+        if self.rotate.is_some() {
+            log::info!("Space rotate interrupted by external change");
+            self.rotate = None;
        }
    }

@@ -177,15 +278,24 @@ fn set_working_copy(
 }

 fn apply_chaperone_offset(offset: Vec3A, chaperone_mgr: &mut ChaperoneSetupManager) {
-    let mut quads = chaperone_mgr.get_working_collision_bounds_info();
+    let mut quads = chaperone_mgr.get_live_collision_bounds_info();
    quads.iter_mut().for_each(|quad| {
        quad.vCorners.iter_mut().for_each(|corner| {
            corner.v[0] += offset.x;
-            if corner.v[1] != 0.0 {
-                corner.v[1] += offset.y;
-            }
            corner.v[2] += offset.z;
        });
    });
-    chaperone_mgr.set_working_collision_bounds_info(&mut quads);
+    chaperone_mgr.set_working_collision_bounds_info(quads.as_mut_slice());
+}
+
+fn apply_chaperone_transform(transform: Affine3A, chaperone_mgr: &mut ChaperoneSetupManager) {
+    let mut quads = chaperone_mgr.get_live_collision_bounds_info();
+    quads.iter_mut().for_each(|quad| {
+        quad.vCorners.iter_mut().for_each(|corner| {
+            let coord = transform.transform_point3a(Vec3A::from_slice(&corner.v));
+            corner.v[0] = coord.x;
+            corner.v[2] = coord.z;
+        });
+    });
+    chaperone_mgr.set_working_collision_bounds_info(quads.as_mut_slice());
 }
@@ -1,12 +1,10 @@
 use anyhow::{bail, ensure};
-use glam::{Affine3A, Quat, Vec3};
+use glam::{Affine3A, Quat, Vec3, Vec3A};
 use openxr as xr;
 use xr::OverlaySessionCreateFlagsEXTX;

 pub(super) fn init_xr() -> Result<(xr::Instance, xr::SystemId), anyhow::Error> {
-    let Ok(entry) = (unsafe { xr::Entry::load() }) else {
-        bail!("OpenXR Loader not found.");
-    };
+    let entry = xr::Entry::linked();

    let Ok(available_extensions) = entry.enumerate_extensions() else {
        bail!("Failed to enumerate OpenXR extensions.");
@@ -23,6 +21,28 @@ pub(super) fn init_xr() -> Result<(xr::Instance, xr::SystemId), anyhow::Error> {
    let mut enabled_extensions = xr::ExtensionSet::default();
    enabled_extensions.khr_vulkan_enable2 = true;
    enabled_extensions.extx_overlay = true;
+    if available_extensions.khr_binding_modification && available_extensions.ext_dpad_binding {
+        enabled_extensions.khr_binding_modification = true;
+        enabled_extensions.ext_dpad_binding = true;
+    } else {
+        log::warn!("Missing EXT_dpad_binding extension.");
+    }
+    if available_extensions.ext_hp_mixed_reality_controller {
+        enabled_extensions.ext_hp_mixed_reality_controller = true;
+    } else {
+        log::warn!("Missing EXT_hp_mixed_reality_controller extension.");
+    }
+    if available_extensions.khr_composition_layer_cylinder {
+        enabled_extensions.khr_composition_layer_cylinder = true;
+    } else {
+        log::warn!("Missing EXT_composition_layer_cylinder extension.");
+    }
+
+    if available_extensions.khr_composition_layer_equirect2 {
+        enabled_extensions.khr_composition_layer_equirect2 = true;
+    } else {
+        log::warn!("Missing EXT_composition_layer_equirect2 extension.");
+    }

    //#[cfg(not(debug_assertions))]
    let layers = [];
@@ -76,6 +96,7 @@ pub(super) fn init_xr() -> Result<(xr::Instance, xr::SystemId), anyhow::Error> {

    Ok((xr_instance, system))
 }
+
 pub(super) unsafe fn create_overlay_session(
    instance: &xr::Instance,
    system: xr::SystemId,
@@ -111,42 +132,24 @@ pub(super) unsafe fn create_overlay_session(
    }
 }

-pub(super) fn hmd_pose_from_views(views: &[xr::View]) -> Affine3A {
-    let pos = {
-        let pos0: Vec3 = unsafe { std::mem::transmute(views[0].pose.position) };
-        let pos1: Vec3 = unsafe { std::mem::transmute(views[1].pose.position) };
-        (pos0 + pos1) * 0.5
-    };
-    let rot = {
-        let rot0 = unsafe { std::mem::transmute(views[0].pose.orientation) };
-        let rot1 = unsafe { std::mem::transmute(views[1].pose.orientation) };
-        quat_lerp(rot0, rot1, 0.5)
-    };
+type Vec3M = mint::Vector3<f32>;
+type QuatM = mint::Quaternion<f32>;

-    Affine3A::from_rotation_translation(rot, pos)
+pub(super) fn ipd_from_views(views: &[xr::View]) -> f32 {
+    let p0: Vec3 = Vec3M::from(views[0].pose.position).into();
+    let p1: Vec3 = Vec3M::from(views[1].pose.position).into();
+
+    (p0.distance(p1) * 1000.0).round() * 0.1
 }

-fn quat_lerp(a: Quat, mut b: Quat, t: f32) -> Quat {
-    let l2 = a.dot(b);
-    if l2 < 0.0 {
-        b = -b;
-    }
-
-    Quat::from_xyzw(
-        a.x - t * (a.x - b.x),
-        a.y - t * (a.y - b.y),
-        a.z - t * (a.z - b.z),
-        a.w - t * (a.w - b.w),
-    )
-    .normalize()
-}
-
-pub(super) fn transform_to_posef(transform: &Affine3A) -> xr::Posef {
-    let translation = transform.translation;
+pub(super) fn transform_to_norm_quat(transform: &Affine3A) -> Quat {
    let norm_mat3 = transform
        .matrix3
        .mul_scalar(1.0 / transform.matrix3.x_axis.length());
-    let mut rotation = Quat::from_mat3a(&norm_mat3).normalize();
+    Quat::from_mat3a(&norm_mat3).normalize()
+}
+
+pub(super) fn translation_rotation_to_posef(translation: Vec3A, mut rotation: Quat) -> xr::Posef {
    if !rotation.is_finite() {
        rotation = Quat::IDENTITY;
    }
@@ -165,3 +168,15 @@ pub(super) fn transform_to_posef(transform: &Affine3A) -> xr::Posef {
        },
    }
 }
+
+pub(super) fn transform_to_posef(transform: &Affine3A) -> xr::Posef {
+    let translation = transform.translation;
+    let rotation = transform_to_norm_quat(transform);
+    translation_rotation_to_posef(translation, rotation)
+}
+
+pub(super) fn posef_to_transform(pose: &xr::Posef) -> Affine3A {
+    let rotation = QuatM::from(pose.orientation).into();
+    let translation = Vec3M::from(pose.position).into();
+    Affine3A::from_rotation_translation(rotation, translation)
+}
@@ -1,38 +1,31 @@
-use std::time::{Duration, Instant};
-
-use glam::{bool, Affine3A, Quat, Vec3};
-use openxr as xr;
-
-use crate::{
-    backend::input::{Haptics, Pointer},
-    state::AppState,
+use std::{
+    array::from_fn,
+    mem::transmute,
+    time::{Duration, Instant},
 };

-use super::XrState;
+use glam::{bool, Affine3A, Quat, Vec3};
+use libmonado_rs::{Device, Monado};
+use openxr::{self as xr, Quaternionf, Vector3f};
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    backend::input::{Haptics, Pointer, TrackedDevice, TrackedDeviceRole},
+    config_io,
+    state::{AppSession, AppState},
+};
+
+use super::{helpers::posef_to_transform, XrState};

 type XrSession = xr::Session<xr::Vulkan>;
-static DOUBLE_CLICK_TIME: Duration = Duration::from_millis(500);

-pub(super) struct DoubleClickCounter {
-    pub(super) last_click: Option<Instant>,
-}
+static CLICK_TIMES: [Duration; 3] = [
+    Duration::ZERO,
+    Duration::from_millis(500),
+    Duration::from_millis(750),
+];

-impl DoubleClickCounter {
-    pub(super) fn new() -> Self {
-        Self { last_click: None }
-    }
-
-    // submit a click. returns true if it should count as a double click
-    pub(super) fn click(&mut self) -> bool {
-        let now = Instant::now();
-        let double_click = match self.last_click {
-            Some(last_click) => now - last_click < DOUBLE_CLICK_TIME,
-            None => false,
-        };
-        self.last_click = if double_click { None } else { Some(now) };
-        double_click
-    }
-}
+pub(super) struct OpenXrAction {}

 pub(super) struct OpenXrInputSource {
    action_set: xr::ActionSet,
@@ -44,20 +37,135 @@ pub(super) struct OpenXrHand {
    space: xr::Space,
 }

+pub struct MultiClickHandler<const COUNT: usize> {
+    name: String,
+    action_f32: xr::Action<f32>,
+    action_bool: xr::Action<bool>,
+    previous: [Instant; COUNT],
+    held_active: bool,
+    held_inactive: bool,
+}
+
+impl<const COUNT: usize> MultiClickHandler<COUNT> {
+    fn new(action_set: &xr::ActionSet, action_name: &str, side: &str) -> anyhow::Result<Self> {
+        let name = format!("{}_{}-{}", side, COUNT, action_name);
+        let name_f32 = format!("{}_value", &name);
+
+        let action_bool = action_set.create_action::<bool>(&name, &name, &[])?;
+        let action_f32 = action_set.create_action::<f32>(&name_f32, &name_f32, &[])?;
+
+        Ok(Self {
+            name,
+            action_f32,
+            action_bool,
+            previous: from_fn(|_| Instant::now()),
+            held_active: false,
+            held_inactive: false,
+        })
+    }
+    fn check<G>(&mut self, session: &xr::Session<G>, threshold: f32) -> anyhow::Result<bool> {
+        let res = self.action_bool.state(session, xr::Path::NULL)?;
+        let mut state = res.is_active && res.current_state;
+
+        if !state {
+            let res = self.action_f32.state(session, xr::Path::NULL)?;
+            state = res.is_active && res.current_state > threshold;
+        }
+
+        if !state {
+            self.held_active = false;
+            self.held_inactive = false;
+            return Ok(false);
+        }
+
+        if self.held_active {
+            return Ok(true);
+        }
+
+        if self.held_inactive {
+            return Ok(false);
+        }
+
+        let passed = self
+            .previous
+            .iter()
+            .all(|instant| instant.elapsed() < CLICK_TIMES[COUNT]);
+
+        if passed {
+            log::trace!("{}: passed", self.name);
+            self.held_active = true;
+            self.held_inactive = false;
+
+            // reset to no prior clicks
+            let long_ago = Instant::now() - Duration::from_secs(10);
+            self.previous
+                .iter_mut()
+                .for_each(|instant| *instant = long_ago)
+        } else if COUNT > 0 {
+            log::trace!("{}: rotate", self.name);
+            self.previous.rotate_right(1);
+            self.previous[0] = Instant::now();
+            self.held_inactive = true;
+        }
+
+        Ok(passed)
+    }
+}
+
+pub struct CustomClickAction {
+    single: MultiClickHandler<0>,
+    double: MultiClickHandler<1>,
+    triple: MultiClickHandler<2>,
+}
+
+impl CustomClickAction {
+    pub fn new(action_set: &xr::ActionSet, name: &str, side: &str) -> anyhow::Result<Self> {
+        let single = MultiClickHandler::new(action_set, name, side)?;
+        let double = MultiClickHandler::new(action_set, name, side)?;
+        let triple = MultiClickHandler::new(action_set, name, side)?;
+
+        Ok(Self {
+            single,
+            double,
+            triple,
+        })
+    }
+    pub fn state(
+        &mut self,
+        before: bool,
+        state: &XrState,
+        session: &AppSession,
+    ) -> anyhow::Result<bool> {
+        let threshold = if before {
+            session.config.xr_click_sensitivity_release
+        } else {
+            session.config.xr_click_sensitivity
+        };
+
+        Ok(self.single.check(&state.session, threshold)?
+            || self.double.check(&state.session, threshold)?
+            || self.triple.check(&state.session, threshold)?)
+    }
+}
+
 pub(super) struct OpenXrHandSource {
    action_pose: xr::Action<xr::Posef>,
-    action_click: xr::Action<f32>,
-    action_grab: xr::Action<f32>,
+    action_click: CustomClickAction,
+    action_grab: CustomClickAction,
+    action_alt_click: CustomClickAction,
+    action_show_hide: CustomClickAction,
+    action_space_drag: CustomClickAction,
+    action_space_rotate: CustomClickAction,
+    action_space_reset: CustomClickAction,
+    action_modifier_right: CustomClickAction,
+    action_modifier_middle: CustomClickAction,
+    action_move_mouse: CustomClickAction,
    action_scroll: xr::Action<f32>,
-    action_alt_click: xr::Action<f32>,
-    action_show_hide: xr::Action<bool>,
-    action_click_modifier_right: xr::Action<bool>,
-    action_click_modifier_middle: xr::Action<bool>,
    action_haptics: xr::Action<xr::Haptic>,
 }

 impl OpenXrInputSource {
-    pub fn new(xr: &XrState) -> Result<Self, xr::sys::Result> {
+    pub fn new(xr: &XrState) -> anyhow::Result<Self> {
        let mut action_set =
            xr.session
                .instance()
@@ -94,19 +202,96 @@ impl OpenXrInputSource {
        );
    }

-    pub fn update(&self, xr: &XrState, state: &mut AppState) -> Result<(), xr::sys::Result> {
+    pub fn update(&mut self, xr: &XrState, state: &mut AppState) -> anyhow::Result<()> {
        xr.session.sync_actions(&[(&self.action_set).into()])?;

+        let loc = xr.view.locate(&xr.stage, xr.predicted_display_time)?;
+        let hmd = posef_to_transform(&loc.pose);
+        if loc
+            .location_flags
+            .contains(xr::SpaceLocationFlags::ORIENTATION_VALID)
+        {
+            state.input_state.hmd.matrix3 = hmd.matrix3;
+        }
+
+        if loc
+            .location_flags
+            .contains(xr::SpaceLocationFlags::POSITION_VALID)
+        {
+            state.input_state.hmd.translation = hmd.translation;
+        }
+
        for i in 0..2 {
-            self.hands[i].update(
-                &mut state.input_state.pointers[i],
-                &xr.stage,
-                &xr.session,
-                xr.predicted_display_time,
-            )?;
+            self.hands[i].update(&mut state.input_state.pointers[i], xr, &state.session)?;
        }
        Ok(())
    }
+
+    fn update_device_battery_status(
+        device: &mut Device,
+        role: TrackedDeviceRole,
+        app: &mut AppState,
+    ) {
+        if let Ok(status) = device.battery_status() {
+            if status.present {
+                app.input_state.devices.push(TrackedDevice {
+                    soc: Some(status.charge),
+                    charging: status.charging,
+                    role,
+                });
+                log::debug!(
+                    "Device {} role {:#?}: {:.0}% (charging {})",
+                    device.index,
+                    role,
+                    status.charge * 100.0f32,
+                    status.charging
+                );
+            }
+        }
+    }
+
+    pub fn update_devices(&mut self, app: &mut AppState, monado: &mut Monado) {
+        app.input_state.devices.clear();
+
+        let roles = [
+            ("head", TrackedDeviceRole::Hmd),
+            ("eyes", TrackedDeviceRole::None),
+            ("left", TrackedDeviceRole::LeftHand),
+            ("right", TrackedDeviceRole::RightHand),
+            ("gamepad", TrackedDeviceRole::None),
+            ("hand-tracking-left", TrackedDeviceRole::LeftHand),
+            ("hand-tracking-right", TrackedDeviceRole::RightHand),
+        ];
+        let mut seen = Vec::<u32>::with_capacity(32);
+        for (mnd_role, wlx_role) in roles {
+            let device = monado.device_from_role(mnd_role);
+            if let Ok(mut device) = device {
+                if !seen.contains(&device.index) {
+                    seen.push(device.index);
+                    Self::update_device_battery_status(&mut device, wlx_role, app);
+                }
+            }
+        }
+        if let Ok(devices) = monado.devices() {
+            for mut device in devices {
+                if !seen.contains(&device.index) {
+                    let role = if device.id >= 4 && device.id <= 8 {
+                        TrackedDeviceRole::Tracker
+                    } else {
+                        TrackedDeviceRole::None
+                    };
+                    Self::update_device_battery_status(&mut device, role, app);
+                }
+            }
+        }
+
+        app.input_state.devices.sort_by(|a, b| {
+            (a.soc.is_none() as u8)
+                .cmp(&(b.soc.is_none() as u8))
+                .then((a.role as u8).cmp(&(b.role as u8)))
+                .then(a.soc.unwrap_or(999.).total_cmp(&b.soc.unwrap_or(999.)))
+        });
+    }
 }

 impl OpenXrHand {
@@ -121,66 +306,90 @@ impl OpenXrHand {
    }

    pub(super) fn update(
-        &self,
+        &mut self,
        pointer: &mut Pointer,
-        stage: &xr::Space,
-        session: &XrSession,
-        time: xr::Time,
-    ) -> Result<(), xr::sys::Result> {
-        let location = self.space.locate(stage, time)?;
+        xr: &XrState,
+        session: &AppSession,
+    ) -> anyhow::Result<()> {
+        let location = self.space.locate(&xr.stage, xr.predicted_display_time)?;
        if location
            .location_flags
            .contains(xr::SpaceLocationFlags::ORIENTATION_VALID)
        {
-            let quat = unsafe { std::mem::transmute::<_, Quat>(location.pose.orientation) };
-            let pos = unsafe { std::mem::transmute::<_, Vec3>(location.pose.position) };
-            pointer.pose = Affine3A::from_rotation_translation(quat, pos);
+            let (cur_quat, cur_pos) = (Quat::from_affine3(&pointer.pose), pointer.pose.translation);
+
+            let (new_quat, new_pos) = unsafe {
+                (
+                    transmute::<Quaternionf, Quat>(location.pose.orientation),
+                    transmute::<Vector3f, Vec3>(location.pose.position),
+                )
+            };
+            let lerp_factor =
+                (1.0 / (xr.fps / 100.0) * session.config.pointer_lerp_factor).clamp(0.1, 1.0);
+            pointer.raw_pose = Affine3A::from_rotation_translation(new_quat, new_pos);
+            pointer.pose = Affine3A::from_rotation_translation(
+                cur_quat.lerp(new_quat, lerp_factor),
+                cur_pos.lerp(new_pos.into(), lerp_factor).into(),
+            );
        }

        pointer.now.click = self
            .source
            .action_click
-            .state(session, xr::Path::NULL)?
-            .current_state
-            > 0.7;
+            .state(pointer.before.click, xr, session)?;

        pointer.now.grab = self
            .source
            .action_grab
-            .state(session, xr::Path::NULL)?
-            .current_state
-            > 0.7;
+            .state(pointer.before.grab, xr, session)?;

        pointer.now.scroll = self
            .source
            .action_scroll
-            .state(session, xr::Path::NULL)?
+            .state(&xr.session, xr::Path::NULL)?
            .current_state;

-        pointer.now.alt_click = self
-            .source
-            .action_alt_click
-            .state(session, xr::Path::NULL)?
-            .current_state
-            > 0.7;
+        pointer.now.alt_click =
+            self.source
+                .action_alt_click
+                .state(pointer.before.alt_click, xr, session)?;

-        pointer.now.show_hide = self
-            .source
-            .action_show_hide
-            .state(session, xr::Path::NULL)?
-            .current_state;
+        pointer.now.show_hide =
+            self.source
+                .action_show_hide
+                .state(pointer.before.show_hide, xr, session)?;

-        pointer.now.click_modifier_right = self
-            .source
-            .action_click_modifier_right
-            .state(session, xr::Path::NULL)?
-            .current_state;
+        pointer.now.click_modifier_right = self.source.action_modifier_right.state(
+            pointer.before.click_modifier_right,
+            xr,
+            session,
+        )?;

-        pointer.now.click_modifier_middle = self
-            .source
-            .action_click_modifier_middle
-            .state(session, xr::Path::NULL)?
-            .current_state;
+        pointer.now.click_modifier_middle = self.source.action_modifier_middle.state(
+            pointer.before.click_modifier_middle,
+            xr,
+            session,
+        )?;
+
+        pointer.now.move_mouse =
+            self.source
+                .action_move_mouse
+                .state(pointer.before.move_mouse, xr, session)?;
+
+        pointer.now.space_drag =
+            self.source
+                .action_space_drag
+                .state(pointer.before.space_drag, xr, session)?;
+
+        pointer.now.space_rotate =
+            self.source
+                .action_space_rotate
+                .state(pointer.before.space_rotate, xr, session)?;
+
+        pointer.now.space_reset =
+            self.source
+                .action_space_reset
+                .state(pointer.before.space_reset, xr, session)?;

        Ok(())
    }
@@ -188,48 +397,18 @@ impl OpenXrHand {

 // supported action types: Haptic, Posef, Vector2f, f32, bool
 impl OpenXrHandSource {
-    pub(super) fn new(action_set: &mut xr::ActionSet, side: &str) -> Result<Self, xr::sys::Result> {
+    pub(super) fn new(action_set: &mut xr::ActionSet, side: &str) -> anyhow::Result<Self> {
        let action_pose = action_set.create_action::<xr::Posef>(
            &format!("{}_hand", side),
            &format!("{} hand pose", side),
            &[],
        )?;

-        let action_click = action_set.create_action::<f32>(
-            &format!("{}_click", side),
-            &format!("{} hand click", side),
-            &[],
-        )?;
-        let action_grab = action_set.create_action::<f32>(
-            &format!("{}_grab", side),
-            &format!("{} hand grab", side),
-            &[],
-        )?;
        let action_scroll = action_set.create_action::<f32>(
            &format!("{}_scroll", side),
            &format!("{} hand scroll", side),
            &[],
        )?;
-        let action_alt_click = action_set.create_action::<f32>(
-            &format!("{}_alt_click", side),
-            &format!("{} hand alt click", side),
-            &[],
-        )?;
-        let action_show_hide = action_set.create_action::<bool>(
-            &format!("{}_show_hide", side),
-            &format!("{} hand show/hide", side),
-            &[],
-        )?;
-        let action_click_modifier_right = action_set.create_action::<bool>(
-            &format!("{}_click_modifier_right", side),
-            &format!("{} hand right click modifier", side),
-            &[],
-        )?;
-        let action_click_modifier_middle = action_set.create_action::<bool>(
-            &format!("{}_click_modifier_middle", side),
-            &format!("{} hand middle click modifier", side),
-            &[],
-        )?;
        let action_haptics = action_set.create_action::<xr::Haptic>(
            &format!("{}_haptics", side),
            &format!("{} hand haptics", side),
@@ -238,247 +417,276 @@ impl OpenXrHandSource {

        Ok(Self {
            action_pose,
-            action_click,
-            action_grab,
+            action_click: CustomClickAction::new(action_set, "click", side)?,
+            action_grab: CustomClickAction::new(action_set, "grab", side)?,
            action_scroll,
-            action_alt_click,
-            action_show_hide,
-            action_click_modifier_right,
-            action_click_modifier_middle,
+            action_alt_click: CustomClickAction::new(action_set, "alt_click", side)?,
+            action_show_hide: CustomClickAction::new(action_set, "show_hide", side)?,
+            action_space_drag: CustomClickAction::new(action_set, "space_drag", side)?,
+            action_space_rotate: CustomClickAction::new(action_set, "space_rotate", side)?,
+            action_space_reset: CustomClickAction::new(action_set, "space_reset", side)?,
+            action_modifier_right: CustomClickAction::new(
+                action_set,
+                "click_modifier_right",
+                side,
+            )?,
+            action_modifier_middle: CustomClickAction::new(
+                action_set,
+                "click_modifier_middle",
+                side,
+            )?,
+            action_move_mouse: CustomClickAction::new(action_set, "move_mouse", side)?,
            action_haptics,
        })
    }
 }

-fn suggest_bindings(
-    instance: &xr::Instance,
-    hands: &[&OpenXrHandSource; 2],
-) -> Result<(), xr::sys::Result> {
-    let path = instance.string_to_path("/interaction_profiles/khr/simple_controller")?;
+fn to_path(maybe_path_str: &Option<String>, instance: &xr::Instance) -> Option<xr::Path> {
+    maybe_path_str
+        .as_ref()
+        .and_then(|s| match instance.string_to_path(s) {
+            Ok(path) => Some(path),
+            Err(_) => {
+                log::warn!("Invalid binding path: {}", s);
+                None
+            }
+        })
+}

-    // not fully functional, but helpful for debugging
-    instance.suggest_interaction_profile_bindings(
-        path,
-        &[
-            xr::Binding::new(
-                &hands[0].action_pose,
-                instance.string_to_path("/user/hand/left/input/aim/pose")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_pose,
-                instance.string_to_path("/user/hand/right/input/aim/pose")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_click,
-                instance.string_to_path("/user/hand/left/input/select/click")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_click,
-                instance.string_to_path("/user/hand/right/input/select/click")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_show_hide,
-                instance.string_to_path("/user/hand/left/input/menu/click")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_haptics,
-                instance.string_to_path("/user/hand/left/output/haptic")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_haptics,
-                instance.string_to_path("/user/hand/right/output/haptic")?,
-            ),
-        ],
-    )?;
+fn is_bool(maybe_type_str: &Option<String>) -> bool {
+    maybe_type_str
+        .as_ref()
+        .unwrap() // want panic
+        .split('/')
+        .last()
+        .map(|last| matches!(last, "click" | "touch"))
+        .unwrap_or(false)
+}

-    let path = instance.string_to_path("/interaction_profiles/oculus/touch_controller")?;
-    instance.suggest_interaction_profile_bindings(
-        path,
-        &[
-            xr::Binding::new(
-                &hands[0].action_pose,
-                instance.string_to_path("/user/hand/left/input/aim/pose")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_pose,
-                instance.string_to_path("/user/hand/right/input/aim/pose")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_click,
-                instance.string_to_path("/user/hand/left/input/trigger/value")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_click,
-                instance.string_to_path("/user/hand/right/input/trigger/value")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_grab,
-                instance.string_to_path("/user/hand/left/input/squeeze/value")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_grab,
-                instance.string_to_path("/user/hand/right/input/squeeze/value")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_scroll,
-                instance.string_to_path("/user/hand/left/input/thumbstick/y")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_scroll,
-                instance.string_to_path("/user/hand/right/input/thumbstick/y")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_show_hide,
-                instance.string_to_path("/user/hand/left/input/y/click")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_click_modifier_right,
-                instance.string_to_path("/user/hand/left/input/y/touch")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_click_modifier_right,
-                instance.string_to_path("/user/hand/right/input/b/touch")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_click_modifier_middle,
-                instance.string_to_path("/user/hand/left/input/x/touch")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_click_modifier_middle,
-                instance.string_to_path("/user/hand/right/input/a/touch")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_haptics,
-                instance.string_to_path("/user/hand/left/output/haptic")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_haptics,
-                instance.string_to_path("/user/hand/right/output/haptic")?,
-            ),
-        ],
-    )?;
+macro_rules! add_custom {
+    ($action:expr, $left:expr, $right:expr, $bindings:expr, $instance:expr) => {
+        if let Some(action) = $action.as_ref() {
+            if let Some(p) = to_path(&action.left, $instance) {
+                if is_bool(&action.left) {
+                    if action.triple_click.unwrap_or(false) {
+                        $bindings.push(xr::Binding::new(&$left.triple.action_bool, p));
+                    } else if action.double_click.unwrap_or(false) {
+                        $bindings.push(xr::Binding::new(&$left.double.action_bool, p));
+                    } else {
+                        $bindings.push(xr::Binding::new(&$left.single.action_bool, p));
+                    }
+                } else {
+                    if action.triple_click.unwrap_or(false) {
+                        $bindings.push(xr::Binding::new(&$left.triple.action_f32, p));
+                    } else if action.double_click.unwrap_or(false) {
+                        $bindings.push(xr::Binding::new(&$left.double.action_f32, p));
+                    } else {
+                        $bindings.push(xr::Binding::new(&$left.single.action_f32, p));
+                    }
+                }
+            }
+            if let Some(p) = to_path(&action.right, $instance) {
+                if is_bool(&action.right) {
+                    if action.triple_click.unwrap_or(false) {
+                        $bindings.push(xr::Binding::new(&$right.triple.action_bool, p));
+                    } else if action.double_click.unwrap_or(false) {
+                        $bindings.push(xr::Binding::new(&$right.double.action_bool, p));
+                    } else {
+                        $bindings.push(xr::Binding::new(&$right.single.action_bool, p));
+                    }
+                } else {
+                    if action.triple_click.unwrap_or(false) {
+                        $bindings.push(xr::Binding::new(&$right.triple.action_f32, p));
+                    } else if action.double_click.unwrap_or(false) {
+                        $bindings.push(xr::Binding::new(&$right.double.action_f32, p));
+                    } else {
+                        $bindings.push(xr::Binding::new(&$right.single.action_f32, p));
+                    }
+                }
+            }
+        }
+    };
+}

-    let path = instance.string_to_path("/interaction_profiles/valve/index_controller")?;
-    instance.suggest_interaction_profile_bindings(
-        path,
-        &[
-            xr::Binding::new(
-                &hands[0].action_pose,
-                instance.string_to_path("/user/hand/left/input/aim/pose")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_pose,
-                instance.string_to_path("/user/hand/right/input/aim/pose")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_click,
-                instance.string_to_path("/user/hand/left/input/trigger/value")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_click,
-                instance.string_to_path("/user/hand/right/input/trigger/value")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_grab,
-                instance.string_to_path("/user/hand/left/input/squeeze/value")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_grab,
-                instance.string_to_path("/user/hand/right/input/squeeze/value")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_scroll,
-                instance.string_to_path("/user/hand/left/input/thumbstick/y")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_scroll,
-                instance.string_to_path("/user/hand/right/input/thumbstick/y")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_alt_click,
-                instance.string_to_path("/user/hand/left/input/trackpad/force")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_alt_click,
-                instance.string_to_path("/user/hand/right/input/trackpad/force")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_show_hide,
-                instance.string_to_path("/user/hand/left/input/b/click")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_click_modifier_right,
-                instance.string_to_path("/user/hand/left/input/b/touch")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_click_modifier_right,
-                instance.string_to_path("/user/hand/right/input/b/touch")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_click_modifier_middle,
-                instance.string_to_path("/user/hand/left/input/a/touch")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_click_modifier_middle,
-                instance.string_to_path("/user/hand/right/input/a/touch")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_haptics,
-                instance.string_to_path("/user/hand/left/output/haptic")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_haptics,
-                instance.string_to_path("/user/hand/right/output/haptic")?,
-            ),
-        ],
-    )?;
+fn suggest_bindings(instance: &xr::Instance, hands: &[&OpenXrHandSource; 2]) -> anyhow::Result<()> {
+    let profiles = load_action_profiles()?;

-    let path = instance.string_to_path("/interaction_profiles/htc/vive_controller")?;
-    instance.suggest_interaction_profile_bindings(
-        path,
-        &[
-            xr::Binding::new(
-                &hands[0].action_pose,
-                instance.string_to_path("/user/hand/left/input/aim/pose")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_pose,
-                instance.string_to_path("/user/hand/right/input/aim/pose")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_click,
-                instance.string_to_path("/user/hand/right/input/trigger/value")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_grab,
-                instance.string_to_path("/user/hand/left/input/squeeze/click")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_grab,
-                instance.string_to_path("/user/hand/right/input/squeeze/click")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_scroll,
-                instance.string_to_path("/user/hand/left/input/trackpad/y")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_scroll,
-                instance.string_to_path("/user/hand/right/input/trackpad/y")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_show_hide,
-                instance.string_to_path("/user/hand/left/input/menu/click")?,
-            ),
-            xr::Binding::new(
-                &hands[0].action_haptics,
-                instance.string_to_path("/user/hand/left/output/haptic")?,
-            ),
-            xr::Binding::new(
-                &hands[1].action_haptics,
-                instance.string_to_path("/user/hand/right/output/haptic")?,
-            ),
-        ],
-    )?;
+    for profile in profiles {
+        let Ok(profile_path) = instance.string_to_path(&profile.profile) else {
+            log::debug!("Profile not supported: {}", profile.profile);
+            continue;
+        };
+
+        let mut bindings: Vec<xr::Binding> = vec![];
+
+        if let Some(action) = profile.pose {
+            if let Some(p) = to_path(&action.left, instance) {
+                bindings.push(xr::Binding::new(&hands[0].action_pose, p));
+            }
+            if let Some(p) = to_path(&action.right, instance) {
+                bindings.push(xr::Binding::new(&hands[1].action_pose, p));
+            }
+        }
+
+        if let Some(action) = profile.haptic {
+            if let Some(p) = to_path(&action.left, instance) {
+                bindings.push(xr::Binding::new(&hands[0].action_haptics, p));
+            }
+            if let Some(p) = to_path(&action.right, instance) {
+                bindings.push(xr::Binding::new(&hands[1].action_haptics, p));
+            }
+        }
+
+        if let Some(action) = profile.scroll {
+            if let Some(p) = to_path(&action.left, instance) {
+                bindings.push(xr::Binding::new(&hands[0].action_scroll, p));
+            }
+            if let Some(p) = to_path(&action.right, instance) {
+                bindings.push(xr::Binding::new(&hands[1].action_scroll, p));
+            }
+        }
+
+        add_custom!(
+            profile.click,
+            hands[0].action_click,
+            hands[1].action_click,
+            bindings,
+            instance
+        );
+
+        add_custom!(
+            profile.alt_click,
+            &hands[0].action_alt_click,
+            &hands[1].action_alt_click,
+            bindings,
+            instance
+        );
+
+        add_custom!(
+            profile.grab,
+            &hands[0].action_grab,
+            &hands[1].action_grab,
+            bindings,
+            instance
+        );
+
+        add_custom!(
+            profile.show_hide,
+            &hands[0].action_show_hide,
+            &hands[1].action_show_hide,
+            bindings,
+            instance
+        );
+
+        add_custom!(
+            profile.space_drag,
+            &hands[0].action_space_drag,
+            &hands[1].action_space_drag,
+            bindings,
+            instance
+        );
+
+        add_custom!(
+            profile.space_rotate,
+            &hands[0].action_space_rotate,
+            &hands[1].action_space_rotate,
+            bindings,
+            instance
+        );
+
+        add_custom!(
+            profile.space_reset,
+            &hands[0].action_space_reset,
+            &hands[1].action_space_reset,
+            bindings,
+            instance
+        );
+
+        add_custom!(
+            profile.click_modifier_right,
+            &hands[0].action_modifier_right,
+            &hands[1].action_modifier_right,
+            bindings,
+            instance
+        );
+
+        add_custom!(
+            profile.click_modifier_middle,
+            &hands[0].action_modifier_middle,
+            &hands[1].action_modifier_middle,
+            bindings,
+            instance
+        );
+
+        add_custom!(
+            profile.move_mouse,
+            &hands[0].action_move_mouse,
+            &hands[1].action_move_mouse,
+            bindings,
+            instance
+        );
+
+        if instance
+            .suggest_interaction_profile_bindings(profile_path, &bindings)
+            .is_err()
+        {
+            log::error!("Bad bindings for {}", &profile.profile[22..]);
+            log::error!("Verify config: ~/.config/wlxoverlay/openxr_actions.json5");
+        }
+    }

    Ok(())
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct OpenXrActionConfAction {
+    left: Option<String>,
+    right: Option<String>,
+    threshold: Option<[f32; 2]>,
+    double_click: Option<bool>,
+    triple_click: Option<bool>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct OpenXrActionConfProfile {
+    profile: String,
+    pose: Option<OpenXrActionConfAction>,
+    click: Option<OpenXrActionConfAction>,
+    grab: Option<OpenXrActionConfAction>,
+    alt_click: Option<OpenXrActionConfAction>,
+    show_hide: Option<OpenXrActionConfAction>,
+    space_drag: Option<OpenXrActionConfAction>,
+    space_rotate: Option<OpenXrActionConfAction>,
+    space_reset: Option<OpenXrActionConfAction>,
+    click_modifier_right: Option<OpenXrActionConfAction>,
+    click_modifier_middle: Option<OpenXrActionConfAction>,
+    move_mouse: Option<OpenXrActionConfAction>,
+    scroll: Option<OpenXrActionConfAction>,
+    haptic: Option<OpenXrActionConfAction>,
+}
+
+const DEFAULT_PROFILES: &str = include_str!("openxr_actions.json5");
+
+fn load_action_profiles() -> anyhow::Result<Vec<OpenXrActionConfProfile>> {
+    let mut profiles: Vec<OpenXrActionConfProfile> =
+        serde_json5::from_str(DEFAULT_PROFILES).unwrap(); // want panic
+
+    let Some(conf) = config_io::load("openxr_actions.json5") else {
+        return Ok(profiles);
+    };
+
+    match serde_json5::from_str::<Vec<OpenXrActionConfProfile>>(&conf) {
+        Ok(override_profiles) => {
+            override_profiles.into_iter().for_each(|new| {
+                if let Some(i) = profiles.iter().position(|old| old.profile == new.profile) {
+                    profiles[i] = new;
+                }
+            });
+        }
+        Err(e) => {
+            log::error!("Failed to load openxr_actions.json5: {}", e);
+        }
+    }
+
+    Ok(profiles)
+}
@@ -7,7 +7,6 @@ use std::{
        atomic::{AtomicUsize, Ordering},
        Arc,
    },
-    usize,
 };

 use vulkano::{command_buffer::CommandBufferUsage, format::Format, image::view::ImageView};
@@ -18,8 +17,8 @@ use crate::{
 };

 use super::{
-    swapchain::{create_swapchain_render_data, SwapchainRenderData},
-    XrState,
+    swapchain::{create_swapchain_render_data, SwapchainOpts, SwapchainRenderData},
+    CompositionLayer, XrState,
 };

 static AUTO_INCREMENT: AtomicUsize = AtomicUsize::new(1);
@@ -47,7 +46,7 @@ impl LinePool {
        let views: anyhow::Result<Vec<Arc<ImageView>>> = colors
            .into_iter()
            .map(
-                |color| match command_buffer.texture2d(1, 1, Format::R8G8B8A8_UNORM, &color) {
+                |color| match command_buffer.texture2d_raw(1, 1, Format::R8G8B8A8_UNORM, &color) {
                    Ok(tex) => ImageView::new_default(tex).map_err(|e| anyhow::anyhow!(e)),
                    Err(e) => Err(e),
                },
@@ -69,7 +68,8 @@ impl LinePool {
    ) -> anyhow::Result<usize> {
        let id = AUTO_INCREMENT.fetch_add(1, Ordering::Relaxed);

-        let srd = create_swapchain_render_data(xr, graphics, [1, 1, 1])?;
+        let srd =
+            create_swapchain_render_data(xr, graphics, [1, 1, 1], SwapchainOpts::new().srgb())?;
        self.lines.insert(
            id,
            LineContainer {
@@ -135,7 +135,7 @@ impl LinePool {
        &'a mut self,
        xr: &'a XrState,
        command_buffer: &mut WlxCommandBuffer,
-    ) -> anyhow::Result<Vec<xr::CompositionLayerQuad<xr::Vulkan>>> {
+    ) -> anyhow::Result<Vec<CompositionLayer>> {
        let mut quads = Vec::new();

        for line in self.lines.values_mut() {
@@ -148,14 +148,13 @@ impl LinePool {
                        1.0,
                    )?)
                    .eye_visibility(xr::EyeVisibility::BOTH)
-                    .layer_flags(xr::CompositionLayerFlags::CORRECT_CHROMATIC_ABERRATION)
                    .space(&xr.stage)
                    .size(xr::Extent2Df {
                        width: LINE_WIDTH,
                        height: inner.length,
                    });

-                quads.push(quad);
+                quads.push(CompositionLayer::Quad(quad));
            }
        }

@@ -1,35 +1,42 @@
 use std::{
    collections::VecDeque,
+    ops::Add,
    sync::{
        atomic::{AtomicBool, AtomicUsize, Ordering},
        Arc,
    },
-    time::Duration,
+    time::{Duration, Instant},
 };

 use glam::{Affine3A, Vec3};
+use libmonado_rs::Monado;
 use openxr as xr;
+use skybox::create_skybox;
 use vulkano::{command_buffer::CommandBufferUsage, Handle, VulkanObject};

 use crate::{
    backend::{
-        common::{OverlayContainer, TaskType},
+        common::{BackendError, OverlayContainer},
        input::interact,
        notifications::NotificationManager,
-        openxr::{input::DoubleClickCounter, lines::LinePool, overlay::OpenXrOverlayData},
+        openxr::{lines::LinePool, overlay::OpenXrOverlayData},
        overlay::OverlayData,
+        task::{SystemTask, TaskType},
    },
    graphics::WlxGraphics,
-    overlays::watch::{watch_fade, WATCH_NAME},
+    overlays::{
+        toast::{Toast, ToastTopic},
+        watch::{watch_fade, WATCH_NAME},
+    },
    state::AppState,
 };

-use super::common::BackendError;
-
 mod helpers;
 mod input;
 mod lines;
 mod overlay;
+mod playspace;
+mod skybox;
 mod swapchain;

 const VIEW_TYPE: xr::ViewConfigurationType = xr::ViewConfigurationType::PRIMARY_STEREO;
@@ -41,10 +48,13 @@ struct XrState {
    system: xr::SystemId,
    session: xr::Session<xr::Vulkan>,
    predicted_display_time: xr::Time,
+    fps: f32,
    stage: Arc<xr::Space>,
+    view: Arc<xr::Space>,
+    stage_offset: Affine3A,
 }

-pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
+pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(), BackendError> {
    let (xr_instance, system) = match helpers::init_xr() {
        Ok((xr_instance, system)) => (xr_instance, system),
        Err(e) => {
@@ -62,6 +72,13 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
        AppState::from_graphics(graphics)?
    };

+    if show_by_default {
+        app_state.tasks.enqueue_at(
+            TaskType::System(SystemTask::ShowHide),
+            Instant::now().add(Duration::from_secs(1)),
+        )
+    }
+
    let mut overlays = OverlayContainer::<OpenXrOverlayData>::new(&mut app_state)?;
    let mut lines = LinePool::new(app_state.graphics.clone())?;

@@ -71,12 +88,20 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {

    let mut delete_queue = vec![];

+    let mut monado = Monado::auto_connect()
+        .map_err(|e| log::warn!("Will not use libmonado: {}", e))
+        .ok();
+
+    let mut playspace = monado.as_mut().and_then(|m| {
+        playspace::PlayspaceMover::new(m)
+            .map_err(|e| log::warn!("Will not use Monado playspace mover: {}", e))
+            .ok()
+    });
+
    #[cfg(feature = "osc")]
    let mut osc_sender =
        crate::backend::osc::OscSender::new(app_state.session.config.osc_out_port).ok();

-    app_state.hid_provider.set_desktop_extent(overlays.extent);
-
    let (session, mut frame_wait, mut frame_stream) = unsafe {
        let raw_session = helpers::create_overlay_session(
            &xr_instance,
@@ -100,14 +125,21 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
    let stage =
        session.create_reference_space(xr::ReferenceSpaceType::STAGE, xr::Posef::IDENTITY)?;

+    let view = session.create_reference_space(xr::ReferenceSpaceType::VIEW, xr::Posef::IDENTITY)?;
+
    let mut xr_state = XrState {
        instance: xr_instance,
        system,
        session,
        predicted_display_time: xr::Time::from_nanos(0),
+        fps: 30.0,
        stage: Arc::new(stage),
+        view: Arc::new(view),
+        stage_offset: Affine3A::IDENTITY,
    };

+    let mut skybox = create_skybox(&xr_state, &app_state);
+
    let pointer_lines = [
        lines.allocate(&xr_state, app_state.graphics.clone())?,
        lines.allocate(&xr_state, app_state.graphics.clone())?,
@@ -115,14 +147,18 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {

    let watch_id = overlays.get_by_name(WATCH_NAME).unwrap().state.id; // want panic

-    let input_source = input::OpenXrInputSource::new(&xr_state)?;
+    let mut input_source = input::OpenXrInputSource::new(&xr_state)?;

    let mut session_running = false;
    let mut event_storage = xr::EventDataBuffer::new();

-    let mut show_hide_counter = DoubleClickCounter::new();
+    let mut next_device_update = Instant::now();
    let mut due_tasks = VecDeque::with_capacity(4);

+    let mut fps_counter: VecDeque<Instant> = VecDeque::new();
+
+    let mut main_session_visible = false;
+
    'main_loop: loop {
        let cur_frame = FRAME_COUNTER.fetch_add(1, Ordering::Relaxed);

@@ -166,10 +202,30 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
                EventsLost(e) => {
                    log::warn!("lost {} events", e.lost_event_count());
                }
+                MainSessionVisibilityChangedEXTX(e) => {
+                    if main_session_visible != e.visible() {
+                        main_session_visible = e.visible();
+                        log::info!("Main session visible: {}", main_session_visible);
+                        if main_session_visible {
+                            log::debug!("Destroying skybox.");
+                            skybox = None;
+                        } else {
+                            log::debug!("Allocating skybox.");
+                            skybox = create_skybox(&xr_state, &app_state);
+                        }
+                    }
+                }
                _ => {}
            }
        }

+        if next_device_update <= Instant::now() {
+            if let Some(monado) = &mut monado {
+                input_source.update_devices(&mut app_state, monado);
+                next_device_update = Instant::now() + Duration::from_secs(30);
+            }
+        }
+
        if !session_running {
            std::thread::sleep(Duration::from_millis(100));
            continue 'main_loop;
@@ -179,6 +235,24 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
        frame_stream.begin()?;

        xr_state.predicted_display_time = xr_frame_state.predicted_display_time;
+        xr_state.fps = {
+            fps_counter.push_back(Instant::now());
+
+            while let Some(time) = fps_counter.front() {
+                if time.elapsed().as_secs_f32() > 1. {
+                    fps_counter.pop_front();
+                } else {
+                    break;
+                }
+            }
+
+            let total_elapsed = fps_counter
+                .front()
+                .map(|time| time.elapsed().as_secs_f32())
+                .unwrap_or(0f32);
+
+            fps_counter.len() as f32 / total_elapsed
+        };

        if !xr_frame_state.should_render {
            frame_stream.end(
@@ -198,12 +272,18 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
            .pointers
            .iter()
            .any(|p| p.now.show_hide && !p.before.show_hide)
-            && show_hide_counter.click()
        {
            overlays.show_hide(&mut app_state);
        }

        watch_fade(&mut app_state, overlays.mut_by_id(watch_id).unwrap()); // want panic
+        if let Some(ref mut space_mover) = playspace {
+            space_mover.update(
+                &mut overlays,
+                &app_state,
+                monado.as_mut().unwrap(), // safe
+            );
+        }

        for o in overlays.iter_mut() {
            o.after_input(&mut app_state)?;
@@ -220,7 +300,17 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
            &xr_state.stage,
        )?;

-        app_state.input_state.hmd = helpers::hmd_pose_from_views(&views);
+        let ipd = helpers::ipd_from_views(&views);
+        if (app_state.input_state.ipd - ipd).abs() > 0.01 {
+            log::info!("IPD changed: {} -> {}", app_state.input_state.ipd, ipd);
+            app_state.input_state.ipd = ipd;
+            Toast::new(
+                ToastTopic::IpdChange,
+                "IPD".into(),
+                format!("{:.1} mm", ipd).into(),
+            )
+            .submit(&mut app_state);
+        }

        overlays
            .iter_mut()
@@ -240,6 +330,8 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
            }
        }

+        app_state.hid_provider.commit();
+
        let watch = overlays.mut_by_id(watch_id).unwrap(); // want panic
        let watch_transform = watch.state.transform;
        if !watch.state.want_visible {
@@ -256,6 +348,18 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
            .graphics
            .create_command_buffer(CommandBufferUsage::OneTimeSubmit)?;

+        if !main_session_visible {
+            if let Some(skybox) = skybox.as_mut() {
+                for (idx, layer) in skybox
+                    .present_xr(&xr_state, app_state.input_state.hmd, &mut command_buffer)?
+                    .into_iter()
+                    .enumerate()
+                {
+                    layers.push((200.0 - 50.0 * (idx as f32), layer));
+                }
+            }
+        }
+
        for o in overlays.iter_mut() {
            if !o.state.want_visible {
                continue;
@@ -269,19 +373,25 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
            o.render(&mut app_state)?;

            let dist_sq = (app_state.input_state.hmd.translation - o.state.transform.translation)
-                .length_squared();
+                .length_squared()
+                + (100f32 - o.state.z_order as f32);

            if !dist_sq.is_normal() {
                continue;
            }

-            if let Some(quad) = o.present_xr(&xr_state, &mut command_buffer)? {
-                layers.push((dist_sq, quad));
-            };
+            let maybe_layer = o.present_xr(&xr_state, &mut command_buffer)?;
+            if let CompositionLayer::None = maybe_layer {
+                continue;
+            }
+            layers.push((dist_sq, maybe_layer));
        }

-        for quad in lines.present_xr(&xr_state, &mut command_buffer)? {
-            layers.push((0.0, quad));
+        for maybe_layer in lines.present_xr(&xr_state, &mut command_buffer)? {
+            if let CompositionLayer::None = maybe_layer {
+                continue;
+            }
+            layers.push((0.0, maybe_layer));
        }

        command_buffer.build_and_execute_now()?;
@@ -290,7 +400,12 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {

        let frame_ref = layers
            .iter()
-            .map(|f| &f.1 as &xr::CompositionLayerBase<xr::Vulkan>)
+            .map(|f| match f.1 {
+                CompositionLayer::Quad(ref l) => l as &xr::CompositionLayerBase<xr::Vulkan>,
+                CompositionLayer::Cylinder(ref l) => l as &xr::CompositionLayerBase<xr::Vulkan>,
+                CompositionLayer::Equirect2(ref l) => l as &xr::CompositionLayerBase<xr::Vulkan>,
+                CompositionLayer::None => unreachable!(),
+            })
            .collect::<Vec<_>>();

        frame_stream.end(
@@ -299,6 +414,11 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
            &frame_ref,
        )?;

+        let removed_overlays = overlays.update(&mut app_state)?;
+        for o in removed_overlays {
+            delete_queue.push((o, cur_frame + 5));
+        }
+
        notifications.submit_pending(&mut app_state);

        app_state.tasks.retrieve_due(&mut due_tasks);
@@ -308,6 +428,8 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
                TaskType::Overlay(sel, f) => {
                    if let Some(o) = overlays.mut_by_selector(&sel) {
                        f(&mut app_state, &mut o.state);
+                    } else {
+                        log::warn!("Overlay not found for task: {:?}", sel);
                    }
                }
                TaskType::CreateOverlay(sel, f) => {
@@ -329,25 +451,47 @@ pub fn openxr_run(running: Arc<AtomicBool>) -> Result<(), BackendError> {
                TaskType::DropOverlay(sel) => {
                    if let Some(o) = overlays.mut_by_selector(&sel) {
                        if o.state.birthframe < cur_frame {
-                            let o = overlays.remove_by_selector(&sel);
-                            // set for deletion after all images are done showing
-                            delete_queue.push((o, cur_frame + 5));
+                            if let Some(o) = overlays.remove_by_selector(&sel) {
+                                // set for deletion after all images are done showing
+                                delete_queue.push((o, cur_frame + 5));
+                            }
                        }
                    }
                }
-                TaskType::System(_task) => {
-                    // Not implemented
-                }
+                TaskType::System(task) => match task {
+                    SystemTask::FixFloor => {
+                        if let Some(ref mut playspace) = playspace {
+                            playspace.fix_floor(
+                                &app_state.input_state,
+                                monado.as_mut().unwrap(), // safe
+                            );
+                        }
+                    }
+                    SystemTask::ResetPlayspace => {
+                        if let Some(ref mut playspace) = playspace {
+                            playspace.reset_offset(monado.as_mut().unwrap()); // safe
+                        }
+                    }
+                    SystemTask::ShowHide => {
+                        overlays.show_hide(&mut app_state);
+                    }
+                    _ => {}
+                },
            }
        }

        delete_queue.retain(|(_, frame)| *frame > cur_frame);

-        app_state.hid_provider.on_new_frame();
-
        let watch = overlays.mut_by_id(watch_id).unwrap(); // want panic
        watch.state.transform = watch_transform;
    }

    Ok(())
 }
+
+pub(super) enum CompositionLayer<'a> {
+    None,
+    Quad(xr::CompositionLayerQuad<'a, xr::Vulkan>),
+    Cylinder(xr::CompositionLayerCylinderKHR<'a, xr::Vulkan>),
+    Equirect2(xr::CompositionLayerEquirect2KHR<'a, xr::Vulkan>),
+}
@@ -0,0 +1,250 @@
+// Available bindings:
+//
+// -- click --
+// primary click to interact with the watch or overlays. required
+//
+// -- grab --
+// used to manipulate position, size, orientation of overlays in 3D space
+//
+// -- show_hide --
+// used to quickly hide and show your last selection of screens + keyboard
+//
+// -- space_drag --
+// move your stage (playspace drag)
+//
+// -- space_rotate --
+// rotate your stage (playspace rotate, WIP)
+//
+// -- space_reset --
+// reset your stage (reset the offset from playspace drag)
+//
+// -- click_modifier_right --
+// while this is held, your pointer will turn ORANGE and your mouse clicks will be RIGHT clicks
+//
+// -- click_modifier_middle --
+// while this is held, your pointer will turn PURPLE and your mouse clicks will be MIDDLE clicks
+//
+// -- move_mouse --
+// when using `focus_follows_mouse_mode`, you need to hold this for the mouse to move
+//
+// -- pose, haptic --
+// do not mess with these, unless you know what you're doing
+
+[
+  // Fallback controller, intended for testing
+  {
+    profile: "/interaction_profiles/khr/simple_controller",
+    pose: {
+      left: "/user/hand/left/input/aim/pose",
+      right: "/user/hand/right/input/aim/pose"
+    },
+    haptic: {
+      left: "/user/hand/left/output/haptic",
+      right: "/user/hand/right/output/haptic"
+    },
+    click: {
+      // left trigger is click
+      left: "/user/hand/left/input/select/click",
+    },
+    grab: {
+      // right trigger is grab
+      right: "/user/hand/right/input/select/click"
+    },
+    show_hide: {
+      left: "/user/hand/left/input/menu/click"
+    }
+  },
+
+  // Oculus Touch Controller. Compatible with Quest 2, Quest 3, Quest Pro
+  {
+    profile: "/interaction_profiles/oculus/touch_controller",
+    pose: {
+      left: "/user/hand/left/input/aim/pose",
+      right: "/user/hand/right/input/aim/pose"
+    },
+    haptic: {
+      left: "/user/hand/left/output/haptic",
+      right: "/user/hand/right/output/haptic"
+    },
+    click: {
+      left: "/user/hand/left/input/trigger/value",
+      right: "/user/hand/right/input/trigger/value"
+    },
+    grab: {
+      left: "/user/hand/left/input/squeeze/value",
+      right: "/user/hand/right/input/squeeze/value"
+    },
+    scroll: {
+      left: "/user/hand/left/input/thumbstick/y",
+      right: "/user/hand/right/input/thumbstick/y"
+    },
+    show_hide: {
+      double_click: true,
+      left: "/user/hand/left/input/y/click",
+    },
+    space_drag: {
+      left: "/user/hand/left/input/menu/click",
+    },
+    click_modifier_right: {
+      left: "/user/hand/left/input/y/touch",
+      right: "/user/hand/right/input/b/touch"
+    },
+    click_modifier_middle: {
+      left: "/user/hand/left/input/x/touch",
+      right: "/user/hand/right/input/a/touch"
+    },
+    move_mouse: {
+      // used with focus_follows_mouse_mode
+      left: "/user/hand/left/input/trigger/touch",
+      right: "/user/hand/right/input/trigger/touch"
+    }
+  },
+
+  // Index controller
+  {
+    profile: "/interaction_profiles/valve/index_controller",
+    pose: {
+      left: "/user/hand/left/input/aim/pose",
+      right: "/user/hand/right/input/aim/pose"
+    },
+    haptic: {
+      left: "/user/hand/left/output/haptic",
+      right: "/user/hand/right/output/haptic"
+    },
+    click: {
+      left: "/user/hand/left/input/trigger/value",
+      right: "/user/hand/right/input/trigger/value"
+    },
+    alt_click: {
+      // left trackpad is space_drag
+      right: "/user/hand/right/input/trackpad/force",
+    },
+    grab: {
+      left: "/user/hand/left/input/squeeze/force",
+      right: "/user/hand/right/input/squeeze/force"
+    },
+    scroll: {
+      left: "/user/hand/left/input/thumbstick/y",
+      right: "/user/hand/right/input/thumbstick/y"
+    },
+    show_hide: {
+      double_click: true,
+      left: "/user/hand/left/input/b/click",
+    },
+    space_drag: {
+      left: "/user/hand/left/input/trackpad/force",
+      // right trackpad is alt_click
+    },
+    space_reset: {
+      double_click: true,
+      left: "/user/hand/left/input/trackpad/force",
+    },
+    click_modifier_right: {
+      left: "/user/hand/left/input/b/touch",
+      right: "/user/hand/right/input/b/touch"
+    },
+    click_modifier_middle: {
+      left: "/user/hand/left/input/a/touch",
+      right: "/user/hand/right/input/a/touch"
+    },
+    move_mouse: {
+      // used with focus_follows_mouse_mode
+      left: "/user/hand/left/input/trigger/touch",
+      right: "/user/hand/right/input/trigger/touch"
+    }
+  },
+
+  // Vive controller
+  {
+    profile: "/interaction_profiles/htc/vive_controller",
+    pose: {
+      left: "/user/hand/left/input/aim/pose",
+      right: "/user/hand/right/input/aim/pose"
+    },
+    click: {
+      left: "/user/hand/left/input/trigger/value",
+      right: "/user/hand/right/input/trigger/value"
+    },
+    grab: {
+      left: "/user/hand/left/input/squeeze/click",
+      right: "/user/hand/right/input/squeeze/click"
+    },
+    scroll: {
+      left: "/user/hand/left/input/trackpad/y",
+      right: "/user/hand/right/input/trackpad/y"
+    },
+    show_hide: {
+      left: "/user/hand/left/input/menu/click",
+    },
+    space_drag: {
+      right: "/user/hand/right/input/menu/click",
+    },
+    haptic: {
+      left: "/user/hand/left/output/haptic",
+      right: "/user/hand/right/output/haptic"
+    }
+  },
+
+  // Windows Mixed Reality controller
+  {
+    profile: "/interaction_profiles/microsoft/motion_controller",
+    pose: {
+      left: "/user/hand/left/input/aim/pose",
+      right: "/user/hand/right/input/aim/pose"
+    },
+    haptic: {
+      left: "/user/hand/left/output/haptic",
+      right: "/user/hand/right/output/haptic"
+    },
+    click: {
+      left: "/user/hand/left/input/trigger/value",
+      right: "/user/hand/right/input/trigger/value"
+    },
+    grab: {
+      left: "/user/hand/left/input/squeeze/click",
+      right: "/user/hand/right/input/squeeze/click"
+    },
+    scroll: {
+      left: "/user/hand/left/input/thumbstick/y",
+      right: "/user/hand/right/input/thumbstick/y"
+    },
+    show_hide: {
+      left: "/user/hand/left/input/menu/click",
+    },
+    space_drag: {
+      right: "/user/hand/right/input/menu/click",
+    },
+  },
+
+  // HP Reverb G2 controller
+  {
+    profile: "/interaction_profiles/hp/mixed_reality_controller",
+    pose: {
+      left: "/user/hand/left/input/aim/pose",
+      right: "/user/hand/right/input/aim/pose"
+    },
+    haptic: {
+      left: "/user/hand/left/output/haptic",
+      right: "/user/hand/right/output/haptic"
+    },
+    click: {
+      left: "/user/hand/left/input/trigger/value",
+      right: "/user/hand/right/input/trigger/value"
+    },
+    grab: {
+      left: "/user/hand/left/input/squeeze/value",
+      right: "/user/hand/right/input/squeeze/value"
+    },
+    scroll: {
+      left: "/user/hand/left/input/thumbstick/y",
+      right: "/user/hand/right/input/thumbstick/y"
+    },
+    show_hide: {
+      left: "/user/hand/left/input/menu/click",
+    },
+    space_drag: {
+      right: "/user/hand/right/input/menu/click",
+    },
+  },
+
+]
@@ -1,10 +1,14 @@
-use openxr as xr;
-use std::sync::Arc;
-use xr::{CompositionLayerFlags, EyeVisibility};
+use glam::Vec3A;
+use openxr::{self as xr, CompositionLayerFlags};
+use std::{f32::consts::PI, sync::Arc};
+use xr::EyeVisibility;

-use super::{helpers, swapchain::SwapchainRenderData, XrState};
+use super::{helpers, swapchain::SwapchainRenderData, CompositionLayer, XrState};
 use crate::{
-    backend::{openxr::swapchain::create_swapchain_render_data, overlay::OverlayData},
+    backend::{
+        openxr::swapchain::{create_swapchain_render_data, SwapchainOpts},
+        overlay::OverlayData,
+    },
    graphics::WlxCommandBuffer,
    state::AppState,
 };
@@ -23,7 +27,7 @@ impl OverlayData<OpenXrOverlayData> {
        &'a mut self,
        xr: &'a XrState,
        command_buffer: &mut WlxCommandBuffer,
-    ) -> anyhow::Result<Option<xr::CompositionLayerQuad<xr::Vulkan>>> {
+    ) -> anyhow::Result<CompositionLayer> {
        if let Some(new_view) = self.view() {
            self.data.last_view = Some(new_view);
        }
@@ -32,15 +36,20 @@ impl OverlayData<OpenXrOverlayData> {
            view.clone()
        } else {
            log::warn!("{}: Will not show - image not ready", self.state.name);
-            return Ok(None);
+            return Ok(CompositionLayer::None);
        };
-        let extent = my_view.image().extent();
+
+        let extent = self.extent().unwrap(); // want panic

        let data = match self.data.swapchain {
            Some(ref mut data) => data,
            None => {
-                let srd =
-                    create_swapchain_render_data(xr, command_buffer.graphics.clone(), extent)?;
+                let srd = create_swapchain_render_data(
+                    xr,
+                    command_buffer.graphics.clone(),
+                    extent,
+                    SwapchainOpts::new(),
+                )?;
                log::debug!(
                    "{}: Created swapchain {}x{}, {} images, {} MB",
                    self.state.name,
@@ -55,10 +64,8 @@ impl OverlayData<OpenXrOverlayData> {
        };

        let sub_image = data.acquire_present_release(command_buffer, my_view, self.state.alpha)?;
-        let posef = helpers::transform_to_posef(&self.state.transform);

        let aspect_ratio = extent[1] as f32 / extent[0] as f32;
-
        let (scale_x, scale_y) = if aspect_ratio < 1.0 {
            let major = self.state.transform.matrix3.col(0).length();
            (major, major * aspect_ratio)
@@ -67,17 +74,38 @@ impl OverlayData<OpenXrOverlayData> {
            (major / aspect_ratio, major)
        };

-        let quad = xr::CompositionLayerQuad::new()
-            .pose(posef)
-            .sub_image(sub_image)
-            .eye_visibility(EyeVisibility::BOTH)
-            .layer_flags(CompositionLayerFlags::CORRECT_CHROMATIC_ABERRATION)
-            .space(&xr.stage)
-            .size(xr::Extent2Df {
-                width: scale_x,
-                height: scale_y,
-            });
-        Ok(Some(quad))
+        if let Some(curvature) = self.state.curvature {
+            let radius = scale_x / (2.0 * PI * curvature);
+            let quat = helpers::transform_to_norm_quat(&self.state.transform);
+            let center_point = self.state.transform.translation + quat.mul_vec3a(Vec3A::Z * radius);
+
+            let posef = helpers::translation_rotation_to_posef(center_point, quat);
+            let angle = 2.0 * (scale_x / (2.0 * radius));
+
+            let cylinder = xr::CompositionLayerCylinderKHR::new()
+                .layer_flags(CompositionLayerFlags::BLEND_TEXTURE_SOURCE_ALPHA)
+                .pose(posef)
+                .sub_image(sub_image)
+                .eye_visibility(EyeVisibility::BOTH)
+                .space(&xr.stage)
+                .radius(radius)
+                .central_angle(angle)
+                .aspect_ratio(aspect_ratio);
+            Ok(CompositionLayer::Cylinder(cylinder))
+        } else {
+            let posef = helpers::transform_to_posef(&self.state.transform);
+            let quad = xr::CompositionLayerQuad::new()
+                .layer_flags(CompositionLayerFlags::BLEND_TEXTURE_SOURCE_ALPHA)
+                .pose(posef)
+                .sub_image(sub_image)
+                .eye_visibility(EyeVisibility::BOTH)
+                .space(&xr.stage)
+                .size(xr::Extent2Df {
+                    width: scale_x,
+                    height: scale_y,
+                });
+            Ok(CompositionLayer::Quad(quad))
+        }
    }

    pub(super) fn after_input(&mut self, app: &mut AppState) -> anyhow::Result<()> {
@@ -0,0 +1,206 @@
+use glam::{Affine3A, Quat, Vec3A};
+use libmonado_rs::{Monado, Pose, ReferenceSpaceType};
+
+use crate::{
+    backend::{common::OverlayContainer, input::InputState},
+    state::AppState,
+};
+
+use super::overlay::OpenXrOverlayData;
+
+#[repr(C)]
+#[derive(Default, Debug)]
+struct XrtPose {
+    orientation: [f32; 4],
+    position: [f32; 3],
+}
+
+struct MoverData<T> {
+    pose: Affine3A,
+    hand: usize,
+    hand_pose: T,
+}
+
+pub(super) struct PlayspaceMover {
+    last_transform: Affine3A,
+    drag: Option<MoverData<Vec3A>>,
+    rotate: Option<MoverData<Quat>>,
+}
+
+impl PlayspaceMover {
+    pub fn new(monado: &mut Monado) -> anyhow::Result<Self> {
+        log::info!("Monado: using space offset API");
+
+        let Ok(stage) = monado.get_reference_space_offset(ReferenceSpaceType::Stage) else {
+            anyhow::bail!("Space offsets not supported.");
+        };
+
+        log::debug!("STAGE is at {:?}, {:?}", stage.position, stage.orientation);
+
+        // initial offset
+        let last_transform =
+            Affine3A::from_rotation_translation(stage.orientation.into(), stage.position.into());
+
+        Ok(Self {
+            last_transform,
+
+            drag: None,
+            rotate: None,
+        })
+    }
+
+    pub fn update(
+        &mut self,
+        overlays: &mut OverlayContainer<OpenXrOverlayData>,
+        state: &AppState,
+        monado: &mut Monado,
+    ) {
+        for pointer in state.input_state.pointers.iter() {
+            if pointer.now.space_reset {
+                if !pointer.before.space_reset {
+                    log::info!("Space reset");
+                    self.reset_offset(monado);
+                }
+                return;
+            }
+        }
+
+        if let Some(mut data) = self.rotate.take() {
+            let pointer = &state.input_state.pointers[data.hand];
+            if !pointer.now.space_rotate {
+                self.last_transform = data.pose;
+                log::info!("End space rotate");
+                return;
+            }
+
+            let new_hand =
+                Quat::from_affine3(&(data.pose * state.input_state.pointers[data.hand].raw_pose));
+
+            let dq = new_hand * data.hand_pose.conjugate();
+            let mut space_transform = if state.session.config.space_rotate_unlocked {
+                Affine3A::from_quat(dq)
+            } else {
+                let rel_y = f32::atan2(
+                    2.0 * (dq.y * dq.w + dq.x * dq.z),
+                    (2.0 * (dq.w * dq.w + dq.x * dq.x)) - 1.0,
+                );
+
+                Affine3A::from_rotation_y(rel_y)
+            };
+            let offset = (space_transform.transform_vector3a(state.input_state.hmd.translation)
+                - state.input_state.hmd.translation)
+                * -1.0;
+
+            space_transform.translation = offset;
+
+            data.pose *= space_transform;
+            data.hand_pose = new_hand;
+
+            self.apply_offset(data.pose, monado);
+            self.rotate = Some(data);
+        } else {
+            for (i, pointer) in state.input_state.pointers.iter().enumerate() {
+                if pointer.now.space_rotate {
+                    let hand_pose = Quat::from_affine3(&(self.last_transform * pointer.raw_pose));
+                    self.rotate = Some(MoverData {
+                        pose: self.last_transform,
+                        hand: i,
+                        hand_pose,
+                    });
+                    self.drag = None;
+                    log::info!("Start space rotate");
+                    return;
+                }
+            }
+        }
+
+        if let Some(mut data) = self.drag.take() {
+            let pointer = &state.input_state.pointers[data.hand];
+            if !pointer.now.space_drag {
+                self.last_transform = data.pose;
+                log::info!("End space drag");
+                return;
+            }
+
+            let new_hand = data
+                .pose
+                .transform_point3a(state.input_state.pointers[data.hand].raw_pose.translation);
+            let relative_pos =
+                (new_hand - data.hand_pose) * state.session.config.space_drag_multiplier;
+
+            if relative_pos.length_squared() > 1000.0 {
+                log::warn!("Space drag too fast, ignoring");
+                return;
+            }
+
+            let overlay_offset = data.pose.inverse().transform_vector3a(relative_pos) * -1.0;
+
+            overlays.iter_mut().for_each(|overlay| {
+                if overlay.state.grabbable {
+                    overlay.state.dirty = true;
+                    overlay.state.transform.translation += overlay_offset;
+                }
+            });
+
+            data.pose.translation += relative_pos;
+            data.hand_pose = new_hand;
+
+            self.apply_offset(data.pose, monado);
+            self.drag = Some(data);
+        } else {
+            for (i, pointer) in state.input_state.pointers.iter().enumerate() {
+                if pointer.now.space_drag {
+                    let hand_pos = self
+                        .last_transform
+                        .transform_point3a(pointer.raw_pose.translation);
+                    self.drag = Some(MoverData {
+                        pose: self.last_transform,
+                        hand: i,
+                        hand_pose: hand_pos,
+                    });
+                    log::info!("Start space drag");
+                    return;
+                }
+            }
+        }
+    }
+
+    pub fn reset_offset(&mut self, monado: &mut Monado) {
+        if self.drag.is_some() {
+            log::info!("Space drag interrupted by manual reset");
+            self.drag = None;
+        }
+        if self.rotate.is_some() {
+            log::info!("Space rotate interrupted by manual reset");
+            self.rotate = None;
+        }
+
+        self.last_transform = Affine3A::IDENTITY;
+        self.apply_offset(self.last_transform, monado);
+    }
+
+    pub fn fix_floor(&mut self, input: &InputState, monado: &mut Monado) {
+        if self.drag.is_some() {
+            log::info!("Space drag interrupted by fix floor");
+            self.drag = None;
+        }
+        if self.rotate.is_some() {
+            log::info!("Space rotate interrupted by fix floor");
+            self.rotate = None;
+        }
+
+        let y1 = input.pointers[0].raw_pose.translation.y;
+        let y2 = input.pointers[1].raw_pose.translation.y;
+        let delta = y1.min(y2) - 0.03;
+        self.last_transform.translation.y += delta;
+        self.apply_offset(self.last_transform, monado);
+    }
+
+    fn apply_offset(&self, transform: Affine3A, monado: &mut Monado) {
+        let pose = Pose {
+            position: transform.translation.into(),
+            orientation: Quat::from_affine3(&transform).into(),
+        };
+        let _ = monado.set_reference_space_offset(ReferenceSpaceType::Stage, pose);
+    }
+}
@@ -0,0 +1,168 @@
+use std::{f32::consts::PI, fs::File, sync::Arc};
+
+use glam::{Affine3A, Quat, Vec3A};
+use once_cell::sync::Lazy;
+use openxr::{self as xr, CompositionLayerFlags};
+use vulkano::{command_buffer::CommandBufferUsage, image::view::ImageView};
+
+use crate::{
+    backend::openxr::{helpers::translation_rotation_to_posef, swapchain::SwapchainOpts},
+    config_io::CONFIG_ROOT_PATH,
+    graphics::{dds::WlxCommandBufferDds, format_is_srgb, WlxCommandBuffer},
+    state::AppState,
+};
+
+use super::{
+    swapchain::{create_swapchain_render_data, SwapchainRenderData},
+    CompositionLayer, XrState,
+};
+
+pub(super) struct Skybox {
+    view: Arc<ImageView>,
+    srd: Option<(SwapchainRenderData, SwapchainRenderData)>,
+}
+
+impl Skybox {
+    pub fn new(app: &AppState) -> anyhow::Result<Self> {
+        let mut command_buffer = app
+            .graphics
+            .create_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
+
+        let mut maybe_image = None;
+
+        'custom_tex: {
+            if app.session.config.skybox_texture.is_empty() {
+                break 'custom_tex;
+            }
+
+            let real_path = CONFIG_ROOT_PATH.join(&*app.session.config.skybox_texture);
+            let Ok(f) = File::open(real_path) else {
+                log::warn!(
+                    "Could not open custom skybox texture at: {}",
+                    app.session.config.skybox_texture
+                );
+                break 'custom_tex;
+            };
+            match command_buffer.texture2d_dds(f) {
+                Ok(image) => {
+                    maybe_image = Some(image);
+                }
+                Err(e) => {
+                    log::warn!(
+                        "Could not use custom skybox texture at: {}",
+                        app.session.config.skybox_texture
+                    );
+                    log::warn!("{:?}", e);
+                }
+            }
+        }
+
+        if maybe_image.is_none() {
+            let p = include_bytes!("../../res/table_mountain_2.dds");
+            maybe_image = Some(command_buffer.texture2d_dds(p.as_slice())?);
+        }
+
+        command_buffer.build_and_execute_now()?;
+
+        let view = ImageView::new_default(maybe_image.unwrap())?; // safe unwrap
+
+        Ok(Self { view, srd: None })
+    }
+
+    pub(super) fn present_xr<'a>(
+        &'a mut self,
+        xr: &'a XrState,
+        hmd: Affine3A,
+        command_buffer: &mut WlxCommandBuffer,
+    ) -> anyhow::Result<Vec<CompositionLayer>> {
+        let (sky_image, grid_image) = if let Some((ref mut srd_sky, ref mut srd_grid)) = self.srd {
+            (srd_sky.present_last()?, srd_grid.present_last()?)
+        } else {
+            log::debug!("Render skybox.");
+
+            let mut opts = SwapchainOpts::new().immutable();
+            opts.srgb = format_is_srgb(self.view.image().format());
+
+            let srd_sky = create_swapchain_render_data(
+                xr,
+                command_buffer.graphics.clone(),
+                self.view.image().extent(),
+                opts,
+            )?;
+
+            let srd_grid = create_swapchain_render_data(
+                xr,
+                command_buffer.graphics.clone(),
+                [1024, 1024, 1],
+                SwapchainOpts::new().immutable().grid(),
+            )?;
+
+            self.srd = Some((srd_sky, srd_grid));
+
+            let (srd_sky, srd_grid) = self.srd.as_mut().unwrap(); // safe unwrap
+
+            (
+                srd_sky.acquire_present_release(command_buffer, self.view.clone(), 1.0)?,
+                srd_grid.acquire_compute_release(command_buffer)?,
+            )
+        };
+
+        let pose = xr::Posef {
+            orientation: xr::Quaternionf::IDENTITY,
+            position: xr::Vector3f {
+                x: hmd.translation.x,
+                y: hmd.translation.y,
+                z: hmd.translation.z,
+            },
+        };
+
+        // cover the entire sphere
+        const HORIZ_ANGLE: f32 = 2.0 * PI;
+        const HI_VERT_ANGLE: f32 = 0.5 * PI;
+        const LO_VERT_ANGLE: f32 = -0.5 * PI;
+
+        let mut layers = vec![];
+
+        let sky = xr::CompositionLayerEquirect2KHR::new()
+            .layer_flags(CompositionLayerFlags::BLEND_TEXTURE_SOURCE_ALPHA)
+            .pose(pose)
+            .radius(10.0)
+            .sub_image(sky_image)
+            .eye_visibility(xr::EyeVisibility::BOTH)
+            .space(&xr.stage)
+            .central_horizontal_angle(HORIZ_ANGLE)
+            .upper_vertical_angle(HI_VERT_ANGLE)
+            .lower_vertical_angle(LO_VERT_ANGLE);
+
+        layers.push(CompositionLayer::Equirect2(sky));
+
+        static GRID_POSE: Lazy<xr::Posef> = Lazy::new(|| {
+            translation_rotation_to_posef(Vec3A::ZERO, Quat::from_rotation_x(PI * -0.5))
+        });
+
+        let grid = xr::CompositionLayerQuad::new()
+            .layer_flags(CompositionLayerFlags::BLEND_TEXTURE_SOURCE_ALPHA)
+            .pose(*GRID_POSE)
+            .size(xr::Extent2Df {
+                width: 10.0,
+                height: 10.0,
+            })
+            .sub_image(grid_image)
+            .eye_visibility(xr::EyeVisibility::BOTH)
+            .space(&xr.stage);
+
+        layers.push(CompositionLayer::Quad(grid));
+
+        Ok(layers)
+    }
+}
+
+pub(super) fn create_skybox(xr: &XrState, app: &AppState) -> Option<Skybox> {
+    if !app.session.config.use_skybox {
+        return None;
+    }
+    xr.instance
+        .exts()
+        .khr_composition_layer_equirect2
+        .and_then(|_| Skybox::new(app).ok())
+}
@@ -6,7 +6,8 @@ use openxr as xr;

 use smallvec::SmallVec;
 use vulkano::{
-    image::{sampler::Filter, sys::RawImage, view::ImageView, ImageCreateInfo, ImageUsage},
+    format::Format,
+    image::{sys::RawImage, view::ImageView, ImageCreateInfo, ImageUsage},
    pipeline::graphics::color_blend::AttachmentBlend,
    Handle,
 };
@@ -15,15 +16,47 @@ use crate::graphics::{WlxCommandBuffer, WlxGraphics, WlxPipeline, WlxPipelineDyn

 use super::XrState;

+#[derive(Default)]
+pub(super) struct SwapchainOpts {
+    pub immutable: bool,
+    pub srgb: bool,
+    pub grid: bool,
+}
+
+impl SwapchainOpts {
+    pub fn new() -> Self {
+        Default::default()
+    }
+    pub fn immutable(mut self) -> Self {
+        self.immutable = true;
+        self
+    }
+    pub fn srgb(mut self) -> Self {
+        self.srgb = true;
+        self
+    }
+    pub fn grid(mut self) -> Self {
+        self.grid = true;
+        self
+    }
+}
+
 pub(super) fn create_swapchain_render_data(
    xr: &XrState,
    graphics: Arc<WlxGraphics>,
    extent: [u32; 3],
+    opts: SwapchainOpts,
 ) -> anyhow::Result<SwapchainRenderData> {
+    let create_flags = if opts.immutable {
+        xr::SwapchainCreateFlags::STATIC_IMAGE
+    } else {
+        xr::SwapchainCreateFlags::EMPTY
+    };
+
    let swapchain = xr.session.create_swapchain(&xr::SwapchainCreateInfo {
-        create_flags: xr::SwapchainCreateFlags::EMPTY,
+        create_flags,
        usage_flags: xr::SwapchainUsageFlags::COLOR_ATTACHMENT | xr::SwapchainUsageFlags::SAMPLED,
-        format: graphics.native_format as _,
+        format: Format::R8G8B8A8_SRGB as _,
        sample_count: 1,
        width: extent[0],
        height: extent[1],
@@ -35,10 +68,22 @@ pub(super) fn create_swapchain_render_data(
    let Ok(shaders) = graphics.shared_shaders.read() else {
        bail!("Failed to lock shared shaders for reading");
    };
+
+    let image_fmt = if opts.srgb {
+        Format::R8G8B8A8_SRGB
+    } else {
+        Format::R8G8B8A8_UNORM
+    };
+
+    let frag_shader = if opts.grid {
+        "frag_grid"
+    } else {
+        "frag_swapchain"
+    };
    let pipeline = graphics.create_pipeline_dynamic(
        shaders.get("vert_common").unwrap().clone(), // want panic
-        shaders.get("frag_srgb").unwrap().clone(),   // want panic
-        graphics.native_format,
+        shaders.get(frag_shader).unwrap().clone(),   // want panic
+        image_fmt,
        Some(AttachmentBlend::alpha()),
    )?;

@@ -53,7 +98,7 @@ pub(super) fn create_swapchain_render_data(
                    graphics.device.clone(),
                    vk_image,
                    ImageCreateInfo {
-                        format: graphics.native_format,
+                        format: image_fmt, // actually SRGB but we lie
                        extent,
                        usage: ImageUsage::COLOR_ATTACHMENT,
                        ..Default::default()
@@ -71,6 +116,7 @@ pub(super) fn create_swapchain_render_data(
        pipeline,
        images,
        extent,
+        target_extent: [0, 0, 0],
    })
 }

@@ -78,6 +124,7 @@ pub(super) struct SwapchainRenderData {
    pub(super) swapchain: xr::Swapchain<xr::Vulkan>,
    pub(super) pipeline: Arc<WlxPipeline<WlxPipelineDynamic>>,
    pub(super) extent: [u32; 3],
+    pub(super) target_extent: [u32; 3],
    pub(super) images: SmallVec<[Arc<ImageView>; 4]>,
 }

@@ -94,16 +141,18 @@ impl SwapchainRenderData {
        let render_target = &mut self.images[idx];
        command_buffer.begin_rendering(render_target.clone())?;

-        let target_extent = render_target.image().extent();
+        self.target_extent = render_target.image().extent();

-        let set0 = self
-            .pipeline
-            .uniform_sampler(0, view.clone(), Filter::Linear)?;
+        let set0 = self.pipeline.uniform_sampler(
+            0,
+            view.clone(),
+            command_buffer.graphics.texture_filtering,
+        )?;

        let set1 = self.pipeline.uniform_buffer(1, vec![alpha])?;

        let pass = self.pipeline.create_pass(
-            [target_extent[0] as _, target_extent[1] as _],
+            [self.target_extent[0] as _, self.target_extent[1] as _],
            command_buffer.graphics.quad_verts.clone(),
            command_buffer.graphics.quad_indices.clone(),
            vec![set0, set1],
@@ -118,8 +167,60 @@ impl SwapchainRenderData {
            .image_rect(xr::Rect2Di {
                offset: xr::Offset2Di { x: 0, y: 0 },
                extent: xr::Extent2Di {
-                    width: target_extent[0] as _,
-                    height: target_extent[1] as _,
+                    width: self.target_extent[0] as _,
+                    height: self.target_extent[1] as _,
+                },
+            })
+            .image_array_index(0))
+    }
+
+    pub(super) fn acquire_compute_release(
+        &mut self,
+        command_buffer: &mut WlxCommandBuffer,
+    ) -> anyhow::Result<xr::SwapchainSubImage<xr::Vulkan>> {
+        let idx = self.swapchain.acquire_image()? as usize;
+        self.swapchain.wait_image(xr::Duration::INFINITE)?;
+
+        let render_target = &mut self.images[idx];
+        command_buffer.begin_rendering(render_target.clone())?;
+
+        self.target_extent = render_target.image().extent();
+
+        let pass = self.pipeline.create_pass(
+            [self.target_extent[0] as _, self.target_extent[1] as _],
+            command_buffer.graphics.quad_verts.clone(),
+            command_buffer.graphics.quad_indices.clone(),
+            vec![],
+        )?;
+        command_buffer.run_ref(&pass)?;
+        command_buffer.end_rendering()?;
+
+        self.swapchain.release_image()?;
+
+        Ok(xr::SwapchainSubImage::new()
+            .swapchain(&self.swapchain)
+            .image_rect(xr::Rect2Di {
+                offset: xr::Offset2Di { x: 0, y: 0 },
+                extent: xr::Extent2Di {
+                    width: self.target_extent[0] as _,
+                    height: self.target_extent[1] as _,
+                },
+            })
+            .image_array_index(0))
+    }
+
+    pub(super) fn present_last(&self) -> anyhow::Result<xr::SwapchainSubImage<xr::Vulkan>> {
+        debug_assert!(
+            self.target_extent[0] * self.target_extent[1] != 0,
+            "present_last: target_extent zero"
+        );
+        Ok(xr::SwapchainSubImage::new()
+            .swapchain(&self.swapchain)
+            .image_rect(xr::Rect2Di {
+                offset: xr::Offset2Di { x: 0, y: 0 },
+                extent: xr::Extent2Di {
+                    width: self.target_extent[0] as _,
+                    height: self.target_extent[1] as _,
                },
            })
            .image_array_index(0))
@@ -10,13 +10,16 @@ use anyhow::Ok;
 use glam::{Affine2, Affine3A, Mat3A, Quat, Vec2, Vec3, Vec3A};
 use vulkano::image::view::ImageView;

-use crate::state::AppState;
+use crate::{config::AStrMapExt, state::AppState};

 use super::input::{DummyInteractionHandler, Haptics, InteractionHandler, PointerHit};

 static AUTO_INCREMENT: AtomicUsize = AtomicUsize::new(0);

-pub trait OverlayBackend: OverlayRenderer + InteractionHandler {}
+pub trait OverlayBackend: OverlayRenderer + InteractionHandler {
+    fn set_renderer(&mut self, renderer: Box<dyn OverlayRenderer>);
+    fn set_interaction(&mut self, interaction: Box<dyn InteractionHandler>);
+}

 pub struct OverlayState {
    pub id: usize,
@@ -26,15 +29,17 @@ pub struct OverlayState {
    pub grabbable: bool,
    pub interactable: bool,
    pub recenter: bool,
+    pub anchored: bool,
    pub dirty: bool,
    pub alpha: f32,
+    pub z_order: u32,
    pub transform: Affine3A,
-    pub saved_point: Option<Vec3A>,
-    pub saved_scale: Option<f32>,
    pub spawn_scale: f32, // aka width
    pub spawn_point: Vec3A,
    pub spawn_rotation: Quat,
+    pub saved_transform: Option<Affine3A>,
    pub relative_to: RelativeTo,
+    pub curvature: Option<f32>,
    pub primary_pointer: Option<usize>,
    pub interaction_transform: Affine2,
    pub birthframe: usize,
@@ -50,14 +55,16 @@ impl Default for OverlayState {
            grabbable: false,
            recenter: false,
            interactable: false,
+            anchored: false,
            dirty: true,
            alpha: 1.0,
+            z_order: 0,
            relative_to: RelativeTo::None,
-            saved_point: None,
-            saved_scale: None,
+            curvature: None,
            spawn_scale: 1.0,
            spawn_point: Vec3A::NEG_Z,
            spawn_rotation: Quat::IDENTITY,
+            saved_transform: None,
            transform: Affine3A::IDENTITY,
            primary_pointer: None,
            interaction_transform: Affine2::IDENTITY,
@@ -93,43 +100,51 @@ where
 impl OverlayState {
    pub fn parent_transform(&self, app: &AppState) -> Option<Affine3A> {
        match self.relative_to {
-            RelativeTo::None => None,
            RelativeTo::Head => Some(app.input_state.hmd),
            RelativeTo::Hand(idx) => Some(app.input_state.pointers[idx].pose),
+            _ => None,
        }
    }

+    fn get_anchor(&self, app: &AppState) -> Affine3A {
+        if self.anchored {
+            app.anchor
+        } else {
+            // fake anchor that's always in front of HMD
+            app.input_state.hmd
+        }
+    }
+
+    fn get_transform(&self) -> Affine3A {
+        self.saved_transform.unwrap_or_else(|| {
+            Affine3A::from_scale_rotation_translation(
+                Vec3::ONE * self.spawn_scale,
+                self.spawn_rotation,
+                self.spawn_point.into(),
+            )
+        })
+    }
+
    pub fn auto_movement(&mut self, app: &mut AppState) {
        if let Some(parent) = self.parent_transform(app) {
-            let scale = self.saved_scale.unwrap_or(self.spawn_scale);
-            let point = self.saved_point.unwrap_or(self.spawn_point);
-            self.transform = parent
-                * Affine3A::from_scale_rotation_translation(
-                    Vec3::ONE * scale,
-                    self.spawn_rotation,
-                    point.into(),
-                );
-
+            self.transform = parent * self.get_transform();
            self.dirty = true;
        }
    }

    pub fn reset(&mut self, app: &mut AppState, hard_reset: bool) {
        if hard_reset {
-            self.saved_point = None;
-            self.saved_scale = None;
+            self.saved_transform = None;
        }

-        let scale = self.saved_scale.unwrap_or(self.spawn_scale);
-        let point = self.saved_point.unwrap_or(self.spawn_point);
+        self.transform = self
+            .parent_transform(app)
+            .unwrap_or_else(|| self.get_anchor(app))
+            * self.get_transform();

-        let translation = app.input_state.hmd.transform_point3a(point);
-        self.transform = Affine3A::from_scale_rotation_translation(
-            Vec3::ONE * scale,
-            Quat::IDENTITY,
-            translation.into(),
-        );
-        self.realign(&app.input_state.hmd);
+        if self.grabbable && hard_reset {
+            self.realign(&app.input_state.hmd);
+        }
        self.dirty = true;
    }

@@ -179,7 +194,28 @@ where
    T: Default,
 {
    pub fn init(&mut self, app: &mut AppState) -> anyhow::Result<()> {
-        self.state.reset(app, true);
+        self.state.curvature = app
+            .session
+            .config
+            .curve_values
+            .arc_get(self.state.name.as_ref())
+            .copied();
+
+        if matches!(self.state.relative_to, RelativeTo::None) {
+            let hard_reset;
+            if let Some(transform) = app
+                .session
+                .config
+                .transform_values
+                .arc_get(self.state.name.as_ref())
+            {
+                self.state.saved_transform = Some(*transform);
+                hard_reset = false;
+            } else {
+                hard_reset = true;
+            }
+            self.state.reset(app, hard_reset);
+        }
        self.backend.init(app)
    }
    pub fn render(&mut self, app: &mut AppState) -> anyhow::Result<()> {
@@ -188,6 +224,9 @@ where
    pub fn view(&mut self) -> Option<Arc<ImageView>> {
        self.backend.view()
    }
+    pub fn extent(&mut self) -> Option<[u32; 3]> {
+        self.backend.extent()
+    }
    pub fn set_visible(&mut self, app: &mut AppState, visible: bool) -> anyhow::Result<()> {
        let old_visible = self.state.want_visible;
        self.state.want_visible = visible;
@@ -203,11 +242,19 @@ where
 }

 pub trait OverlayRenderer {
+    /// Called once, before the first frame is rendered
    fn init(&mut self, app: &mut AppState) -> anyhow::Result<()>;
    fn pause(&mut self, app: &mut AppState) -> anyhow::Result<()>;
    fn resume(&mut self, app: &mut AppState) -> anyhow::Result<()>;
+    /// Called when the presentation layer is ready to present a new frame
    fn render(&mut self, app: &mut AppState) -> anyhow::Result<()>;
+    /// Called to retrieve the current image to be displayed
    fn view(&mut self) -> Option<Arc<ImageView>>;
+    /// Called to retrieve the effective extent of the image
+    /// Used for creating swapchains.
+    ///
+    /// Muse not be None if view() is also not None
+    fn extent(&mut self) -> Option<[u32; 3]>;
 }

 pub struct FallbackRenderer;
@@ -228,15 +275,23 @@ impl OverlayRenderer for FallbackRenderer {
    fn view(&mut self) -> Option<Arc<ImageView>> {
        None
    }
+    fn extent(&mut self) -> Option<[u32; 3]> {
+        None
+    }
 }
 // Boilerplate and dummies

 #[derive(Clone, Copy, Debug, Default)]
 pub enum RelativeTo {
+    /// Stays in place unless rencentered
    #[default]
    None,
+    /// Stays in position relative to HMD
    Head,
+    /// Stays in position relative to hand
    Hand(usize),
+    /// Stays in place, no recentering
+    Stage,
 }

 pub struct SplitOverlayBackend {
@@ -253,7 +308,14 @@ impl Default for SplitOverlayBackend {
    }
 }

-impl OverlayBackend for SplitOverlayBackend {}
+impl OverlayBackend for SplitOverlayBackend {
+    fn set_renderer(&mut self, renderer: Box<dyn OverlayRenderer>) {
+        self.renderer = renderer;
+    }
+    fn set_interaction(&mut self, interaction: Box<dyn InteractionHandler>) {
+        self.interaction = interaction;
+    }
+}
 impl OverlayRenderer for SplitOverlayBackend {
    fn init(&mut self, app: &mut AppState) -> anyhow::Result<()> {
        self.renderer.init(app)
@@ -270,6 +332,9 @@ impl OverlayRenderer for SplitOverlayBackend {
    fn view(&mut self) -> Option<Arc<ImageView>> {
        self.renderer.view()
    }
+    fn extent(&mut self) -> Option<[u32; 3]> {
+        self.renderer.extent()
+    }
 }
 impl InteractionHandler for SplitOverlayBackend {
    fn on_left(&mut self, app: &mut AppState, pointer: usize) {
@@ -287,10 +352,18 @@ impl InteractionHandler for SplitOverlayBackend {
 }

 pub fn ui_transform(extent: &[u32; 2]) -> Affine2 {
+    let aspect = extent[0] as f32 / extent[1] as f32;
+    let scale = if aspect < 1.0 {
+        Vec2 {
+            x: 1.0 / aspect,
+            y: -1.0,
+        }
+    } else {
+        Vec2 {
+            x: 1.0,
+            y: -1.0 * aspect,
+        }
+    };
    let center = Vec2 { x: 0.5, y: 0.5 };
-    Affine2::from_cols(
-        Vec2::X,
-        Vec2::NEG_Y * (extent[0] as f32 / extent[1] as f32),
-        center,
-    )
+    Affine2::from_scale_angle_translation(scale, 0.0, center)
 }
@@ -0,0 +1,114 @@
+use std::{
+    cmp,
+    collections::{BinaryHeap, VecDeque},
+    sync::atomic::{self, AtomicUsize},
+    time::Instant,
+};
+
+use serde::Deserialize;
+
+use crate::state::AppState;
+
+use super::{
+    common::OverlaySelector,
+    overlay::{OverlayBackend, OverlayState},
+};
+
+static TASK_AUTO_INCREMENT: AtomicUsize = AtomicUsize::new(0);
+
+struct AppTask {
+    pub not_before: Instant,
+    pub id: usize,
+    pub task: TaskType,
+}
+
+impl PartialEq<AppTask> for AppTask {
+    fn eq(&self, other: &Self) -> bool {
+        self.cmp(other) == cmp::Ordering::Equal
+    }
+}
+impl PartialOrd<AppTask> for AppTask {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl Eq for AppTask {}
+impl Ord for AppTask {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.not_before
+            .cmp(&other.not_before)
+            .then(self.id.cmp(&other.id))
+            .reverse()
+    }
+}
+
+pub enum SystemTask {
+    ColorGain(ColorChannel, f32),
+    ResetPlayspace,
+    FixFloor,
+    ShowHide,
+}
+
+pub type OverlayTask = dyn FnOnce(&mut AppState, &mut OverlayState) + Send;
+pub type CreateOverlayTask =
+    dyn FnOnce(&mut AppState) -> Option<(OverlayState, Box<dyn OverlayBackend>)> + Send;
+
+pub enum TaskType {
+    Global(Box<dyn FnOnce(&mut AppState) + Send>),
+    Overlay(OverlaySelector, Box<OverlayTask>),
+    CreateOverlay(OverlaySelector, Box<CreateOverlayTask>),
+    DropOverlay(OverlaySelector),
+    System(SystemTask),
+}
+
+#[derive(Deserialize, Clone, Copy)]
+pub enum ColorChannel {
+    R,
+    G,
+    B,
+    All,
+}
+
+pub struct TaskContainer {
+    tasks: BinaryHeap<AppTask>,
+}
+
+impl TaskContainer {
+    pub fn new() -> Self {
+        Self {
+            tasks: BinaryHeap::new(),
+        }
+    }
+
+    pub fn enqueue(&mut self, task: TaskType) {
+        self.tasks.push(AppTask {
+            not_before: Instant::now(),
+            id: TASK_AUTO_INCREMENT.fetch_add(1, atomic::Ordering::Relaxed),
+            task,
+        });
+    }
+
+    /// Enqueue a task to be executed at a specific time.
+    /// If the time is in the past, the task will be executed immediately.
+    /// Multiple tasks enqueued for the same instant will be executed in order of submission.
+    pub fn enqueue_at(&mut self, task: TaskType, not_before: Instant) {
+        self.tasks.push(AppTask {
+            not_before,
+            id: TASK_AUTO_INCREMENT.fetch_add(1, atomic::Ordering::Relaxed),
+            task,
+        });
+    }
+
+    pub fn retrieve_due(&mut self, dest_buf: &mut VecDeque<TaskType>) {
+        let now = Instant::now();
+
+        while let Some(task) = self.tasks.peek() {
+            if task.not_before > now {
+                break;
+            }
+
+            // Safe unwrap because we peeked.
+            dest_buf.push_back(self.tasks.pop().unwrap().task);
+        }
+    }
+}
@@ -0,0 +1,317 @@
+use std::sync::Arc;
+
+use vulkano::{
+    command_buffer::CommandBufferUsage,
+    image::{view::ImageView, ImageUsage},
+    swapchain::{
+        acquire_next_image, Surface, Swapchain, SwapchainCreateInfo, SwapchainPresentInfo,
+    },
+    sync::GpuFuture,
+    Validated, VulkanError,
+};
+use winit::{
+    dpi::LogicalSize,
+    event::{Event, WindowEvent},
+    event_loop::ControlFlow,
+    window::Window,
+};
+
+use crate::{
+    config::load_custom_ui,
+    config_io,
+    graphics::{DynamicPass, DynamicPipeline, WlxGraphics, BLEND_ALPHA},
+    gui::{
+        canvas::Canvas,
+        modular::{modular_canvas, ModularData},
+    },
+    hid::USE_UINPUT,
+    state::{AppState, ScreenMeta},
+};
+
+use super::{
+    input::{TrackedDevice, TrackedDeviceRole},
+    overlay::OverlayRenderer,
+};
+
+static LAST_SIZE: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+
+struct PreviewState {
+    canvas: Canvas<(), ModularData>,
+    pipeline: Arc<DynamicPipeline>,
+    pass: DynamicPass,
+    swapchain: Arc<Swapchain>,
+    images: Vec<Arc<ImageView>>,
+}
+
+impl PreviewState {
+    fn new(
+        state: &mut AppState,
+        surface: Arc<Surface>,
+        window: Arc<Window>,
+        panel_name: &str,
+    ) -> anyhow::Result<Self> {
+        let config = load_custom_ui(panel_name)?;
+
+        let last_size = {
+            let size_u64 = LAST_SIZE.load(std::sync::atomic::Ordering::Relaxed);
+            [size_u64 as u32, (size_u64 >> 32) as u32]
+        };
+
+        if last_size != config.size {
+            let logical_size = LogicalSize::new(config.size[0], config.size[1]);
+            let _ = window.request_inner_size(logical_size);
+            window.set_min_inner_size(Some(logical_size));
+            window.set_max_inner_size(Some(logical_size));
+            LAST_SIZE.store(
+                (config.size[1] as u64) << 32 | config.size[0] as u64,
+                std::sync::atomic::Ordering::Relaxed,
+            );
+        }
+
+        let inner_size = window.inner_size();
+        let swapchain_size = [inner_size.width, inner_size.height];
+        let (swapchain, images) =
+            create_swapchain(&state.graphics, surface.clone(), swapchain_size)?;
+
+        let mut canvas = modular_canvas(&config.size, &config.elements, state)?;
+        canvas.init(state)?;
+        let view = canvas.view().unwrap();
+
+        let pipeline = {
+            let shaders = state.graphics.shared_shaders.read().unwrap();
+            state.graphics.create_pipeline_dynamic(
+                shaders.get("vert_common").unwrap().clone(), // want panic
+                shaders.get("frag_sprite").unwrap().clone(), // want panic
+                state.graphics.native_format,
+                Some(BLEND_ALPHA),
+            )
+        }?;
+        let set0 = pipeline
+            .uniform_sampler(0, view.clone(), pipeline.graphics.texture_filtering)
+            .unwrap();
+
+        let pass = pipeline
+            .create_pass(
+                [swapchain_size[0] as f32, swapchain_size[1] as f32],
+                state.graphics.quad_verts.clone(),
+                state.graphics.quad_indices.clone(),
+                vec![set0],
+            )
+            .unwrap();
+
+        Ok(PreviewState {
+            canvas,
+            pipeline,
+            pass,
+            swapchain,
+            images,
+        })
+    }
+}
+
+pub fn uidev_run(panel_name: &str) -> anyhow::Result<()> {
+    let (graphics, event_loop, window, surface) = WlxGraphics::new_window()?;
+    window.set_resizable(false);
+    window.set_title("WlxOverlay UI Preview");
+
+    USE_UINPUT.store(false, std::sync::atomic::Ordering::Relaxed);
+
+    let mut state = AppState::from_graphics(graphics.clone())?;
+    add_dummy_devices(&mut state);
+    add_dummy_screens(&mut state);
+
+    let mut preview = Some(PreviewState::new(
+        &mut state,
+        surface.clone(),
+        window.clone(),
+        panel_name,
+    )?);
+
+    let watch_path = config_io::CONFIG_ROOT_PATH.join(format!("{}.yaml", panel_name));
+    let mut path_last_modified = watch_path.metadata()?.modified()?;
+    let mut recreate = false;
+    let mut last_draw = std::time::Instant::now();
+
+    event_loop.run(move |event, elwt| {
+        elwt.set_control_flow(ControlFlow::Poll);
+
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => {
+                elwt.exit();
+            }
+            Event::WindowEvent {
+                event: WindowEvent::Resized(_),
+                ..
+            } => {
+                recreate = true;
+            }
+            Event::WindowEvent {
+                event: WindowEvent::RedrawRequested,
+                ..
+            } => {
+                let new_modified = watch_path.metadata().unwrap().modified().unwrap();
+                if new_modified > path_last_modified {
+                    recreate = true;
+                    path_last_modified = new_modified;
+                }
+
+                if recreate {
+                    drop(preview.take());
+                    preview = Some(
+                        PreviewState::new(&mut state, surface.clone(), window.clone(), panel_name)
+                            .unwrap(),
+                    );
+                    recreate = false;
+                    window.request_redraw();
+                }
+
+                {
+                    let preview = preview.as_mut().unwrap();
+                    let (image_index, _, acquire_future) =
+                        match acquire_next_image(preview.swapchain.clone(), None)
+                            .map_err(Validated::unwrap)
+                        {
+                            Ok(r) => r,
+                            Err(VulkanError::OutOfDate) => {
+                                recreate = true;
+                                return;
+                            }
+                            Err(e) => panic!("failed to acquire next image: {e}"),
+                        };
+
+                    if let Err(e) = preview.canvas.render(&mut state) {
+                        log::error!("failed to render canvas: {e}");
+                        window.request_redraw();
+                    };
+
+                    let target = preview.images[image_index as usize].clone();
+
+                    let mut cmd_buf = state
+                        .graphics
+                        .create_command_buffer(CommandBufferUsage::OneTimeSubmit)
+                        .unwrap();
+                    cmd_buf.begin_rendering(target).unwrap();
+                    cmd_buf.run_ref(&preview.pass).unwrap();
+                    cmd_buf.end_rendering().unwrap();
+                    last_draw = std::time::Instant::now();
+
+                    let command_buffer = cmd_buf.build().unwrap();
+                    vulkano::sync::now(graphics.device.clone())
+                        .join(acquire_future)
+                        .then_execute(graphics.queue.clone(), command_buffer)
+                        .unwrap()
+                        .then_swapchain_present(
+                            graphics.queue.clone(),
+                            SwapchainPresentInfo::swapchain_image_index(
+                                preview.swapchain.clone(),
+                                image_index,
+                            ),
+                        )
+                        .then_signal_fence_and_flush()
+                        .unwrap()
+                        .wait(None)
+                        .unwrap();
+                }
+            }
+            Event::AboutToWait => {
+                if last_draw.elapsed().as_millis() > 100 {
+                    window.request_redraw();
+                }
+            }
+            _ => (),
+        }
+    })?;
+
+    Ok(())
+}
+
+fn create_swapchain(
+    graphics: &WlxGraphics,
+    surface: Arc<Surface>,
+    extent: [u32; 2],
+) -> anyhow::Result<(Arc<Swapchain>, Vec<Arc<ImageView>>)> {
+    let surface_capabilities = graphics
+        .device
+        .physical_device()
+        .surface_capabilities(&surface, Default::default())
+        .unwrap(); // want panic
+
+    let (swapchain, images) = Swapchain::new(
+        graphics.device.clone(),
+        surface.clone(),
+        SwapchainCreateInfo {
+            min_image_count: surface_capabilities.min_image_count.max(2),
+            image_format: graphics.native_format,
+            image_extent: extent,
+            image_usage: ImageUsage::COLOR_ATTACHMENT,
+            composite_alpha: surface_capabilities
+                .supported_composite_alpha
+                .into_iter()
+                .next()
+                .unwrap(), // want panic
+            ..Default::default()
+        },
+    )?;
+
+    let image_views = images
+        .into_iter()
+        // want panic
+        .map(|image| ImageView::new_default(image).unwrap())
+        .collect::<Vec<_>>();
+
+    Ok((swapchain, image_views))
+}
+
+fn add_dummy_devices(app: &mut AppState) {
+    app.input_state.devices.push(TrackedDevice {
+        role: TrackedDeviceRole::Hmd,
+        soc: Some(0.42),
+        charging: true,
+    });
+    app.input_state.devices.push(TrackedDevice {
+        role: TrackedDeviceRole::LeftHand,
+        soc: Some(0.72),
+        charging: false,
+    });
+    app.input_state.devices.push(TrackedDevice {
+        role: TrackedDeviceRole::RightHand,
+        soc: Some(0.73),
+        charging: false,
+    });
+    app.input_state.devices.push(TrackedDevice {
+        role: TrackedDeviceRole::Tracker,
+        soc: Some(0.65),
+        charging: false,
+    });
+    app.input_state.devices.push(TrackedDevice {
+        role: TrackedDeviceRole::Tracker,
+        soc: Some(0.67),
+        charging: false,
+    });
+    app.input_state.devices.push(TrackedDevice {
+        role: TrackedDeviceRole::Tracker,
+        soc: Some(0.69),
+        charging: false,
+    });
+}
+
+fn add_dummy_screens(app: &mut AppState) {
+    app.screens.push(ScreenMeta {
+        name: "HDMI-A-1".into(),
+        id: 0,
+        native_handle: 0,
+    });
+    app.screens.push(ScreenMeta {
+        name: "DP-2".into(),
+        id: 0,
+        native_handle: 0,
+    });
+    app.screens.push(ScreenMeta {
+        name: "DP-3".into(),
+        id: 0,
+        native_handle: 0,
+    });
+}
@@ -1,29 +1,100 @@
+use std::path::PathBuf;
 use std::sync::Arc;

 use crate::config_io;
 use crate::config_io::get_conf_d_path;
+use crate::config_io::CONFIG_ROOT_PATH;
 use crate::gui::modular::ModularUiConfig;
-use crate::load_with_fallback;
+use crate::overlays::toast::DisplayMethod;
+use crate::overlays::toast::ToastTopic;
 use crate::state::LeftRight;
 use anyhow::bail;
+use config::Config;
+use config::File;
+use glam::vec3a;
+use glam::Affine3A;
+use glam::Quat;
+use glam::Vec3A;
+use idmap::IdMap;
 use log::error;
 use serde::Deserialize;
 use serde::Serialize;

-pub fn def_watch_pos() -> [f32; 3] {
-    [-0.03, -0.01, 0.125]
+pub type AStrMap<V> = Vec<(Arc<str>, V)>;
+
+pub trait AStrMapExt<V> {
+    fn arc_set(&mut self, key: Arc<str>, value: V) -> bool;
+    fn arc_get(&self, key: &str) -> Option<&V>;
+    fn arc_rm(&mut self, key: &str) -> Option<V>;
 }

-pub fn def_watch_rot() -> [f32; 4] {
-    [-0.7071066, 0.0007963618, 0.7071066, 0.0]
+impl<V> AStrMapExt<V> for AStrMap<V> {
+    fn arc_set(&mut self, key: Arc<str>, value: V) -> bool {
+        let index = self.iter().position(|(k, _)| k.as_ref().eq(key.as_ref()));
+        index.map(|i| self.remove(i).1);
+        self.push((key, value));
+        true
+    }
+
+    fn arc_get(&self, key: &str) -> Option<&V> {
+        self.iter()
+            .find_map(|(k, v)| if k.as_ref().eq(key) { Some(v) } else { None })
+    }
+
+    fn arc_rm(&mut self, key: &str) -> Option<V> {
+        let index = self.iter().position(|(k, _)| k.as_ref().eq(key));
+        index.map(|i| self.remove(i).1)
+    }
+}
+
+pub type AStrSet = Vec<Arc<str>>;
+
+pub trait AStrSetExt {
+    fn arc_set(&mut self, value: Arc<str>) -> bool;
+    fn arc_get(&self, value: &str) -> bool;
+    fn arc_rm(&mut self, value: &str) -> bool;
+}
+
+impl AStrSetExt for AStrSet {
+    fn arc_set(&mut self, value: Arc<str>) -> bool {
+        if self.iter().any(|v| v.as_ref().eq(value.as_ref())) {
+            return false;
+        }
+        self.push(value);
+        true
+    }
+
+    fn arc_get(&self, value: &str) -> bool {
+        self.iter().any(|v| v.as_ref().eq(value))
+    }
+
+    fn arc_rm(&mut self, value: &str) -> bool {
+        let index = self.iter().position(|v| v.as_ref().eq(value));
+        index
+            .map(|i| {
+                self.remove(i);
+                true
+            })
+            .unwrap_or(false)
+    }
+}
+
+pub type PwTokenMap = AStrMap<String>;
+
+pub fn def_watch_pos() -> Vec3A {
+    vec3a(-0.03, -0.01, 0.125)
+}
+
+pub fn def_watch_rot() -> Quat {
+    Quat::from_xyzw(-0.7071066, 0.0007963618, 0.7071066, 0.0)
 }

 pub fn def_left() -> LeftRight {
    LeftRight::Left
 }

-pub fn def_pw_tokens() -> Vec<(String, String)> {
-    Vec::new()
+pub fn def_pw_tokens() -> PwTokenMap {
+    AStrMap::new()
 }

 fn def_click_freeze_time_ms() -> u32 {
@@ -50,25 +121,53 @@ pub fn def_point7() -> f32 {
    0.7
 }

+pub fn def_point3() -> f32 {
+    0.3
+}
+
 fn def_osc_port() -> u16 {
    9000
 }

-fn def_screens() -> Vec<Arc<str>> {
-    vec![]
+fn def_screens() -> AStrSet {
+    AStrSet::new()
+}
+
+fn def_curve_values() -> AStrMap<f32> {
+    AStrMap::new()
+}
+
+fn def_transforms() -> AStrMap<Affine3A> {
+    AStrMap::new()
 }

 fn def_auto() -> Arc<str> {
    "auto".into()
 }

+fn def_empty() -> Arc<str> {
+    "".into()
+}
+
+fn def_toast_topics() -> IdMap<ToastTopic, DisplayMethod> {
+    IdMap::new()
+}
+
+fn def_font() -> Arc<str> {
+    "LiberationSans:style=Bold".into()
+}
+
+fn def_max_height() -> u16 {
+    1440
+}
+
 #[derive(Deserialize, Serialize)]
 pub struct GeneralConfig {
    #[serde(default = "def_watch_pos")]
-    pub watch_pos: [f32; 3],
+    pub watch_pos: Vec3A,

    #[serde(default = "def_watch_rot")]
-    pub watch_rot: [f32; 4],
+    pub watch_rot: Quat,

    #[serde(default = "def_left")]
    pub watch_hand: LeftRight,
@@ -82,6 +181,9 @@ pub struct GeneralConfig {
    #[serde(default = "def_true")]
    pub notifications_sound_enabled: bool,

+    #[serde(default = "def_toast_topics")]
+    pub notification_topics: IdMap<ToastTopic, DisplayMethod>,
+
    #[serde(default = "def_true")]
    pub keyboard_sound_enabled: bool,

@@ -100,9 +202,6 @@ pub struct GeneralConfig {
    #[serde(default = "def_one")]
    pub long_press_duration: f32,

-    #[serde(default = "def_pw_tokens")]
-    pub pw_tokens: Vec<(String, String)>,
-
    #[serde(default = "def_osc_port")]
    pub osc_out_port: u16,

@@ -113,10 +212,67 @@ pub struct GeneralConfig {
    pub double_cursor_fix: bool,

    #[serde(default = "def_screens")]
-    pub show_screens: Vec<Arc<str>>,
+    pub show_screens: AStrSet,
+
+    #[serde(default = "def_curve_values")]
+    pub curve_values: AStrMap<f32>,
+
+    #[serde(default = "def_transforms")]
+    pub transform_values: AStrMap<Affine3A>,

    #[serde(default = "def_auto")]
    pub capture_method: Arc<str>,
+
+    #[serde(default = "def_point7")]
+    pub xr_grab_sensitivity: f32,
+
+    #[serde(default = "def_point7")]
+    pub xr_click_sensitivity: f32,
+
+    #[serde(default = "def_point7")]
+    pub xr_alt_click_sensitivity: f32,
+
+    #[serde(default = "def_half")]
+    pub xr_grab_sensitivity_release: f32,
+
+    #[serde(default = "def_half")]
+    pub xr_click_sensitivity_release: f32,
+
+    #[serde(default = "def_half")]
+    pub xr_alt_click_sensitivity_release: f32,
+
+    #[serde(default = "def_true")]
+    pub allow_sliding: bool,
+
+    #[serde(default = "def_true")]
+    pub realign_on_showhide: bool,
+
+    #[serde(default = "def_false")]
+    pub focus_follows_mouse_mode: bool,
+
+    #[serde(default = "def_font")]
+    pub primary_font: Arc<str>,
+
+    #[serde(default = "def_one")]
+    pub space_drag_multiplier: f32,
+
+    #[serde(default = "def_empty")]
+    pub skybox_texture: Arc<str>,
+
+    #[serde(default = "def_true")]
+    pub use_skybox: bool,
+
+    #[serde(default = "def_max_height")]
+    pub screen_max_height: u16,
+
+    #[serde(default = "def_false")]
+    pub screen_render_down: bool,
+
+    #[serde(default = "def_point3")]
+    pub pointer_lerp_factor: f32,
+
+    #[serde(default = "def_false")]
+    pub space_rotate_unlocked: bool,
 }

 impl GeneralConfig {
@@ -136,18 +292,24 @@ impl GeneralConfig {
    }

    fn post_load(&self) {
-        GeneralConfig::sanitize_range("keyboard_scale", self.keyboard_scale, 0.0, 5.0);
-        GeneralConfig::sanitize_range("desktop_view_scale", self.desktop_view_scale, 0.0, 5.0);
+        GeneralConfig::sanitize_range("keyboard_scale", self.keyboard_scale, 0.05, 5.0);
+        GeneralConfig::sanitize_range("desktop_view_scale", self.desktop_view_scale, 0.05, 5.0);
    }
 }

-const FALLBACKS: [&str; 3] = [
+const FALLBACKS: [&str; 4] = [
    include_str!("res/keyboard.yaml"),
    include_str!("res/watch.yaml"),
    include_str!("res/settings.yaml"),
+    include_str!("res/anchor.yaml"),
 ];

-const FILES: [&str; 3] = ["keyboard.yaml", "watch.yaml", "settings.yaml"];
+const FILES: [&str; 4] = [
+    "keyboard.yaml",
+    "watch.yaml",
+    "settings.yaml",
+    "anchor.yaml",
+];

 #[derive(Clone, Copy)]
 #[repr(usize)]
@@ -155,6 +317,7 @@ pub enum ConfigType {
    Keyboard,
    Watch,
    Settings,
+    Anchor,
 }

 pub fn load_known_yaml<T>(config_type: ConfigType) -> T
@@ -187,35 +350,115 @@ pub fn load_custom_ui(name: &str) -> anyhow::Result<ModularUiConfig> {
 }

 pub fn load_general() -> GeneralConfig {
-    let mut yaml_data = String::new();
+    let mut settings_builder = Config::builder();

    // Add files from conf.d directory
    let path_conf_d = get_conf_d_path();
-    if let Ok(paths_unsorted) = std::fs::read_dir(path_conf_d) {
-        // Sort paths alphabetically
-        let mut paths: Vec<_> = paths_unsorted.map(|r| r.unwrap()).collect(); // TODO safe unwrap?
-        paths.sort_by_key(|dir| dir.path());
-        for path in paths {
-            if !path.file_type().unwrap().is_file() {
-                // TODO safe unwrap?
-                continue;
-            }

-            log::info!("Loading config file {}", path.path().to_string_lossy());
-
-            if let Ok(data) = std::fs::read_to_string(path.path()) {
-                yaml_data.push('\n'); // Just in case, if end of the config file was not newline
-                yaml_data.push_str(data.as_str());
-            } else {
-                // Shouldn't happen anyways
-                error!("Failed to load {}", path.path().to_string_lossy());
-            }
+    for mut base_conf in [CONFIG_ROOT_PATH.clone(), path_conf_d.clone()] {
+        base_conf.push("config.yaml");
+        if base_conf.exists() {
+            log::info!("Loading config file: {}", base_conf.to_string_lossy());
+            settings_builder = settings_builder.add_source(File::from(base_conf));
        }
    }

-    if yaml_data.is_empty() {
-        yaml_data.push_str(load_with_fallback!("config.yaml", "res/config.yaml").as_str());
+    if let Ok(paths_unsorted) = std::fs::read_dir(path_conf_d) {
+        let mut paths: Vec<_> = paths_unsorted
+            .filter_map(|r| match r {
+                Ok(entry) => Some(entry),
+                Err(e) => {
+                    error!("Failed to read conf.d directory: {}", e);
+                    None
+                }
+            })
+            .collect();
+        // Sort paths alphabetically
+        paths.sort_by_key(|dir| dir.path());
+        for path in paths {
+            log::info!("Loading config file: {}", path.path().to_string_lossy());
+            settings_builder = settings_builder.add_source(File::from(path.path()));
+        }
    }

-    serde_yaml::from_str(&yaml_data).expect("Failed to parse config.yaml")
+    match settings_builder.build() {
+        Ok(settings) => match settings.try_deserialize::<GeneralConfig>() {
+            Ok(config) => config,
+            Err(e) => {
+                panic!("Failed to deserialize settings: {}", e);
+            }
+        },
+        Err(e) => {
+            panic!("Failed to build settings: {}", e);
+        }
+    }
+}
+
+// Config that is saved from the settings panel
+
+#[derive(Serialize)]
+pub struct AutoSettings {
+    pub watch_pos: Vec3A,
+    pub watch_rot: Quat,
+    pub watch_hand: LeftRight,
+    pub watch_view_angle_min: f32,
+    pub watch_view_angle_max: f32,
+    pub notifications_enabled: bool,
+    pub notifications_sound_enabled: bool,
+    pub realign_on_showhide: bool,
+    pub allow_sliding: bool,
+    pub space_drag_multiplier: f32,
+}
+
+fn get_settings_path() -> PathBuf {
+    let mut path = config_io::get_conf_d_path();
+    path.push("zz-saved-config.json5");
+    path
+}
+pub fn save_settings(config: &GeneralConfig) -> anyhow::Result<()> {
+    let conf = AutoSettings {
+        watch_pos: config.watch_pos,
+        watch_rot: config.watch_rot,
+        watch_hand: config.watch_hand,
+        watch_view_angle_min: config.watch_view_angle_min,
+        watch_view_angle_max: config.watch_view_angle_max,
+        notifications_enabled: config.notifications_enabled,
+        notifications_sound_enabled: config.notifications_sound_enabled,
+        realign_on_showhide: config.realign_on_showhide,
+        allow_sliding: config.allow_sliding,
+        space_drag_multiplier: config.space_drag_multiplier,
+    };
+
+    let json = serde_json::to_string_pretty(&conf).unwrap(); // want panic
+    std::fs::write(get_settings_path(), json)?;
+
+    Ok(())
+}
+
+// Config that is saved after manipulating overlays
+
+#[derive(Serialize)]
+pub struct AutoState {
+    pub show_screens: AStrSet,
+    pub curve_values: AStrMap<f32>,
+    pub transform_values: AStrMap<Affine3A>,
+}
+
+fn get_state_path() -> PathBuf {
+    let mut path = config_io::get_conf_d_path();
+    path.push("zz-saved-state.json5");
+    path
+}
+
+pub fn save_layout(config: &GeneralConfig) -> anyhow::Result<()> {
+    let conf = AutoState {
+        show_screens: config.show_screens.clone(),
+        curve_values: config.curve_values.clone(),
+        transform_values: config.transform_values.clone(),
+    };
+
+    let json = serde_json::to_string_pretty(&conf).unwrap(); // want panic
+    std::fs::write(get_state_path(), json)?;
+
+    Ok(())
 }
@@ -53,19 +53,3 @@ pub fn load(filename: &str) -> Option<String> {
        None
    }
 }
-
-#[macro_export]
-macro_rules! load_with_fallback {
-    ($filename: expr,  $fallback: expr) => {
-        if let Some(data) = config_io::load($filename) {
-            data
-        } else {
-            log::info!(
-                "Config {}/{} does not exist, using internal fallback",
-                config_io::CONFIG_ROOT_PATH.to_string_lossy(),
-                $filename
-            );
-            include_str!($fallback).to_string()
-        }
-    };
-}
@@ -0,0 +1,102 @@
+use image_dds::{ImageFormat, Surface};
+use std::{io::Read, sync::Arc};
+use vulkano::{
+    buffer::{Buffer, BufferCreateInfo, BufferUsage, Subbuffer},
+    command_buffer::CopyBufferToImageInfo,
+    format::Format,
+    image::{Image, ImageCreateInfo, ImageType, ImageUsage},
+    memory::allocator::{AllocationCreateInfo, MemoryTypeFilter},
+    DeviceSize,
+};
+
+use super::WlxCommandBuffer;
+
+pub trait WlxCommandBufferDds {
+    fn texture2d_dds<R>(&mut self, r: R) -> anyhow::Result<Arc<Image>>
+    where
+        R: Read;
+}
+
+impl WlxCommandBufferDds for WlxCommandBuffer {
+    fn texture2d_dds<R>(&mut self, r: R) -> anyhow::Result<Arc<Image>>
+    where
+        R: Read,
+    {
+        let Ok(dds) = image_dds::ddsfile::Dds::read(r) else {
+            anyhow::bail!("Not a valid DDS file.\nSee: https://github.com/galister/wlx-overlay-s/wiki/Custom-Textures");
+        };
+
+        let surface = Surface::from_dds(&dds)?;
+
+        if surface.depth != 1 {
+            anyhow::bail!("Not a 2D texture.")
+        }
+
+        let image = Image::new(
+            self.graphics.memory_allocator.clone(),
+            ImageCreateInfo {
+                image_type: ImageType::Dim2d,
+                format: dds_to_vk(surface.image_format)?,
+                extent: [surface.width, surface.height, surface.depth],
+                usage: ImageUsage::TRANSFER_DST | ImageUsage::TRANSFER_SRC | ImageUsage::SAMPLED,
+                ..Default::default()
+            },
+            AllocationCreateInfo::default(),
+        )?;
+
+        let buffer: Subbuffer<[u8]> = Buffer::new_slice(
+            self.graphics.memory_allocator.clone(),
+            BufferCreateInfo {
+                usage: BufferUsage::TRANSFER_SRC,
+                ..Default::default()
+            },
+            AllocationCreateInfo {
+                memory_type_filter: MemoryTypeFilter::PREFER_HOST
+                    | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
+                ..Default::default()
+            },
+            surface.data.len() as DeviceSize,
+        )?;
+
+        buffer.write()?.copy_from_slice(surface.data);
+
+        self.command_buffer
+            .copy_buffer_to_image(CopyBufferToImageInfo::buffer_image(buffer, image.clone()))?;
+
+        Ok(image)
+    }
+}
+
+pub fn dds_to_vk(dds_fmt: ImageFormat) -> anyhow::Result<Format> {
+    match dds_fmt {
+        ImageFormat::R8Unorm => Ok(Format::R8_UNORM),
+        ImageFormat::Rgba8Unorm => Ok(Format::R8G8B8A8_UNORM),
+        ImageFormat::Rgba8UnormSrgb => Ok(Format::R8G8B8A8_SRGB),
+        ImageFormat::Rgba16Float => Ok(Format::R16G16B16A16_SFLOAT),
+        ImageFormat::Rgba32Float => Ok(Format::R32G32B32A32_SFLOAT),
+        ImageFormat::Bgra8Unorm => Ok(Format::B8G8R8A8_UNORM),
+        ImageFormat::Bgra8UnormSrgb => Ok(Format::B8G8R8A8_SRGB),
+        // DXT1
+        ImageFormat::BC1RgbaUnorm => Ok(Format::BC1_RGBA_UNORM_BLOCK),
+        ImageFormat::BC1RgbaUnormSrgb => Ok(Format::BC1_RGBA_SRGB_BLOCK),
+        // DXT3
+        ImageFormat::BC2RgbaUnorm => Ok(Format::BC2_UNORM_BLOCK),
+        ImageFormat::BC2RgbaUnormSrgb => Ok(Format::BC2_SRGB_BLOCK),
+        // DXT5
+        ImageFormat::BC3RgbaUnorm => Ok(Format::BC3_UNORM_BLOCK),
+        ImageFormat::BC3RgbaUnormSrgb => Ok(Format::BC3_SRGB_BLOCK),
+        // RGTC1
+        ImageFormat::BC4RUnorm => Ok(Format::BC4_UNORM_BLOCK),
+        ImageFormat::BC4RSnorm => Ok(Format::BC4_SNORM_BLOCK),
+        // RGTC2
+        ImageFormat::BC5RgUnorm => Ok(Format::BC5_UNORM_BLOCK),
+        ImageFormat::BC5RgSnorm => Ok(Format::BC5_SNORM_BLOCK),
+        // BPTC
+        ImageFormat::BC6hRgbUfloat => Ok(Format::BC6H_UFLOAT_BLOCK),
+        ImageFormat::BC6hRgbSfloat => Ok(Format::BC6H_SFLOAT_BLOCK),
+        // BPTC
+        ImageFormat::BC7RgbaUnorm => Ok(Format::BC7_UNORM_BLOCK),
+        ImageFormat::BC7RgbaUnormSrgb => Ok(Format::BC7_SRGB_BLOCK),
+        _ => anyhow::bail!("Unsupported format {:?}", dds_fmt),
+    }
+}
@@ -1,3 +1,5 @@
+pub(crate) mod dds;
+
 use std::{
    collections::HashMap,
    os::fd::{FromRawFd, IntoRawFd},
@@ -42,8 +44,8 @@ use vulkano::{
        allocator::StandardDescriptorSetAllocator, DescriptorSet, WriteDescriptorSet,
    },
    device::{
-        physical::PhysicalDevice, Device, DeviceCreateInfo, DeviceExtensions, Features, Queue,
-        QueueCreateInfo, QueueFlags,
+        physical::PhysicalDevice, Device, DeviceCreateInfo, DeviceExtensions, DeviceFeatures,
+        Queue, QueueCreateInfo, QueueFlags,
    },
    format::Format,
    image::{
@@ -92,10 +94,12 @@ use vulkano::{
 };

 use wlx_capture::frame::{
-    DmabufFrame, FourCC, DRM_FORMAT_ABGR8888, DRM_FORMAT_ARGB8888, DRM_FORMAT_XBGR8888,
-    DRM_FORMAT_XRGB8888,
+    DmabufFrame, FourCC, DRM_FORMAT_ABGR2101010, DRM_FORMAT_ABGR8888, DRM_FORMAT_ARGB8888,
+    DRM_FORMAT_XBGR2101010, DRM_FORMAT_XBGR8888, DRM_FORMAT_XRGB8888,
 };

+pub const DRM_FORMAT_MOD_INVALID: u64 = 0xff_ffff_ffff_ffff;
+
 #[repr(C)]
 #[derive(BufferContents, Vertex, Copy, Clone, Debug)]
 pub struct Vert2Uv {
@@ -122,6 +126,7 @@ pub struct WlxGraphics {
    pub queue: Arc<Queue>,

    pub native_format: Format,
+    pub texture_filtering: Filter,

    pub memory_allocator: Arc<StandardMemoryAllocator>,
    pub command_buffer_allocator: Arc<StandardCommandBufferAllocator>,
@@ -133,6 +138,15 @@ pub struct WlxGraphics {
    pub shared_shaders: RwLock<HashMap<&'static str, Arc<ShaderModule>>>,
 }

+fn get_dmabuf_extensions() -> DeviceExtensions {
+    DeviceExtensions {
+        khr_external_memory: true,
+        khr_external_memory_fd: true,
+        ext_external_memory_dma_buf: true,
+        ..DeviceExtensions::empty()
+    }
+}
+
 static VULKAN_LIBRARY: OnceLock<Arc<vulkano::VulkanLibrary>> = OnceLock::new();
 fn get_vulkan_library() -> &'static Arc<vulkano::VulkanLibrary> {
    VULKAN_LIBRARY.get_or_init(|| vulkano::VulkanLibrary::new().unwrap()) // want panic
@@ -181,7 +195,7 @@ impl WlxGraphics {
        let target_version = vulkano::Version::V1_3;
        let library = get_vulkan_library();

-        let vk_app_info_raw = vk::ApplicationInfo::builder()
+        let vk_app_info_raw = vk::ApplicationInfo::default()
            .application_version(0)
            .engine_version(0)
            .api_version(vk_target_version);
@@ -191,7 +205,7 @@ impl WlxGraphics {
                .create_vulkan_instance(
                    system,
                    get_instance_proc_addr,
-                    &vk::InstanceCreateInfo::builder()
+                    &vk::InstanceCreateInfo::default()
                        .application_info(&vk_app_info_raw)
                        .enabled_extension_names(&instance_extensions_raw)
                        as *const _ as *const _,
@@ -243,14 +257,22 @@ impl WlxGraphics {
            .position(|(_, q)| q.queue_flags.intersects(QueueFlags::GRAPHICS))
            .expect("Vulkan device has no graphics queue") as u32;

-        let device_extensions = DeviceExtensions {
-            khr_swapchain: true,
-            khr_external_memory: true,
-            khr_external_memory_fd: true,
-            ext_external_memory_dma_buf: true,
-            ext_image_drm_format_modifier: true,
-            ..DeviceExtensions::empty()
-        };
+        let mut device_extensions = DeviceExtensions::empty();
+        let dmabuf_extensions = get_dmabuf_extensions();
+
+        if physical_device
+            .supported_extensions()
+            .contains(&dmabuf_extensions)
+        {
+            device_extensions = device_extensions.union(&dmabuf_extensions);
+            device_extensions.ext_image_drm_format_modifier = physical_device
+                .supported_extensions()
+                .ext_image_drm_format_modifier;
+        }
+
+        if physical_device.supported_extensions().ext_filter_cubic {
+            device_extensions.ext_filter_cubic = true;
+        }

        let device_extensions_raw = device_extensions
            .into_iter()
@@ -264,30 +286,33 @@ impl WlxGraphics {
            })
            .collect::<Vec<_>>();

-        let features = Features {
+        let features = DeviceFeatures {
            dynamic_rendering: true,
            ..Default::default()
        };

        let queue_priorities = [1.0];

-        let queue_create_infos = [vk::DeviceQueueCreateInfo::builder()
+        let queue_create_infos = [vk::DeviceQueueCreateInfo::default()
            .queue_family_index(queue_family_index)
-            .queue_priorities(&queue_priorities)
-            .build()];
+            .queue_priorities(&queue_priorities)];

-        let mut device_create_info = vk::DeviceCreateInfo::builder()
+        let mut device_create_info = vk::DeviceCreateInfo::default()
            .queue_create_infos(&queue_create_infos)
-            .enabled_extension_names(&device_extensions_raw)
-            .build();
+            .enabled_extension_names(&device_extensions_raw);

-        let mut dynamic_rendering = PhysicalDeviceDynamicRenderingFeatures::builder()
-            .dynamic_rendering(true)
-            .build();
+        let mut dynamic_rendering =
+            PhysicalDeviceDynamicRenderingFeatures::default().dynamic_rendering(true);

        dynamic_rendering.p_next = device_create_info.p_next as _;
        device_create_info.p_next = (&mut dynamic_rendering) as *const _ as *const c_void;

+        let texture_filtering = if physical_device.supported_extensions().ext_filter_cubic {
+            Filter::Cubic
+        } else {
+            Filter::Linear
+        };
+
        let (device, mut queues) = unsafe {
            let vk_device = xr_instance
                .create_vulkan_device(
@@ -316,6 +341,15 @@ impl WlxGraphics {
            )
        };

+        log::debug!(
+            "  DMA-buf supported: {}",
+            device.enabled_extensions().ext_external_memory_dma_buf
+        );
+        log::debug!(
+            "  DRM format modifiers supported: {}",
+            device.enabled_extensions().ext_image_drm_format_modifier
+        );
+
        // Drop the CStrings
        device_extensions_raw
            .into_iter()
@@ -347,6 +381,7 @@ impl WlxGraphics {
            device,
            queue,
            native_format: Format::R8G8B8A8_UNORM,
+            texture_filtering,
            memory_allocator,
            command_buffer_allocator,
            descriptor_set_allocator,
@@ -366,6 +401,7 @@ impl WlxGraphics {
        //#[cfg(debug_assertions)]
        //let layers = vec!["VK_LAYER_KHRONOS_validation".to_owned()];
        //#[cfg(not(debug_assertions))]
+
        let layers = vec![];

        log::debug!("Instance exts for runtime: {:?}", &vk_instance_extensions);
@@ -382,31 +418,42 @@ impl WlxGraphics {
            },
        )?;

-        let device_extensions = DeviceExtensions {
-            khr_external_memory: true,
-            khr_external_memory_fd: true,
-            ext_external_memory_dma_buf: true,
-            ext_image_drm_format_modifier: true,
-            ..DeviceExtensions::empty()
-        };
-
-        log::debug!("Device exts for app: {:?}", &device_extensions);
+        let dmabuf_extensions = get_dmabuf_extensions();

        let (physical_device, my_extensions, queue_family_index) = instance
            .enumerate_physical_devices()?
            .filter_map(|p| {
-                let runtime_extensions = vk_device_extensions_fn(&p);
+                let mut my_extensions = vk_device_extensions_fn(&p);
+
+                if !p.supported_extensions().contains(&my_extensions) {
+                    log::debug!(
+                        "Not using {} due to missing extensions:",
+                        p.properties().device_name,
+                    );
+                    for (ext, missing) in p.supported_extensions().difference(&my_extensions) {
+                        if missing {
+                            log::debug!("  {}", ext);
+                        }
+                    }
+                    return None;
+                }
+
+                if p.supported_extensions().contains(&dmabuf_extensions) {
+                    my_extensions = my_extensions.union(&dmabuf_extensions);
+                    my_extensions.ext_image_drm_format_modifier =
+                        p.supported_extensions().ext_image_drm_format_modifier;
+                }
+
+                if p.supported_extensions().ext_filter_cubic {
+                    my_extensions.ext_filter_cubic = true;
+                }
+
                log::debug!(
                    "Device exts for {}: {:?}",
                    p.properties().device_name,
-                    &runtime_extensions
+                    &my_extensions
                );
-                let my_extensions = runtime_extensions.union(&device_extensions);
-                if p.supported_extensions().contains(&my_extensions) {
-                    Some((p, my_extensions))
-                } else {
-                    None
-                }
+                Some((p, my_extensions))
            })
            .filter_map(|(p, my_extensions)| {
                p.queue_family_properties()
@@ -430,13 +477,19 @@ impl WlxGraphics {
            physical_device.properties().device_name,
        );

+        let texture_filtering = if physical_device.supported_extensions().ext_filter_cubic {
+            Filter::Cubic
+        } else {
+            Filter::Linear
+        };
+
        let (device, mut queues) = Device::new(
            physical_device,
            DeviceCreateInfo {
                enabled_extensions: my_extensions,
-                enabled_features: Features {
+                enabled_features: DeviceFeatures {
                    dynamic_rendering: true,
-                    ..Features::empty()
+                    ..DeviceFeatures::empty()
                },
                queue_create_infos: vec![QueueCreateInfo {
                    queue_family_index,
@@ -446,6 +499,15 @@ impl WlxGraphics {
            },
        )?;

+        log::debug!(
+            "  DMA-buf supported: {}",
+            device.enabled_extensions().ext_external_memory_dma_buf
+        );
+        log::debug!(
+            "  DRM format modifiers supported: {}",
+            device.enabled_extensions().ext_image_drm_format_modifier
+        );
+
        let queue = queues
            .next()
            .ok_or_else(|| anyhow::anyhow!("no GPU queues available"))?;
@@ -471,6 +533,7 @@ impl WlxGraphics {
            queue,
            memory_allocator,
            native_format: Format::R8G8B8A8_UNORM,
+            texture_filtering,
            command_buffer_allocator,
            descriptor_set_allocator,
            quad_indices,
@@ -481,6 +544,141 @@ impl WlxGraphics {
        Ok(Arc::new(me))
    }

+    #[cfg(feature = "uidev")]
+    pub fn new_window() -> anyhow::Result<(
+        Arc<Self>,
+        winit::event_loop::EventLoop<()>,
+        Arc<winit::window::Window>,
+        Arc<vulkano::swapchain::Surface>,
+    )> {
+        use vulkano::swapchain::Surface;
+        use winit::{event_loop::EventLoop, window::Window};
+
+        let event_loop = EventLoop::new().unwrap(); // want panic
+        let mut vk_instance_extensions = Surface::required_extensions(&event_loop).unwrap();
+        vk_instance_extensions.khr_get_physical_device_properties2 = true;
+        log::debug!("Instance exts for runtime: {:?}", &vk_instance_extensions);
+
+        let instance = Instance::new(
+            get_vulkan_library().clone(),
+            InstanceCreateInfo {
+                flags: InstanceCreateFlags::ENUMERATE_PORTABILITY,
+                enabled_extensions: vk_instance_extensions,
+                ..Default::default()
+            },
+        )?;
+
+        let window = Arc::new(
+            event_loop
+                .create_window(Window::default_attributes())
+                .unwrap(), // want panic
+        );
+        let surface = Surface::from_window(instance.clone(), window.clone())?;
+
+        let mut device_extensions = DeviceExtensions::empty();
+        device_extensions.khr_swapchain = true;
+
+        log::debug!("Device exts for app: {:?}", &device_extensions);
+
+        let (physical_device, my_extensions, queue_family_index) = instance
+            .enumerate_physical_devices()?
+            .filter_map(|p| {
+                if p.supported_extensions().contains(&device_extensions) {
+                    Some((p, device_extensions))
+                } else {
+                    log::debug!(
+                        "Not using {} because it does not implement the following device extensions:",
+                        p.properties().device_name,
+                    );
+                    for (ext, missing) in p.supported_extensions().difference(&device_extensions) {
+                        if missing {
+                            log::debug!("  {}", ext);
+                        }
+                    }
+                    None
+                }
+            })
+            .filter_map(|(p, my_extensions)| {
+                p.queue_family_properties()
+                    .iter()
+                    .enumerate()
+                    .position(|(i, q)| q.queue_flags.intersects(QueueFlags::GRAPHICS)
+                    && p.surface_support(i as u32, &surface).unwrap_or(false))
+                    .map(|i| (p, my_extensions, i as u32))
+            })
+            .min_by_key(|(p, _, _)| match p.properties().device_type {
+                PhysicalDeviceType::DiscreteGpu => 0,
+                PhysicalDeviceType::IntegratedGpu => 1,
+                PhysicalDeviceType::VirtualGpu => 2,
+                PhysicalDeviceType::Cpu => 3,
+                PhysicalDeviceType::Other => 4,
+                _ => 5,
+            })
+            .expect("no suitable physical device found");
+
+        log::info!(
+            "Using vkPhysicalDevice: {}",
+            physical_device.properties().device_name,
+        );
+
+        let (device, mut queues) = Device::new(
+            physical_device,
+            DeviceCreateInfo {
+                enabled_extensions: my_extensions,
+                enabled_features: DeviceFeatures {
+                    dynamic_rendering: true,
+                    ..DeviceFeatures::empty()
+                },
+                queue_create_infos: vec![QueueCreateInfo {
+                    queue_family_index,
+                    ..Default::default()
+                }],
+                ..Default::default()
+            },
+        )?;
+
+        let native_format = device
+            .physical_device()
+            .surface_formats(&surface, Default::default())
+            .unwrap()[0] // want panic
+            .0;
+        log::info!("Using surface format: {:?}", native_format);
+
+        let queue = queues
+            .next()
+            .ok_or_else(|| anyhow::anyhow!("no GPU queues available"))?;
+
+        let memory_allocator = memory_allocator(device.clone());
+        let command_buffer_allocator = Arc::new(StandardCommandBufferAllocator::new(
+            device.clone(),
+            StandardCommandBufferAllocatorCreateInfo {
+                secondary_buffer_count: 32,
+                ..Default::default()
+            },
+        ));
+        let descriptor_set_allocator = Arc::new(StandardDescriptorSetAllocator::new(
+            device.clone(),
+            Default::default(),
+        ));
+
+        let (quad_verts, quad_indices) = Self::default_quad(memory_allocator.clone())?;
+
+        let me = Self {
+            instance,
+            device,
+            queue,
+            memory_allocator,
+            native_format,
+            texture_filtering: Filter::Linear,
+            command_buffer_allocator,
+            descriptor_set_allocator,
+            quad_indices,
+            quad_verts,
+            shared_shaders: RwLock::new(HashMap::new()),
+        };
+
+        Ok((Arc::new(me), event_loop, window, surface))
+    }
    fn default_quad(
        memory_allocator: Arc<StandardMemoryAllocator>,
    ) -> anyhow::Result<(Vert2Buf, IndexBuf)> {
@@ -600,18 +798,24 @@ impl WlxGraphics {

        let format = fourcc_to_vk(frame.format.fourcc)?;

-        let layouts: Vec<SubresourceLayout> = (0..frame.num_planes)
-            .map(|i| {
+        let mut tiling: ImageTiling = ImageTiling::Optimal;
+        let mut modifiers: Vec<u64> = vec![];
+        let mut layouts: Vec<SubresourceLayout> = vec![];
+
+        if frame.format.modifier != DRM_FORMAT_MOD_INVALID {
+            (0..frame.num_planes).for_each(|i| {
                let plane = &frame.planes[i];
-                SubresourceLayout {
+                layouts.push(SubresourceLayout {
                    offset: plane.offset as _,
                    size: 0,
                    row_pitch: plane.stride as _,
                    array_pitch: None,
                    depth_pitch: None,
-                }
-            })
-            .collect();
+                });
+                modifiers.push(frame.format.modifier);
+            });
+            tiling = ImageTiling::DrmFormatModifier;
+        };

        let image = unsafe {
            RawImage::new_unchecked(
@@ -621,8 +825,8 @@ impl WlxGraphics {
                    extent,
                    usage: ImageUsage::SAMPLED,
                    external_memory_handle_types: ExternalMemoryHandleTypes::DMA_BUF,
-                    tiling: ImageTiling::DrmFormatModifier,
-                    drm_format_modifiers: vec![frame.format.modifier],
+                    tiling,
+                    drm_format_modifiers: modifiers,
                    drm_format_modifier_plane_layouts: layouts,
                    ..Default::default()
                },
@@ -830,10 +1034,7 @@ impl WlxGraphics {
            (fns.v1_0.queue_submit)(
                self.queue.handle(),
                1,
-                [SubmitInfo::builder()
-                    .command_buffers(&[command_buffer.handle()])
-                    .build()]
-                .as_ptr(),
+                [SubmitInfo::default().command_buffers(&[command_buffer.handle()])].as_ptr(),
                fence.handle(),
            )
        }
@@ -884,7 +1085,7 @@ impl WlxCommandBuffer {
        Ok(())
    }

-    pub fn texture2d(
+    pub fn texture2d_raw(
        &mut self,
        width: u32,
        height: u32,
@@ -964,7 +1165,6 @@ pub struct WlxPipelineDynamic {}
 pub struct WlxPipelineLegacy {
    pub render_pass: Arc<RenderPass>,
    pub framebuffer: Arc<Framebuffer>,
-    pub view: Arc<ImageView>,
 }

 pub struct WlxPipeline<D> {
@@ -986,7 +1186,7 @@ impl WlxPipeline<WlxPipelineDynamic> {
        let vep = vert.entry_point("main").unwrap(); // want panic
        let fep = frag.entry_point("main").unwrap(); // want panic

-        let vertex_input_state = Vert2Uv::per_vertex().definition(&vep.info().input_interface)?;
+        let vertex_input_state = Vert2Uv::per_vertex().definition(&vep)?;

        let stages = smallvec![
            vulkano::pipeline::PipelineShaderStageCreateInfo::new(vep),
@@ -1143,7 +1343,7 @@ impl WlxPipeline<WlxPipelineLegacy> {
        let vep = vert.entry_point("main").unwrap(); // want panic
        let fep = frag.entry_point("main").unwrap(); // want panic

-        let vertex_input_state = Vert2Uv::per_vertex().definition(&vep.info().input_interface)?;
+        let vertex_input_state = Vert2Uv::per_vertex().definition(&vep)?;

        let stages = smallvec![
            vulkano::pipeline::PipelineShaderStageCreateInfo::new(vep),
@@ -1198,7 +1398,6 @@ impl WlxPipeline<WlxPipelineLegacy> {
            data: WlxPipelineLegacy {
                render_pass,
                framebuffer,
-                view: render_target,
            },
        })
    }
@@ -1414,6 +1613,8 @@ pub fn fourcc_to_vk(fourcc: FourCC) -> anyhow::Result<Format> {
        DRM_FORMAT_XBGR8888 => Ok(Format::R8G8B8A8_UNORM),
        DRM_FORMAT_ARGB8888 => Ok(Format::B8G8R8A8_UNORM),
        DRM_FORMAT_XRGB8888 => Ok(Format::B8G8R8A8_UNORM),
+        DRM_FORMAT_ABGR2101010 => Ok(Format::A2B10G10R10_UNORM_PACK32),
+        DRM_FORMAT_XBGR2101010 => Ok(Format::A2B10G10R10_UNORM_PACK32),
        _ => bail!("Unsupported format {}", fourcc),
    }
 }
@@ -1456,3 +1657,15 @@ fn memory_allocator(device: Arc<Device>) -> Arc<StandardMemoryAllocator> {

    Arc::new(StandardMemoryAllocator::new(device, create_info))
 }
+
+pub fn format_is_srgb(format: Format) -> bool {
+    matches!(
+        format,
+        Format::R8G8B8A8_SRGB
+            | Format::B8G8R8A8_SRGB
+            | Format::BC1_RGBA_SRGB_BLOCK
+            | Format::BC2_SRGB_BLOCK
+            | Format::BC3_SRGB_BLOCK
+            | Format::BC7_SRGB_BLOCK
+    )
+}
@@ -0,0 +1,249 @@
+use glam::Vec4;
+use std::sync::Arc;
+
+use vulkano::format::Format;
+
+use crate::{
+    graphics::WlxGraphics,
+    gui::{canvas::control::ControlRenderer, GuiColor, KeyCapType},
+};
+
+use super::{control::Control, Canvas, Rect};
+
+pub struct CanvasBuilder<D, S> {
+    canvas: Canvas<D, S>,
+
+    pub fg_color: GuiColor,
+    pub bg_color: GuiColor,
+    pub font_size: isize,
+}
+
+impl<D, S> CanvasBuilder<D, S> {
+    pub fn new(
+        width: usize,
+        height: usize,
+        graphics: Arc<WlxGraphics>,
+        format: Format,
+        data: D,
+    ) -> anyhow::Result<Self> {
+        Ok(Self {
+            canvas: Canvas::new(width, height, graphics, format, data)?,
+            bg_color: Vec4::ZERO,
+            fg_color: Vec4::ONE,
+            font_size: 16,
+        })
+    }
+
+    pub fn build(self) -> Canvas<D, S> {
+        self.canvas
+    }
+
+    // Creates a panel with bg_color inherited from the canvas
+    pub fn panel(&mut self, x: f32, y: f32, w: f32, h: f32, radius: f32) -> &mut Control<D, S> {
+        let idx = self.canvas.controls.len();
+        self.canvas.controls.push(Control {
+            rect: Rect { x, y, w, h },
+            corner_radius: radius,
+            bg_color: self.bg_color,
+            on_render_bg: Some(Control::render_rounded_rect),
+            ..Control::new()
+        });
+        &mut self.canvas.controls[idx]
+    }
+
+    // Creates a label with fg_color, font_size inherited from the canvas
+    pub fn label(&mut self, x: f32, y: f32, w: f32, h: f32, radius: f32, text: Arc<str>) -> &mut Control<D, S> {
+        let idx = self.canvas.controls.len();
+        self.canvas.controls.push(Control {
+            rect: Rect { x, y, w, h },
+            corner_radius: radius,
+            text,
+            fg_color: self.fg_color,
+            size: self.font_size,
+            on_render_fg: Some(Control::render_text),
+            ..Control::new()
+        });
+        &mut self.canvas.controls[idx]
+    }
+
+    // Creates a label with fg_color, font_size inherited from the canvas
+    #[allow(dead_code)]
+    pub fn label_centered(
+        &mut self,
+        x: f32,
+        y: f32,
+        w: f32,
+        h: f32,
+        radius: f32,
+        text: Arc<str>,
+    ) -> &mut Control<D, S> {
+        let idx = self.canvas.controls.len();
+        self.canvas.controls.push(Control {
+            rect: Rect { x, y, w, h },
+            corner_radius: radius,
+            text,
+            fg_color: self.fg_color,
+            size: self.font_size,
+            on_render_fg: Some(Control::render_text_centered),
+            ..Control::new()
+        });
+        &mut self.canvas.controls[idx]
+    }
+
+    // Creates a sprite. Will not draw anything until set_sprite is called.
+    pub fn sprite(&mut self, x: f32, y: f32, w: f32, h: f32) -> &mut Control<D, S> {
+        let idx = self.canvas.controls.len();
+        self.canvas.controls.push(Control {
+            rect: Rect { x, y, w, h },
+            corner_radius: 0.,
+            on_render_bg: Some(Control::render_sprite_bg),
+            ..Control::new()
+        });
+        &mut self.canvas.controls[idx]
+    }
+
+    // Creates a sprite that highlights on pointer hover. Will not draw anything until set_sprite is called.
+    pub fn sprite_interactive(&mut self, x: f32, y: f32, w: f32, h: f32) -> &mut Control<D, S> {
+        let idx = self.canvas.controls.len();
+        self.canvas.controls.push(Control {
+            rect: Rect { x, y, w, h },
+            corner_radius: 0.,
+            on_render_bg: Some(Control::render_sprite_bg),
+            on_render_hl: Some(Control::render_sprite_hl),
+            ..Control::new()
+        });
+        &mut self.canvas.controls[idx]
+    }
+
+    // Creates a button with fg_color, bg_color, font_size inherited from the canvas
+    pub fn button(&mut self, x: f32, y: f32, w: f32, h: f32, radius: f32, text: Arc<str>) -> &mut Control<D, S> {
+        let idx = self.canvas.controls.len();
+
+        self.canvas.interactive_set_idx(x, y, w, h, idx);
+        self.canvas.controls.push(Control {
+            rect: Rect { x, y, w, h },
+            corner_radius: radius,
+            text,
+            fg_color: self.fg_color,
+            bg_color: self.bg_color,
+            size: self.font_size,
+            on_render_bg: Some(Control::render_rounded_rect),
+            on_render_fg: Some(Control::render_text_centered),
+            on_render_hl: Some(Control::render_highlight),
+            ..Control::new()
+        });
+
+        &mut self.canvas.controls[idx]
+    }
+
+    pub fn key_button(
+        &mut self,
+        x: f32,
+        y: f32,
+        w: f32,
+        h: f32,
+        radius: f32,
+        cap_type: KeyCapType,
+        label: &[String],
+    ) -> &mut Control<D, S> {
+        let idx = self.canvas.controls.len();
+        self.canvas.interactive_set_idx(x, y, w, h, idx);
+
+        self.canvas.controls.push(Control {
+            rect: Rect { x, y, w, h },
+            corner_radius: radius,
+            bg_color: self.bg_color,
+            on_render_bg: Some(Control::render_rounded_rect),
+            on_render_hl: Some(Control::render_highlight),
+            ..Control::new()
+        });
+
+        let renders = match cap_type {
+            KeyCapType::Regular => {
+                let render: ControlRenderer<D, S> = Control::render_text_centered;
+                let rect = Rect {
+                    x,
+                    y,
+                    w,
+                    h: h - self.font_size as f32,
+                };
+                vec![(render, rect, 1f32)]
+            }
+            KeyCapType::RegularAltGr => {
+                let render: ControlRenderer<D, S> = Control::render_text;
+                let rect0 = Rect {
+                    x: x + 12.,
+                    y: y + (self.font_size as f32) + 12.,
+                    w,
+                    h,
+                };
+                let rect1 = Rect {
+                    x: x + w * 0.5 + 12.,
+                    y: y + h - (self.font_size as f32) + 8.,
+                    w,
+                    h,
+                };
+                vec![(render, rect0, 1.0), (render, rect1, 0.8)]
+            }
+            KeyCapType::Reversed => {
+                let render: ControlRenderer<D, S> = Control::render_text_centered;
+                let rect0 = Rect {
+                    x,
+                    y: y + 2.0,
+                    w,
+                    h: h * 0.5,
+                };
+                let rect1 = Rect {
+                    x,
+                    y: y + h * 0.5 + 2.0,
+                    w,
+                    h: h * 0.5,
+                };
+                vec![(render, rect1, 1.0), (render, rect0, 0.8)]
+            }
+            KeyCapType::ReversedAltGr => {
+                let render: ControlRenderer<D, S> = Control::render_text;
+                let rect0 = Rect {
+                    x: x + 12.,
+                    y: y + (self.font_size as f32) + 8.,
+                    w,
+                    h,
+                };
+                let rect1 = Rect {
+                    x: x + 12.,
+                    y: y + h - (self.font_size as f32) + 4.,
+                    w,
+                    h,
+                };
+                let rect2 = Rect {
+                    x: x + w * 0.5 + 8.,
+                    y: y + h - (self.font_size as f32) + 4.,
+                    w,
+                    h,
+                };
+                vec![
+                    (render, rect1, 1.0),
+                    (render, rect0, 0.8),
+                    (render, rect2, 0.8),
+                ]
+            }
+        };
+
+        for (idx, (render, rect, alpha)) in renders.into_iter().enumerate() {
+            if idx >= label.len() {
+                break;
+            }
+
+            self.canvas.controls.push(Control {
+                rect,
+                text: Arc::from(label[idx].as_str()),
+                fg_color: self.fg_color * alpha,
+                size: self.font_size,
+                on_render_fg: Some(render),
+                ..Control::new()
+            });
+        }
+
+        &mut self.canvas.controls[idx]
+    }
+}
@@ -0,0 +1,386 @@
+use glam::Vec4;
+use std::sync::Arc;
+use vulkano::image::view::ImageView;
+
+use crate::{
+    backend::input::PointerMode, graphics::WlxCommandBuffer, gui::GuiColor, state::AppState,
+};
+
+use super::{CanvasData, Rect};
+
+pub type ControlRenderer<D, S> =
+    fn(&Control<D, S>, &CanvasData<D>, &mut AppState, &mut WlxCommandBuffer) -> anyhow::Result<()>;
+
+pub type ControlRendererHl<D, S> = fn(
+    &Control<D, S>,
+    &CanvasData<D>,
+    &mut AppState,
+    &mut WlxCommandBuffer,
+    Vec4,
+) -> anyhow::Result<()>;
+
+pub(crate) struct Control<D, S> {
+    pub state: Option<S>,
+    pub rect: Rect,
+    pub corner_radius: f32,
+    pub fg_color: GuiColor,
+    pub bg_color: GuiColor,
+    pub text: Arc<str>,
+    pub size: isize,
+    pub sprite: Option<Arc<ImageView>>,
+    pub sprite_st: Vec4,
+    pub(super) dirty: bool,
+
+    pub on_update: Option<fn(&mut Self, &mut D, &mut AppState)>,
+    pub on_press: Option<fn(&mut Self, &mut D, &mut AppState, PointerMode)>,
+    pub on_release: Option<fn(&mut Self, &mut D, &mut AppState)>,
+    pub on_scroll: Option<fn(&mut Self, &mut D, &mut AppState, f32)>,
+    pub test_highlight: Option<fn(&Self, &mut D, &mut AppState) -> Option<Vec4>>,
+
+    pub(super) on_render_bg: Option<ControlRenderer<D, S>>,
+    pub(super) on_render_hl: Option<ControlRendererHl<D, S>>,
+    pub(super) on_render_fg: Option<ControlRenderer<D, S>>,
+}
+
+impl<D, S> Control<D, S> {
+    pub(super) fn new() -> Self {
+        Self {
+            rect: Rect {
+                x: 0.,
+                y: 0.,
+                w: 0.,
+                h: 0.,
+            },
+            corner_radius: 0.,
+            fg_color: Vec4::ONE,
+            bg_color: Vec4::ZERO,
+            text: Arc::from(""),
+            sprite: None,
+            sprite_st: Vec4::new(1., 1., 0., 0.),
+            dirty: true,
+            size: 24,
+            state: None,
+            on_update: None,
+            on_render_bg: None,
+            on_render_hl: None,
+            on_render_fg: None,
+            test_highlight: None,
+            on_press: None,
+            on_release: None,
+            on_scroll: None,
+        }
+    }
+
+    #[inline(always)]
+    pub fn set_text(&mut self, text: &str) {
+        if *self.text == *text {
+            return;
+        }
+        self.text = text.into();
+        self.dirty = true;
+    }
+
+    #[inline(always)]
+    pub fn set_sprite(&mut self, sprite: Arc<ImageView>) {
+        self.sprite.replace(sprite);
+        self.dirty = true;
+    }
+
+    #[inline(always)]
+    pub fn set_sprite_st(&mut self, sprite_st: Vec4) {
+        if self.sprite_st == sprite_st {
+            return;
+        }
+        self.sprite_st = sprite_st;
+        self.dirty = true;
+    }
+
+    #[inline(always)]
+    pub fn set_fg_color(&mut self, color: GuiColor) {
+        if self.fg_color == color {
+            return;
+        }
+        self.fg_color = color;
+        self.dirty = true;
+    }
+
+    pub fn render_rounded_rect(
+        &self,
+        canvas: &CanvasData<D>,
+        _: &mut AppState,
+        cmd_buffer: &mut WlxCommandBuffer,
+    ) -> anyhow::Result<()> {
+        let pass = {
+            let vertex_buffer = canvas.graphics.upload_verts(
+                canvas.width as _,
+                canvas.height as _,
+                self.rect.x,
+                self.rect.y,
+                self.rect.w,
+                self.rect.h,
+            )?;
+
+            let clamped_radius = self
+                .corner_radius
+                .min(self.rect.w / 2.0)
+                .min(self.rect.h / 2.0);
+
+            let skew_radius = [clamped_radius / self.rect.w, clamped_radius / self.rect.h];
+
+            let set0 = canvas.pipeline_bg_color.uniform_buffer(
+                0,
+                vec![
+                    self.bg_color.x,
+                    self.bg_color.y,
+                    self.bg_color.z,
+                    self.bg_color.w,
+                    skew_radius[0],
+                    skew_radius[1],
+                ],
+            )?;
+
+            canvas.pipeline_bg_color.create_pass(
+                [canvas.width as _, canvas.height as _],
+                vertex_buffer,
+                canvas.graphics.quad_indices.clone(),
+                vec![set0],
+            )?
+        };
+
+        cmd_buffer.run_ref(&pass)
+    }
+
+    pub(super) fn render_highlight(
+        &self,
+        canvas: &CanvasData<D>,
+        _: &mut AppState,
+        cmd_buffer: &mut WlxCommandBuffer,
+        color: GuiColor,
+    ) -> anyhow::Result<()> {
+        let vertex_buffer = canvas.graphics.upload_verts(
+            canvas.width as _,
+            canvas.height as _,
+            self.rect.x,
+            self.rect.y,
+            self.rect.w,
+            self.rect.h,
+        )?;
+
+        let clamped_radius = self
+            .corner_radius
+            .min(self.rect.w / 2.0)
+            .min(self.rect.h / 2.0);
+
+        let skew_radius = [clamped_radius / self.rect.w, clamped_radius / self.rect.h];
+
+        let set0 = canvas.pipeline_bg_color.uniform_buffer(
+            0,
+            vec![
+                color.x,
+                color.y,
+                color.z,
+                color.w,
+                skew_radius[0],
+                skew_radius[1],
+            ],
+        )?;
+
+        let pass = canvas.pipeline_bg_color.create_pass(
+            [canvas.width as _, canvas.height as _],
+            vertex_buffer.clone(),
+            canvas.graphics.quad_indices.clone(),
+            vec![set0],
+        )?;
+
+        cmd_buffer.run_ref(&pass)
+    }
+
+    pub(super) fn render_text(
+        &self,
+        canvas: &CanvasData<D>,
+        app: &mut AppState,
+        cmd_buffer: &mut WlxCommandBuffer,
+    ) -> anyhow::Result<()> {
+        let mut cur_y = self.rect.y;
+        for line in self.text.lines() {
+            let mut cur_x = self.rect.x;
+            for glyph in app
+                .fc
+                .get_glyphs(line, self.size, canvas.graphics.clone())?
+            {
+                if let Some(tex) = glyph.tex.clone() {
+                    let vertex_buffer = canvas.graphics.upload_verts(
+                        canvas.width as _,
+                        canvas.height as _,
+                        cur_x + glyph.left,
+                        cur_y - glyph.top,
+                        glyph.width,
+                        glyph.height,
+                    )?;
+                    let set0 = canvas.pipeline_fg_glyph.uniform_sampler(
+                        0,
+                        ImageView::new_default(tex)?,
+                        app.graphics.texture_filtering,
+                    )?;
+                    let set1 = canvas
+                        .pipeline_fg_glyph
+                        .uniform_buffer(1, self.fg_color.to_array().to_vec())?;
+                    let pass = canvas.pipeline_fg_glyph.create_pass(
+                        [canvas.width as _, canvas.height as _],
+                        vertex_buffer,
+                        canvas.graphics.quad_indices.clone(),
+                        vec![set0, set1],
+                    )?;
+                    cmd_buffer.run_ref(&pass)?;
+                }
+                cur_x += glyph.advance;
+            }
+            cur_y += (self.size as f32) * 1.5;
+        }
+        Ok(())
+    }
+
+    pub(super) fn render_text_centered(
+        &self,
+        canvas: &CanvasData<D>,
+        app: &mut AppState,
+        cmd_buffer: &mut WlxCommandBuffer,
+    ) -> anyhow::Result<()> {
+        let (w, h) = app
+            .fc
+            .get_text_size(&self.text, self.size, canvas.graphics.clone())?;
+
+        let mut cur_y = self.rect.y + (self.rect.h) - (h * 0.5) - (self.size as f32 * 0.25);
+        for line in self.text.lines() {
+            let mut cur_x = self.rect.x + (self.rect.w * 0.5) - (w * 0.5);
+            for glyph in app
+                .fc
+                .get_glyphs(line, self.size, canvas.graphics.clone())?
+            {
+                if let Some(tex) = glyph.tex.clone() {
+                    let vertex_buffer = canvas.graphics.upload_verts(
+                        canvas.width as _,
+                        canvas.height as _,
+                        cur_x + glyph.left,
+                        cur_y - glyph.top,
+                        glyph.width,
+                        glyph.height,
+                    )?;
+                    let set0 = canvas.pipeline_fg_glyph.uniform_sampler(
+                        0,
+                        ImageView::new_default(tex)?,
+                        app.graphics.texture_filtering,
+                    )?;
+                    let set1 = canvas
+                        .pipeline_fg_glyph
+                        .uniform_buffer(1, self.fg_color.to_array().to_vec())?;
+                    let pass = canvas.pipeline_fg_glyph.create_pass(
+                        [canvas.width as _, canvas.height as _],
+                        vertex_buffer,
+                        canvas.graphics.quad_indices.clone(),
+                        vec![set0, set1],
+                    )?;
+                    cmd_buffer.run_ref(&pass)?;
+                }
+                cur_x += glyph.advance;
+            }
+            cur_y += (self.size as f32) * 1.5;
+        }
+        Ok(())
+    }
+
+    pub(super) fn render_sprite_bg(
+        &self,
+        canvas: &CanvasData<D>,
+        app: &mut AppState,
+        cmd_buffer: &mut WlxCommandBuffer,
+    ) -> anyhow::Result<()> {
+        let Some(view) = self.sprite.as_ref() else {
+            return Ok(());
+        };
+
+        let vertex_buffer = canvas.graphics.upload_verts(
+            canvas.width as _,
+            canvas.height as _,
+            self.rect.x,
+            self.rect.y,
+            self.rect.w,
+            self.rect.h,
+        )?;
+        let set0 = canvas.pipeline_bg_sprite.uniform_sampler(
+            0,
+            view.clone(),
+            app.graphics.texture_filtering,
+        )?;
+
+        let uniform = vec![
+            self.sprite_st.x,
+            self.sprite_st.y,
+            self.sprite_st.z,
+            self.sprite_st.w,
+            self.fg_color.x,
+            self.fg_color.y,
+            self.fg_color.z,
+            self.fg_color.w,
+        ];
+
+        let set1 = canvas.pipeline_bg_sprite.uniform_buffer(1, uniform)?;
+
+        let pass = canvas.pipeline_bg_sprite.create_pass(
+            [canvas.width as _, canvas.height as _],
+            vertex_buffer,
+            canvas.graphics.quad_indices.clone(),
+            vec![set0, set1],
+        )?;
+        cmd_buffer.run_ref(&pass)?;
+        Ok(())
+    }
+
+    pub(super) fn render_sprite_hl(
+        &self,
+        canvas: &CanvasData<D>,
+        app: &mut AppState,
+        cmd_buffer: &mut WlxCommandBuffer,
+        color: GuiColor,
+    ) -> anyhow::Result<()> {
+        let Some(view) = self.sprite.as_ref() else {
+            return Ok(());
+        };
+
+        let vertex_buffer = canvas.graphics.upload_verts(
+            canvas.width as _,
+            canvas.height as _,
+            self.rect.x,
+            self.rect.y,
+            self.rect.w,
+            self.rect.h,
+        )?;
+        let set0 = canvas.pipeline_hl_sprite.uniform_sampler(
+            0,
+            view.clone(),
+            app.graphics.texture_filtering,
+        )?;
+
+        let uniform = vec![
+            self.sprite_st.x,
+            self.sprite_st.y,
+            self.sprite_st.z,
+            self.sprite_st.w,
+            color.x,
+            color.y,
+            color.z,
+            color.w,
+        ];
+
+        let set1 = canvas.pipeline_hl_sprite.uniform_buffer(1, uniform)?;
+
+        let pass = canvas.pipeline_hl_sprite.create_pass(
+            [canvas.width as _, canvas.height as _],
+            vertex_buffer,
+            canvas.graphics.quad_indices.clone(),
+            vec![set0, set1],
+        )?;
+        cmd_buffer.run_ref(&pass)?;
+        Ok(())
+    }
+}
@@ -0,0 +1,382 @@
+pub(crate) mod builder;
+pub(crate) mod control;
+
+use std::sync::Arc;
+
+use glam::{Vec2, Vec4};
+use vulkano::{
+    command_buffer::CommandBufferUsage,
+    format::Format,
+    image::{view::ImageView, ImageLayout},
+};
+
+use crate::{
+    backend::{
+        input::{Haptics, InteractionHandler, PointerHit},
+        overlay::{OverlayBackend, OverlayRenderer},
+    },
+    graphics::{WlxGraphics, WlxPass, WlxPipeline, WlxPipelineLegacy, BLEND_ALPHA},
+    state::AppState,
+};
+
+const RES_DIVIDER: usize = 4;
+
+pub struct Rect {
+    x: f32,
+    y: f32,
+    w: f32,
+    h: f32,
+}
+
+pub struct CanvasData<D> {
+    pub data: D,
+    pub width: usize,
+    pub height: usize,
+
+    graphics: Arc<WlxGraphics>,
+
+    pipeline_bg_color: Arc<WlxPipeline<WlxPipelineLegacy>>,
+    pipeline_fg_glyph: Arc<WlxPipeline<WlxPipelineLegacy>>,
+    pipeline_bg_sprite: Arc<WlxPipeline<WlxPipelineLegacy>>,
+    pipeline_hl_sprite: Arc<WlxPipeline<WlxPipelineLegacy>>,
+    pipeline_final: Arc<WlxPipeline<WlxPipelineLegacy>>,
+}
+
+pub struct Canvas<D, S> {
+    controls: Vec<control::Control<D, S>>,
+    canvas: CanvasData<D>,
+
+    hover_controls: [Option<usize>; 2],
+    pressed_controls: [Option<usize>; 2],
+
+    interact_map: Vec<Option<u16>>,
+    interact_stride: usize,
+    interact_rows: usize,
+
+    view_final: Arc<ImageView>,
+
+    pass_fg: WlxPass<WlxPipelineLegacy>,
+    pass_bg: WlxPass<WlxPipelineLegacy>,
+}
+
+impl<D, S> Canvas<D, S> {
+    fn new(
+        width: usize,
+        height: usize,
+        graphics: Arc<WlxGraphics>,
+        format: Format,
+        data: D,
+    ) -> anyhow::Result<Self> {
+        let tex_fg = graphics.render_texture(width as _, height as _, format)?;
+        let tex_bg = graphics.render_texture(width as _, height as _, format)?;
+        let tex_final = graphics.render_texture(width as _, height as _, format)?;
+
+        let view_fg = ImageView::new_default(tex_fg.clone())?;
+        let view_bg = ImageView::new_default(tex_bg.clone())?;
+        let view_final = ImageView::new_default(tex_final.clone())?;
+
+        let Ok(shaders) = graphics.shared_shaders.read() else {
+            anyhow::bail!("Failed to lock shared shaders for reading");
+        };
+
+        let pipeline_bg_color = graphics.create_pipeline(
+            view_bg.clone(),
+            shaders.get("vert_common").unwrap().clone(), // want panic
+            shaders.get("frag_color").unwrap().clone(),  // want panic
+            format,
+            Some(BLEND_ALPHA),
+        )?;
+
+        let pipeline_fg_glyph = graphics.create_pipeline(
+            view_fg.clone(),
+            shaders.get("vert_common").unwrap().clone(), // want panic
+            shaders.get("frag_glyph").unwrap().clone(),  // want panic
+            format,
+            Some(BLEND_ALPHA),
+        )?;
+
+        let pipeline_bg_sprite = graphics.create_pipeline(
+            view_fg.clone(),
+            shaders.get("vert_common").unwrap().clone(), // want panic
+            shaders.get("frag_sprite2").unwrap().clone(), // want panic
+            format,
+            Some(BLEND_ALPHA),
+        )?;
+
+        let pipeline_hl_sprite = graphics.create_pipeline(
+            view_fg.clone(),
+            shaders.get("vert_common").unwrap().clone(), // want panic
+            shaders.get("frag_sprite2_hl").unwrap().clone(), // want panic
+            format,
+            Some(BLEND_ALPHA),
+        )?;
+
+        let vertex_buffer =
+            graphics.upload_verts(width as _, height as _, 0., 0., width as _, height as _)?;
+
+        let pipeline_final = graphics.create_pipeline_with_layouts(
+            view_final.clone(),
+            shaders.get("vert_common").unwrap().clone(), // want panic
+            shaders.get("frag_sprite").unwrap().clone(), // want panic
+            format,
+            Some(BLEND_ALPHA),
+            ImageLayout::TransferSrcOptimal,
+            ImageLayout::TransferSrcOptimal,
+        )?;
+
+        let set_fg =
+            pipeline_final.uniform_sampler(0, view_fg.clone(), graphics.texture_filtering)?;
+        let set_bg =
+            pipeline_final.uniform_sampler(0, view_bg.clone(), graphics.texture_filtering)?;
+        let pass_fg = pipeline_final.create_pass(
+            [width as _, height as _],
+            vertex_buffer.clone(),
+            graphics.quad_indices.clone(),
+            vec![set_fg],
+        )?;
+        let pass_bg = pipeline_final.create_pass(
+            [width as _, height as _],
+            vertex_buffer.clone(),
+            graphics.quad_indices.clone(),
+            vec![set_bg],
+        )?;
+
+        let stride = width / RES_DIVIDER;
+        let rows = height / RES_DIVIDER;
+
+        Ok(Self {
+            canvas: CanvasData {
+                data,
+                width,
+                height,
+                graphics: graphics.clone(),
+                pipeline_bg_color,
+                pipeline_fg_glyph,
+                pipeline_bg_sprite,
+                pipeline_hl_sprite,
+                pipeline_final,
+            },
+            controls: Vec::new(),
+            hover_controls: [None, None],
+            pressed_controls: [None, None],
+            interact_map: vec![None; stride * rows],
+            interact_stride: stride,
+            interact_rows: rows,
+            view_final,
+            pass_fg,
+            pass_bg,
+        })
+    }
+
+    fn interactive_set_idx(&mut self, x: f32, y: f32, w: f32, h: f32, idx: usize) {
+        let (x, y, w, h) = (x as usize, y as usize, w as usize, h as usize);
+
+        let x_min = (x / RES_DIVIDER).max(0);
+        let y_min = (y / RES_DIVIDER).max(0);
+        let x_max = (x_min + (w / RES_DIVIDER)).min(self.interact_stride - 1);
+        let y_max = (y_min + (h / RES_DIVIDER)).min(self.interact_rows - 1);
+
+        for y in y_min..y_max {
+            for x in x_min..x_max {
+                self.interact_map[y * self.interact_stride + x] = Some(idx as u16);
+            }
+        }
+    }
+
+    fn interactive_get_idx(&self, uv: Vec2) -> Option<usize> {
+        let x = (uv.x * self.canvas.width as f32) as usize;
+        let y = (uv.y * self.canvas.height as f32) as usize;
+        let x = (x / RES_DIVIDER).max(0).min(self.interact_stride - 1);
+        let y = (y / RES_DIVIDER).max(0).min(self.interact_rows - 1);
+        self.interact_map[y * self.interact_stride + x].map(|x| x as usize)
+    }
+
+    fn render_bg(&mut self, app: &mut AppState) -> anyhow::Result<()> {
+        let mut cmd_buffer = self
+            .canvas
+            .graphics
+            .create_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
+        cmd_buffer.begin_render_pass(&self.canvas.pipeline_bg_color)?;
+        for c in self.controls.iter_mut() {
+            if let Some(fun) = c.on_render_bg {
+                fun(c, &self.canvas, app, &mut cmd_buffer)?;
+            }
+        }
+        cmd_buffer.end_render_pass()?;
+        cmd_buffer.build_and_execute_now()
+    }
+
+    fn render_fg(&mut self, app: &mut AppState) -> anyhow::Result<()> {
+        let mut cmd_buffer = self
+            .canvas
+            .graphics
+            .create_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
+        cmd_buffer.begin_render_pass(&self.canvas.pipeline_fg_glyph)?;
+        for c in self.controls.iter_mut() {
+            if let Some(fun) = c.on_render_fg {
+                fun(c, &self.canvas, app, &mut cmd_buffer)?;
+            }
+        }
+        cmd_buffer.end_render_pass()?;
+        cmd_buffer.build_and_execute_now()
+    }
+}
+
+impl<D, S> InteractionHandler for Canvas<D, S> {
+    fn on_left(&mut self, _app: &mut AppState, pointer: usize) {
+        self.hover_controls[pointer] = None;
+    }
+    fn on_hover(&mut self, _app: &mut AppState, hit: &PointerHit) -> Option<Haptics> {
+        let old = self.hover_controls[hit.pointer];
+        if let Some(i) = self.interactive_get_idx(hit.uv) {
+            self.hover_controls[hit.pointer] = Some(i);
+        } else {
+            self.hover_controls[hit.pointer] = None;
+        }
+        if old != self.hover_controls[hit.pointer] {
+            Some(Haptics {
+                intensity: 0.1,
+                duration: 0.01,
+                frequency: 5.0,
+            })
+        } else {
+            None
+        }
+    }
+    fn on_pointer(&mut self, app: &mut AppState, hit: &PointerHit, pressed: bool) {
+        let idx = if pressed {
+            self.interactive_get_idx(hit.uv)
+        } else {
+            self.pressed_controls[hit.pointer]
+        };
+
+        if let Some(idx) = idx {
+            let c = &mut self.controls[idx];
+            if pressed {
+                if let Some(ref mut f) = c.on_press {
+                    self.pressed_controls[hit.pointer] = Some(idx);
+                    f(c, &mut self.canvas.data, app, hit.mode);
+                }
+            } else if let Some(ref mut f) = c.on_release {
+                self.pressed_controls[hit.pointer] = None;
+                f(c, &mut self.canvas.data, app);
+            }
+        }
+    }
+    fn on_scroll(&mut self, app: &mut AppState, hit: &PointerHit, delta: f32) {
+        let idx = self.hover_controls[hit.pointer];
+
+        if let Some(idx) = idx {
+            let c = &mut self.controls[idx];
+            if let Some(ref mut f) = c.on_scroll {
+                f(c, &mut self.canvas.data, app, delta);
+            }
+        }
+    }
+}
+
+impl<D, S> OverlayRenderer for Canvas<D, S> {
+    fn init(&mut self, app: &mut AppState) -> anyhow::Result<()> {
+        self.render_bg(app)?;
+        self.render_fg(app)
+    }
+    fn pause(&mut self, _app: &mut AppState) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn resume(&mut self, _app: &mut AppState) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn render(&mut self, app: &mut AppState) -> anyhow::Result<()> {
+        let mut dirty = false;
+
+        for c in self.controls.iter_mut() {
+            if let Some(fun) = c.on_update {
+                fun(c, &mut self.canvas.data, app);
+            }
+            if c.dirty {
+                dirty = true;
+                c.dirty = false;
+            }
+        }
+
+        if dirty {
+            self.render_bg(app)?;
+            self.render_fg(app)?;
+        }
+
+        /*
+        let image = self.view_final.image().clone();
+        if self.first_render {
+            self.first_render = false;
+        } else {
+            self.canvas
+                .graphics
+                .transition_layout(
+                    image.clone(),
+                    ImageLayout::TransferSrcOptimal,
+                    ImageLayout::ColorAttachmentOptimal,
+                )
+                .wait(None)
+                .unwrap();
+        }
+        */
+
+        let mut cmd_buffer = self
+            .canvas
+            .graphics
+            .create_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
+        cmd_buffer.begin_render_pass(&self.canvas.pipeline_final)?;
+
+        // static background
+        cmd_buffer.run_ref(&self.pass_bg)?;
+
+        for (i, c) in self.controls.iter_mut().enumerate() {
+            if let Some(render) = c.on_render_hl {
+                if let Some(test) = c.test_highlight {
+                    if let Some(hl_color) = test(c, &mut self.canvas.data, app) {
+                        render(c, &self.canvas, app, &mut cmd_buffer, hl_color)?;
+                    }
+                }
+                if self.hover_controls.contains(&Some(i)) {
+                    render(
+                        c,
+                        &self.canvas,
+                        app,
+                        &mut cmd_buffer,
+                        Vec4::new(1., 1., 1., 0.3),
+                    )?;
+                }
+            }
+        }
+
+        // mostly static text
+        cmd_buffer.run_ref(&self.pass_fg)?;
+
+        cmd_buffer.end_render_pass()?;
+        cmd_buffer.build_and_execute_now()
+
+        /*
+        self.canvas
+            .graphics
+            .transition_layout(
+                image,
+                ImageLayout::ColorAttachmentOptimal,
+                ImageLayout::TransferSrcOptimal,
+            )
+            .wait(None)
+            .unwrap();
+        */
+    }
+    fn view(&mut self) -> Option<Arc<ImageView>> {
+        Some(self.view_final.clone())
+    }
+
+    fn extent(&mut self) -> Option<[u32; 3]> {
+        Some(self.view_final.image().extent())
+    }
+}
+
+impl<D, S> OverlayBackend for Canvas<D, S> {
+    fn set_renderer(&mut self, _renderer: Box<dyn OverlayRenderer>) {}
+    fn set_interaction(&mut self, _interaction: Box<dyn InteractionHandler>) {}
+}
@@ -7,9 +7,8 @@ use vulkano::{command_buffer::CommandBufferUsage, format::Format, image::Image};

 use crate::graphics::WlxGraphics;

-const PRIMARY_FONT: &str = "LiberationSans";
-
 pub struct FontCache {
+    primary_font: Arc<str>,
    fc: FontConfig,
    ft: Library,
    collections: IdMap<isize, FontCollection>,
@@ -18,6 +17,7 @@ pub struct FontCache {
 struct FontCollection {
    fonts: Vec<Font>,
    cp_map: IdMap<usize, usize>,
+    zero_glyph: Rc<Glyph>,
 }

 struct Font {
@@ -35,11 +35,12 @@ pub struct Glyph {
 }

 impl FontCache {
-    pub fn new() -> anyhow::Result<Self> {
+    pub fn new(primary_font: Arc<str>) -> anyhow::Result<Self> {
        let ft = Library::init()?;
        let fc = FontConfig::default();

        Ok(FontCache {
+            primary_font,
            fc,
            ft,
            collections: IdMap::new(),
@@ -96,6 +97,14 @@ impl FontCache {
                FontCollection {
                    fonts: Vec::new(),
                    cp_map: IdMap::new(),
+                    zero_glyph: Rc::new(Glyph {
+                        tex: None,
+                        top: 0.,
+                        left: 0.,
+                        width: 0.,
+                        height: 0.,
+                        advance: size as f32 / 3.,
+                    }),
                },
            );
        }
@@ -105,10 +114,9 @@ impl FontCache {
            return *font;
        }

-        let pattern_str = format!("{PRIMARY_FONT}-{size}:style=bold:charset={cp:04x}");
-
-        let mut pattern =
-            OwnedPattern::from_str(&pattern_str).expect("Failed to create fontconfig pattern");
+        let primary_font = self.primary_font.clone();
+        let pattern_str = format!("{primary_font}:size={size}:charset={cp:04x}");
+        let mut pattern = OwnedPattern::from_str(&pattern_str).unwrap(); // safe because PRIMARY_FONT is const
        self.fc
            .substitute(&mut pattern, fontconfig::MatchKind::Pattern);
        pattern.default_substitute();
@@ -124,12 +132,22 @@ impl FontCache {

            let font_idx = pattern.face_index().unwrap_or(0);

-            let face = self
-                .ft
-                .new_face(path, font_idx as _)
-                .expect("Failed to load font face");
-            face.set_char_size(size << 6, size << 6, 96, 96)
-                .expect("Failed to set font size");
+            let face = match self.ft.new_face(path, font_idx as _) {
+                Ok(face) => face,
+                Err(e) => {
+                    log::warn!("Failed to load font at {}: {:?}", path, e);
+                    coll.cp_map.insert(cp, 0);
+                    return 0;
+                }
+            };
+            match face.set_char_size(size << 6, size << 6, 96, 96) {
+                Ok(_) => {}
+                Err(e) => {
+                    log::warn!("Failed to set font size: {:?}", e);
+                    coll.cp_map.insert(cp, 0);
+                    return 0;
+                }
+            };

            let idx = coll.fonts.len();
            for cp in 0..0xFFFF {
@@ -137,7 +155,7 @@ impl FontCache {
                    continue;
                }
                let g = face.get_char_index(cp);
-                if g > 0 {
+                if g.is_some() {
                    coll.cp_map.insert(cp, idx);
                }
            }
@@ -156,11 +174,10 @@ impl FontCache {
            let font = Font { face, glyphs };
            coll.fonts.push(font);

-            idx
-        } else {
-            coll.cp_map.insert(cp, 0);
-            0
+            return idx;
        }
+        coll.cp_map.insert(cp, 0);
+        0
    }

    fn get_glyph_for_cp(
@@ -171,25 +188,28 @@ impl FontCache {
    ) -> anyhow::Result<Rc<Glyph>> {
        let key = self.get_font_for_cp(cp, size);

-        let font = &mut self.collections[size].fonts[key];
+        let Some(font) = &mut self.collections[size].fonts.get_mut(key) else {
+            log::warn!("No font found for codepoint: {}", cp);
+            return Ok(self.collections[size].zero_glyph.clone());
+        };

        if let Some(glyph) = font.glyphs.get(cp) {
            return Ok(glyph.clone());
        }

        if font.face.load_char(cp, LoadFlag::DEFAULT).is_err() {
-            return Ok(font.glyphs[0].clone());
+            return Ok(self.collections[size].zero_glyph.clone());
        }

        let glyph = font.face.glyph();
        if glyph.render_glyph(freetype::RenderMode::Normal).is_err() {
-            return Ok(font.glyphs[0].clone());
+            return Ok(self.collections[size].zero_glyph.clone());
        }

        let bmp = glyph.bitmap();
        let buf = bmp.buffer().to_vec();
        if buf.is_empty() {
-            return Ok(font.glyphs[0].clone());
+            return Ok(self.collections[size].zero_glyph.clone());
        }

        let metrics = glyph.metrics();
@@ -198,11 +218,11 @@ impl FontCache {
            Ok(PixelMode::Gray) => Format::R8_UNORM,
            Ok(PixelMode::Gray2) => Format::R16_SFLOAT,
            Ok(PixelMode::Gray4) => Format::R32_SFLOAT,
-            _ => return Ok(font.glyphs[0].clone()),
+            _ => return Ok(self.collections[size].zero_glyph.clone()),
        };

        let mut cmd_buffer = graphics.create_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
-        let texture = cmd_buffer.texture2d(bmp.width() as _, bmp.rows() as _, format, &buf)?;
+        let texture = cmd_buffer.texture2d_raw(bmp.width() as _, bmp.rows() as _, format, &buf)?;
        cmd_buffer.build_and_execute_now()?;

        let g = Glyph {
@@ -1,743 +1,60 @@
-use std::sync::Arc;
-
-use anyhow::bail;
-use glam::{Vec2, Vec3, Vec4};
-use vulkano::{
-    command_buffer::CommandBufferUsage,
-    format::Format,
-    image::{sampler::Filter, view::ImageView, ImageLayout},
-};
-
-use crate::{
-    backend::{
-        input::{Haptics, InteractionHandler, PointerHit, PointerMode},
-        overlay::{OverlayBackend, OverlayRenderer},
-    },
-    graphics::{
-        WlxCommandBuffer, WlxGraphics, WlxPass, WlxPipeline, WlxPipelineLegacy, BLEND_ALPHA,
-    },
-    state::AppState,
-};
+use glam::Vec4;
+use once_cell::sync::Lazy;

+pub mod canvas;
 pub mod font;
 pub mod modular;

-const RES_DIVIDER: usize = 4;
-
-struct Rect {
-    x: f32,
-    y: f32,
-    w: f32,
-    h: f32,
-}
+pub type GuiColor = Vec4;
+pub(super) static FALLBACK_COLOR: Lazy<GuiColor> = Lazy::new(|| Vec4::new(1., 0., 1., 1.));

 // Parses a color from a HTML hex string
-pub fn color_parse(html_hex: &str) -> anyhow::Result<Vec3> {
+pub fn color_parse(html_hex: &str) -> anyhow::Result<GuiColor> {
    if html_hex.len() == 7 {
        if let (Ok(r), Ok(g), Ok(b)) = (
            u8::from_str_radix(&html_hex[1..3], 16),
            u8::from_str_radix(&html_hex[3..5], 16),
            u8::from_str_radix(&html_hex[5..7], 16),
        ) {
-            return Ok(Vec3::new(r as f32 / 255., g as f32 / 255., b as f32 / 255.));
+            return Ok(Vec4::new(
+                r as f32 / 255.,
+                g as f32 / 255.,
+                b as f32 / 255.,
+                1.,
+            ));
+        }
+    } else if html_hex.len() == 9 {
+        if let (Ok(r), Ok(g), Ok(b), Ok(a)) = (
+            u8::from_str_radix(&html_hex[1..3], 16),
+            u8::from_str_radix(&html_hex[3..5], 16),
+            u8::from_str_radix(&html_hex[5..7], 16),
+            u8::from_str_radix(&html_hex[7..9], 16),
+        ) {
+            return Ok(Vec4::new(
+                r as f32 / 255.,
+                g as f32 / 255.,
+                b as f32 / 255.,
+                a as f32 / 255.,
+            ));
        }
    }
-    bail!(
+    anyhow::bail!(
        "Invalid color string: '{}', must be 7 characters long (e.g. #FF00FF)",
        &html_hex
    )
 }

-pub struct CanvasBuilder<D, S> {
-    canvas: Canvas<D, S>,
-
-    pub fg_color: Vec3,
-    pub bg_color: Vec3,
-    pub font_size: isize,
-}
-
-impl<D, S> CanvasBuilder<D, S> {
-    pub fn new(
-        width: usize,
-        height: usize,
-        graphics: Arc<WlxGraphics>,
-        format: Format,
-        data: D,
-    ) -> anyhow::Result<Self> {
-        Ok(Self {
-            canvas: Canvas::new(width, height, graphics, format, data)?,
-            bg_color: Vec3::ZERO,
-            fg_color: Vec3::ONE,
-            font_size: 16,
-        })
-    }
-
-    pub fn build(self) -> Canvas<D, S> {
-        self.canvas
-    }
-
-    // Creates a panel with bg_color inherited from the canvas
-    pub fn panel(&mut self, x: f32, y: f32, w: f32, h: f32) -> &mut Control<D, S> {
-        let idx = self.canvas.controls.len();
-        self.canvas.controls.push(Control {
-            rect: Rect { x, y, w, h },
-            bg_color: self.bg_color,
-            on_render_bg: Some(Control::render_rect),
-            ..Control::new()
-        });
-        &mut self.canvas.controls[idx]
-    }
-
-    // Creates a label with fg_color, font_size inherited from the canvas
-    pub fn label(&mut self, x: f32, y: f32, w: f32, h: f32, text: Arc<str>) -> &mut Control<D, S> {
-        let idx = self.canvas.controls.len();
-        self.canvas.controls.push(Control {
-            rect: Rect { x, y, w, h },
-            text,
-            fg_color: self.fg_color,
-            size: self.font_size,
-            on_render_fg: Some(Control::render_text),
-            ..Control::new()
-        });
-        &mut self.canvas.controls[idx]
-    }
-
-    // Creates a label with fg_color, font_size inherited from the canvas
-    #[allow(dead_code)]
-    pub fn label_centered(
-        &mut self,
-        x: f32,
-        y: f32,
-        w: f32,
-        h: f32,
-        text: Arc<str>,
-    ) -> &mut Control<D, S> {
-        let idx = self.canvas.controls.len();
-        self.canvas.controls.push(Control {
-            rect: Rect { x, y, w, h },
-            text,
-            fg_color: self.fg_color,
-            size: self.font_size,
-            on_render_fg: Some(Control::render_text_centered),
-            ..Control::new()
-        });
-        &mut self.canvas.controls[idx]
-    }
-
-    // Creates a button with fg_color, bg_color, font_size inherited from the canvas
-    pub fn button(&mut self, x: f32, y: f32, w: f32, h: f32, text: Arc<str>) -> &mut Control<D, S> {
-        let idx = self.canvas.controls.len();
-
-        self.canvas.interactive_set_idx(x, y, w, h, idx);
-        self.canvas.controls.push(Control {
-            rect: Rect { x, y, w, h },
-            text,
-            fg_color: self.fg_color,
-            bg_color: self.bg_color,
-            size: self.font_size,
-            on_render_bg: Some(Control::render_rect),
-            on_render_fg: Some(Control::render_text_centered),
-            on_render_hl: Some(Control::render_highlight),
-            ..Control::new()
-        });
-
-        &mut self.canvas.controls[idx]
-    }
-
-    pub fn key_button(
-        &mut self,
-        x: f32,
-        y: f32,
-        w: f32,
-        h: f32,
-        label: &[String],
-    ) -> &mut Control<D, S> {
-        let idx = self.canvas.controls.len();
-        self.canvas.interactive_set_idx(x, y, w, h, idx);
-
-        self.canvas.controls.push(Control {
-            rect: Rect { x, y, w, h },
-            bg_color: self.bg_color,
-            on_render_bg: Some(Control::render_rect),
-            on_render_hl: Some(Control::render_highlight),
-            ..Control::new()
-        });
-
-        for (i, item) in label.iter().enumerate().take(label.len().min(2)) {
-            self.canvas.controls.push(Control {
-                rect: if i == 0 {
-                    Rect {
-                        x: x + 4.,
-                        y: y + (self.font_size as f32) + 4.,
-                        w,
-                        h,
-                    }
-                } else {
-                    Rect {
-                        x: x + w * 0.5,
-                        y: y + h - (self.font_size as f32) + 4.,
-                        w,
-                        h,
-                    }
-                },
-                text: Arc::from(item.as_str()),
-                fg_color: self.fg_color,
-                size: self.font_size,
-                on_render_fg: Some(Control::render_text),
-                ..Control::new()
-            });
-        }
-
-        &mut self.canvas.controls[idx]
-    }
-}
-
-pub struct CanvasData<D> {
-    pub data: D,
-    pub width: usize,
-    pub height: usize,
-
-    graphics: Arc<WlxGraphics>,
-
-    pipeline_bg_color: Arc<WlxPipeline<WlxPipelineLegacy>>,
-    pipeline_fg_glyph: Arc<WlxPipeline<WlxPipelineLegacy>>,
-    pipeline_final: Arc<WlxPipeline<WlxPipelineLegacy>>,
-}
-
-pub struct Canvas<D, S> {
-    controls: Vec<Control<D, S>>,
-    canvas: CanvasData<D>,
-
-    hover_controls: [Option<usize>; 2],
-    pressed_controls: [Option<usize>; 2],
-
-    interact_map: Vec<Option<u8>>,
-    interact_stride: usize,
-    interact_rows: usize,
-
-    view_final: Arc<ImageView>,
-
-    pass_fg: WlxPass<WlxPipelineLegacy>,
-    pass_bg: WlxPass<WlxPipelineLegacy>,
-}
-
-impl<D, S> Canvas<D, S> {
-    fn new(
-        width: usize,
-        height: usize,
-        graphics: Arc<WlxGraphics>,
-        format: Format,
-        data: D,
-    ) -> anyhow::Result<Self> {
-        let tex_fg = graphics.render_texture(width as _, height as _, format)?;
-        let tex_bg = graphics.render_texture(width as _, height as _, format)?;
-        let tex_final = graphics.render_texture(width as _, height as _, format)?;
-
-        let view_fg = ImageView::new_default(tex_fg.clone())?;
-        let view_bg = ImageView::new_default(tex_bg.clone())?;
-        let view_final = ImageView::new_default(tex_final.clone())?;
-
-        let Ok(shaders) = graphics.shared_shaders.read() else {
-            bail!("Failed to lock shared shaders for reading");
-        };
-
-        let pipeline_bg_color = graphics.create_pipeline(
-            view_bg.clone(),
-            shaders.get("vert_common").unwrap().clone(), // want panic
-            shaders.get("frag_color").unwrap().clone(),  // want panic
-            format,
-            Some(BLEND_ALPHA),
-        )?;
-
-        let pipeline_fg_glyph = graphics.create_pipeline(
-            view_fg.clone(),
-            shaders.get("vert_common").unwrap().clone(), // want panic
-            shaders.get("frag_glyph").unwrap().clone(),  // want panic
-            format,
-            Some(BLEND_ALPHA),
-        )?;
-
-        let vertex_buffer =
-            graphics.upload_verts(width as _, height as _, 0., 0., width as _, height as _)?;
-
-        let pipeline_final = graphics.create_pipeline_with_layouts(
-            view_final.clone(),
-            shaders.get("vert_common").unwrap().clone(), // want panic
-            shaders.get("frag_sprite").unwrap().clone(), // want panic
-            format,
-            Some(BLEND_ALPHA),
-            ImageLayout::TransferSrcOptimal,
-            ImageLayout::TransferSrcOptimal,
-        )?;
-
-        let set_fg = pipeline_final.uniform_sampler(0, view_fg.clone(), Filter::Linear)?;
-        let set_bg = pipeline_final.uniform_sampler(0, view_bg.clone(), Filter::Linear)?;
-        let pass_fg = pipeline_final.create_pass(
-            [width as _, height as _],
-            vertex_buffer.clone(),
-            graphics.quad_indices.clone(),
-            vec![set_fg],
-        )?;
-        let pass_bg = pipeline_final.create_pass(
-            [width as _, height as _],
-            vertex_buffer.clone(),
-            graphics.quad_indices.clone(),
-            vec![set_bg],
-        )?;
-
-        let stride = width / RES_DIVIDER;
-        let rows = height / RES_DIVIDER;
-
-        Ok(Self {
-            canvas: CanvasData {
-                data,
-                width,
-                height,
-                graphics: graphics.clone(),
-                pipeline_bg_color,
-                pipeline_fg_glyph,
-                pipeline_final,
-            },
-            controls: Vec::new(),
-            hover_controls: [None, None],
-            pressed_controls: [None, None],
-            interact_map: vec![None; stride * rows],
-            interact_stride: stride,
-            interact_rows: rows,
-            view_final,
-            pass_fg,
-            pass_bg,
-        })
-    }
-
-    fn interactive_set_idx(&mut self, x: f32, y: f32, w: f32, h: f32, idx: usize) {
-        let (x, y, w, h) = (x as usize, y as usize, w as usize, h as usize);
-
-        let x_min = (x / RES_DIVIDER).max(0);
-        let y_min = (y / RES_DIVIDER).max(0);
-        let x_max = (x_min + (w / RES_DIVIDER)).min(self.interact_stride - 1);
-        let y_max = (y_min + (h / RES_DIVIDER)).min(self.interact_rows - 1);
-
-        for y in y_min..y_max {
-            for x in x_min..x_max {
-                self.interact_map[y * self.interact_stride + x] = Some(idx as u8);
-            }
-        }
-    }
-
-    fn interactive_get_idx(&self, uv: Vec2) -> Option<usize> {
-        let x = (uv.x * self.canvas.width as f32) as usize;
-        let y = (uv.y * self.canvas.height as f32) as usize;
-        let x = (x / RES_DIVIDER).max(0).min(self.interact_stride - 1);
-        let y = (y / RES_DIVIDER).max(0).min(self.interact_rows - 1);
-        self.interact_map[y * self.interact_stride + x].map(|x| x as usize)
-    }
-
-    fn render_bg(&mut self, app: &mut AppState) -> anyhow::Result<()> {
-        let mut cmd_buffer = self
-            .canvas
-            .graphics
-            .create_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
-        cmd_buffer.begin_render_pass(&self.canvas.pipeline_bg_color)?;
-        for c in self.controls.iter_mut() {
-            if let Some(fun) = c.on_render_bg {
-                fun(c, &self.canvas, app, &mut cmd_buffer)?;
-            }
-        }
-        cmd_buffer.end_render_pass()?;
-        cmd_buffer.build_and_execute_now()
-    }
-
-    fn render_fg(&mut self, app: &mut AppState) -> anyhow::Result<()> {
-        let mut cmd_buffer = self
-            .canvas
-            .graphics
-            .create_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
-        cmd_buffer.begin_render_pass(&self.canvas.pipeline_fg_glyph)?;
-        for c in self.controls.iter_mut() {
-            if let Some(fun) = c.on_render_fg {
-                fun(c, &self.canvas, app, &mut cmd_buffer)?;
-            }
-        }
-        cmd_buffer.end_render_pass()?;
-        cmd_buffer.build_and_execute_now()
-    }
-}
-
-impl<D, S> InteractionHandler for Canvas<D, S> {
-    fn on_left(&mut self, _app: &mut AppState, pointer: usize) {
-        self.hover_controls[pointer] = None;
-    }
-    fn on_hover(&mut self, _app: &mut AppState, hit: &PointerHit) -> Option<Haptics> {
-        let old = self.hover_controls[hit.pointer];
-        if let Some(i) = self.interactive_get_idx(hit.uv) {
-            self.hover_controls[hit.pointer] = Some(i);
-        } else {
-            self.hover_controls[hit.pointer] = None;
-        }
-        if old != self.hover_controls[hit.pointer] {
-            Some(Haptics {
-                intensity: 0.1,
-                duration: 0.01,
-                frequency: 5.0,
-            })
-        } else {
-            None
-        }
-    }
-    fn on_pointer(&mut self, app: &mut AppState, hit: &PointerHit, pressed: bool) {
-        let idx = if pressed {
-            self.interactive_get_idx(hit.uv)
-        } else {
-            self.pressed_controls[hit.pointer]
-        };
-
-        if let Some(idx) = idx {
-            let c = &mut self.controls[idx];
-            if pressed {
-                if let Some(ref mut f) = c.on_press {
-                    self.pressed_controls[hit.pointer] = Some(idx);
-                    f(c, &mut self.canvas.data, app, hit.mode);
-                }
-            } else if let Some(ref mut f) = c.on_release {
-                self.pressed_controls[hit.pointer] = None;
-                f(c, &mut self.canvas.data, app);
-            }
-        }
-    }
-    fn on_scroll(&mut self, app: &mut AppState, hit: &PointerHit, delta: f32) {
-        let idx = self.hover_controls[hit.pointer];
-
-        if let Some(idx) = idx {
-            let c = &mut self.controls[idx];
-            if let Some(ref mut f) = c.on_scroll {
-                f(c, &mut self.canvas.data, app, delta);
-            }
-        }
-    }
-}
-
-impl<D, S> OverlayRenderer for Canvas<D, S> {
-    fn init(&mut self, app: &mut AppState) -> anyhow::Result<()> {
-        self.render_bg(app)?;
-        self.render_fg(app)
-    }
-    fn pause(&mut self, _app: &mut AppState) -> anyhow::Result<()> {
-        Ok(())
-    }
-    fn resume(&mut self, _app: &mut AppState) -> anyhow::Result<()> {
-        Ok(())
-    }
-    fn render(&mut self, app: &mut AppState) -> anyhow::Result<()> {
-        let mut dirty = false;
-
-        for c in self.controls.iter_mut() {
-            if let Some(fun) = c.on_update {
-                fun(c, &mut self.canvas.data, app);
-            }
-            if c.dirty {
-                dirty = true;
-                c.dirty = false;
-            }
-        }
-
-        if dirty {
-            self.render_bg(app)?;
-            self.render_fg(app)?;
-        }
-
-        /*
-        let image = self.view_final.image().clone();
-        if self.first_render {
-            self.first_render = false;
-        } else {
-            self.canvas
-                .graphics
-                .transition_layout(
-                    image.clone(),
-                    ImageLayout::TransferSrcOptimal,
-                    ImageLayout::ColorAttachmentOptimal,
-                )
-                .wait(None)
-                .unwrap();
-        }
-        */
-
-        let mut cmd_buffer = self
-            .canvas
-            .graphics
-            .create_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
-        cmd_buffer.begin_render_pass(&self.canvas.pipeline_final)?;
-
-        // static background
-        cmd_buffer.run_ref(&self.pass_bg)?;
-
-        for (i, c) in self.controls.iter_mut().enumerate() {
-            if let Some(render) = c.on_render_hl {
-                if let Some(test) = c.test_highlight {
-                    if let Some(hl_color) = test(c, &mut self.canvas.data, app) {
-                        render(c, &self.canvas, app, &mut cmd_buffer, hl_color)?;
-                    }
-                }
-                if self.hover_controls.contains(&Some(i)) {
-                    render(
-                        c,
-                        &self.canvas,
-                        app,
-                        &mut cmd_buffer,
-                        Vec4::new(1., 1., 1., 0.3),
-                    )?;
-                }
-            }
-        }
-
-        // mostly static text
-        cmd_buffer.run_ref(&self.pass_fg)?;
-
-        cmd_buffer.end_render_pass()?;
-        cmd_buffer.build_and_execute_now()
-
-        /*
-        self.canvas
-            .graphics
-            .transition_layout(
-                image,
-                ImageLayout::ColorAttachmentOptimal,
-                ImageLayout::TransferSrcOptimal,
-            )
-            .wait(None)
-            .unwrap();
-        */
-    }
-    fn view(&mut self) -> Option<Arc<ImageView>> {
-        Some(self.view_final.clone())
-    }
-}
-
-impl<D, S> OverlayBackend for Canvas<D, S> {}
-
-pub struct Control<D, S> {
-    pub state: Option<S>,
-    rect: Rect,
-    fg_color: Vec3,
-    bg_color: Vec3,
-    text: Arc<str>,
-    size: isize,
-    dirty: bool,
-
-    pub on_update: Option<fn(&mut Self, &mut D, &mut AppState)>,
-    pub on_press: Option<fn(&mut Self, &mut D, &mut AppState, PointerMode)>,
-    pub on_release: Option<fn(&mut Self, &mut D, &mut AppState)>,
-    pub on_scroll: Option<fn(&mut Self, &mut D, &mut AppState, f32)>,
-    pub test_highlight: Option<fn(&Self, &mut D, &mut AppState) -> Option<Vec4>>,
-
-    on_render_bg: Option<
-        fn(&Self, &CanvasData<D>, &mut AppState, &mut WlxCommandBuffer) -> anyhow::Result<()>,
-    >,
-    on_render_hl: Option<
-        fn(&Self, &CanvasData<D>, &mut AppState, &mut WlxCommandBuffer, Vec4) -> anyhow::Result<()>,
-    >,
-    on_render_fg: Option<
-        fn(&Self, &CanvasData<D>, &mut AppState, &mut WlxCommandBuffer) -> anyhow::Result<()>,
-    >,
-}
-
-impl<D, S> Control<D, S> {
-    fn new() -> Self {
-        Self {
-            rect: Rect {
-                x: 0.,
-                y: 0.,
-                w: 0.,
-                h: 0.,
-            },
-            fg_color: Vec3::ONE,
-            bg_color: Vec3::ZERO,
-            text: Arc::from(""),
-            dirty: true,
-            size: 24,
-            state: None,
-            on_update: None,
-            on_render_bg: None,
-            on_render_hl: None,
-            on_render_fg: None,
-            test_highlight: None,
-            on_press: None,
-            on_release: None,
-            on_scroll: None,
-        }
-    }
-
-    #[inline(always)]
-    pub fn set_text(&mut self, text: &str) {
-        if *self.text == *text {
-            return;
-        }
-        self.text = text.into();
-        self.dirty = true;
-    }
-
-    #[inline(always)]
-    pub fn set_fg_color(&mut self, color: Vec3) {
-        if self.fg_color == color {
-            return;
-        }
-        self.fg_color = color;
-        self.dirty = true;
-    }
-
-    fn render_rect(
-        &self,
-        canvas: &CanvasData<D>,
-        _: &mut AppState,
-        cmd_buffer: &mut WlxCommandBuffer,
-    ) -> anyhow::Result<()> {
-        let pass = {
-            let vertex_buffer = canvas.graphics.upload_verts(
-                canvas.width as _,
-                canvas.height as _,
-                self.rect.x,
-                self.rect.y,
-                self.rect.w,
-                self.rect.h,
-            )?;
-            let set0 = canvas.pipeline_bg_color.uniform_buffer(
-                0,
-                vec![self.bg_color.x, self.bg_color.y, self.bg_color.z, 1.],
-            )?;
-            canvas.pipeline_bg_color.create_pass(
-                [canvas.width as _, canvas.height as _],
-                vertex_buffer,
-                canvas.graphics.quad_indices.clone(),
-                vec![set0],
-            )?
-        };
-
-        cmd_buffer.run_ref(&pass)
-    }
-
-    fn render_highlight(
-        &self,
-        canvas: &CanvasData<D>,
-        _: &mut AppState,
-        cmd_buffer: &mut WlxCommandBuffer,
-        color: Vec4,
-    ) -> anyhow::Result<()> {
-        let vertex_buffer = canvas.graphics.upload_verts(
-            canvas.width as _,
-            canvas.height as _,
-            self.rect.x,
-            self.rect.y,
-            self.rect.w,
-            self.rect.h,
-        )?;
-
-        let set0 = canvas
-            .pipeline_bg_color
-            .uniform_buffer(0, color.to_array().to_vec())?;
-
-        let pass = canvas.pipeline_bg_color.create_pass(
-            [canvas.width as _, canvas.height as _],
-            vertex_buffer.clone(),
-            canvas.graphics.quad_indices.clone(),
-            vec![set0],
-        )?;
-
-        cmd_buffer.run_ref(&pass)
-    }
-
-    fn render_text(
-        &self,
-        canvas: &CanvasData<D>,
-        app: &mut AppState,
-        cmd_buffer: &mut WlxCommandBuffer,
-    ) -> anyhow::Result<()> {
-        let mut cur_y = self.rect.y;
-        for line in self.text.lines() {
-            let mut cur_x = self.rect.x;
-            for glyph in app
-                .fc
-                .get_glyphs(line, self.size, canvas.graphics.clone())?
-            {
-                if let Some(tex) = glyph.tex.clone() {
-                    let vertex_buffer = canvas.graphics.upload_verts(
-                        canvas.width as _,
-                        canvas.height as _,
-                        cur_x + glyph.left,
-                        cur_y - glyph.top,
-                        glyph.width,
-                        glyph.height,
-                    )?;
-                    let set0 = canvas.pipeline_fg_glyph.uniform_sampler(
-                        0,
-                        ImageView::new_default(tex)?,
-                        Filter::Linear,
-                    )?;
-                    let set1 = canvas.pipeline_fg_glyph.uniform_buffer(
-                        1,
-                        vec![self.fg_color.x, self.fg_color.y, self.fg_color.z, 1.],
-                    )?;
-                    let pass = canvas.pipeline_fg_glyph.create_pass(
-                        [canvas.width as _, canvas.height as _],
-                        vertex_buffer,
-                        canvas.graphics.quad_indices.clone(),
-                        vec![set0, set1],
-                    )?;
-                    cmd_buffer.run_ref(&pass)?;
-                }
-                cur_x += glyph.advance;
-            }
-            cur_y += (self.size as f32) * 1.5;
-        }
-        Ok(())
-    }
-    fn render_text_centered(
-        &self,
-        canvas: &CanvasData<D>,
-        app: &mut AppState,
-        cmd_buffer: &mut WlxCommandBuffer,
-    ) -> anyhow::Result<()> {
-        let (w, h) = app
-            .fc
-            .get_text_size(&self.text, self.size, canvas.graphics.clone())?;
-
-        let mut cur_y = self.rect.y + (self.rect.h) - (h * 0.5) - (self.size as f32 * 0.25);
-        for line in self.text.lines() {
-            let mut cur_x = self.rect.x + (self.rect.w * 0.5) - (w * 0.5);
-            for glyph in app
-                .fc
-                .get_glyphs(line, self.size, canvas.graphics.clone())?
-            {
-                if let Some(tex) = glyph.tex.clone() {
-                    let vertex_buffer = canvas.graphics.upload_verts(
-                        canvas.width as _,
-                        canvas.height as _,
-                        cur_x + glyph.left,
-                        cur_y - glyph.top,
-                        glyph.width,
-                        glyph.height,
-                    )?;
-                    let set0 = canvas.pipeline_fg_glyph.uniform_sampler(
-                        0,
-                        ImageView::new_default(tex)?,
-                        Filter::Linear,
-                    )?;
-                    let set1 = canvas.pipeline_fg_glyph.uniform_buffer(
-                        1,
-                        vec![self.fg_color.x, self.fg_color.y, self.fg_color.z, 1.],
-                    )?;
-                    let pass = canvas.pipeline_fg_glyph.create_pass(
-                        [canvas.width as _, canvas.height as _],
-                        vertex_buffer,
-                        canvas.graphics.quad_indices.clone(),
-                        vec![set0, set1],
-                    )?;
-                    cmd_buffer.run_ref(&pass)?;
-                }
-                cur_x += glyph.advance;
-            }
-            cur_y += (self.size as f32) * 1.5;
-        }
-        Ok(())
-    }
+pub enum KeyCapType {
+    /// Label is in center of keycap
+    Regular,
+    /// Label on the top
+    /// AltGr symbol on bottom
+    RegularAltGr,
+    /// Primary symbol on bottom
+    /// Shift symbol on top
+    Reversed,
+    /// Primary symbol on bottom-left
+    /// Shift symbol on top-left
+    /// AltGr symbol on bottom-right
+    ReversedAltGr,
 }
@@ -1,26 +1,25 @@
 use std::{
    f32::consts::PI,
-    io::Cursor,
    ops::Add,
    process::{self, Child},
    sync::Arc,
    time::{Duration, Instant},
 };

-use glam::{Quat, Vec3A};
-use rodio::{Decoder, Source};
+use glam::{Quat, Vec4};
 use serde::Deserialize;

 use crate::{
    backend::{
-        common::{ColorChannel, OverlaySelector, SystemTask, TaskType},
+        common::OverlaySelector,
        input::PointerMode,
-        notifications::save_notifications,
        overlay::RelativeTo,
+        task::{ColorChannel, SystemTask, TaskType},
    },
+    config::{save_layout, save_settings, AStrSetExt},
    overlays::{
-        toast::Toast,
-        watch::{save_watch, WATCH_NAME},
+        toast::{Toast, ToastTopic},
+        watch::WATCH_NAME,
    },
    state::AppState,
 };
@@ -42,14 +41,27 @@ pub enum Axis {
    Z,
 }

+#[derive(Deserialize, Clone)]
+pub enum HighlightTest {
+    AllowSliding,
+    AutoRealign,
+    NotificationSounds,
+    Notifications,
+    RorateLock,
+}
+
 #[derive(Deserialize, Clone)]
 pub enum SystemAction {
+    ToggleAllowSliding,
+    ToggleAutoRealign,
    ToggleNotificationSounds,
    ToggleNotifications,
+    ToggleRotateLock,
    PlayspaceResetOffset,
    PlayspaceFixFloor,
    RecalculateExtent,
    PersistConfig,
+    PersistLayout,
 }

 #[derive(Deserialize, Clone)]
@@ -124,6 +136,9 @@ pub enum ButtonAction {
        channel: ColorChannel,
        delta: f32,
    },
+    DragMultiplier {
+        delta: f32,
+    },
    System {
        action: SystemAction,
    },
@@ -169,6 +184,7 @@ pub struct ButtonData {
    pub(super) long_middle_up: Option<Vec<ButtonAction>>,
    pub(super) scroll_down: Option<Vec<ButtonAction>>,
    pub(super) scroll_up: Option<Vec<ButtonAction>>,
+    pub(super) highlight: Option<HighlightTest>,
 }

 pub fn modular_button_init(button: &mut ModularControl, data: &ButtonData) {
@@ -176,6 +192,7 @@ pub fn modular_button_init(button: &mut ModularControl, data: &ButtonData) {
    button.on_press = Some(modular_button_dn);
    button.on_release = Some(modular_button_up);
    button.on_scroll = Some(modular_button_scroll);
+    button.test_highlight = Some(modular_button_highlight);
 }

 fn modular_button_dn(
@@ -267,6 +284,32 @@ fn modular_button_scroll(button: &mut ModularControl, _: &mut (), app: &mut AppS
    }
 }

+fn modular_button_highlight(
+    button: &ModularControl,
+    _: &mut (),
+    app: &mut AppState,
+) -> Option<Vec4> {
+    // want panic
+    let ModularData::Button(data) = button.state.as_ref().unwrap() else {
+        panic!("modular_button_highlight: button state is not Button");
+    };
+
+    if let Some(test) = &data.highlight {
+        let lit = match test {
+            HighlightTest::AllowSliding => app.session.config.allow_sliding,
+            HighlightTest::AutoRealign => app.session.config.realign_on_showhide,
+            HighlightTest::NotificationSounds => app.session.config.notifications_sound_enabled,
+            HighlightTest::Notifications => app.session.config.notifications_enabled,
+            HighlightTest::RorateLock => !app.session.config.space_rotate_unlocked,
+        };
+
+        if lit {
+            return Some(Vec4::new(1.0, 1.0, 1.0, 0.5));
+        }
+    }
+    None
+}
+
 fn handle_action(action: &ButtonAction, press: &mut PressData, app: &mut AppState) {
    match action {
        ButtonAction::Exec { command, toast } => run_exec(command, toast, press, app),
@@ -278,9 +321,13 @@ fn handle_action(action: &ButtonAction, press: &mut PressData, app: &mut AppStat
            body,
            seconds,
        } => {
-            Toast::new(message.clone(), body.clone().unwrap_or_else(|| "".into()))
-                .with_timeout(seconds.unwrap_or(5.))
-                .submit(app);
+            Toast::new(
+                ToastTopic::System,
+                message.clone(),
+                body.clone().unwrap_or_else(|| "".into()),
+            )
+            .with_timeout(seconds.unwrap_or(5.))
+            .submit(app);
        }
        ButtonAction::ColorAdjust { channel, delta } => {
            let channel = *channel;
@@ -289,11 +336,55 @@ fn handle_action(action: &ButtonAction, press: &mut PressData, app: &mut AppStat
                .enqueue(TaskType::System(SystemTask::ColorGain(channel, delta)));
        }
        ButtonAction::System { action } => run_system(action, app),
+        ButtonAction::DragMultiplier { delta } => {
+            app.session.config.space_drag_multiplier += delta;
+        }
    }
 }

+const ENABLED_DISABLED: [&str; 2] = ["enabled", "disabled"];
+
 fn run_system(action: &SystemAction, app: &mut AppState) {
    match action {
+        SystemAction::ToggleAllowSliding => {
+            app.session.config.allow_sliding = !app.session.config.allow_sliding;
+            Toast::new(
+                ToastTopic::System,
+                format!(
+                    "Sliding is {}.",
+                    ENABLED_DISABLED[app.session.config.allow_sliding as usize]
+                )
+                .into(),
+                "".into(),
+            )
+            .submit(app);
+        }
+        SystemAction::ToggleAutoRealign => {
+            app.session.config.realign_on_showhide = !app.session.config.realign_on_showhide;
+            Toast::new(
+                ToastTopic::System,
+                format!(
+                    "Auto realign is {}.",
+                    ENABLED_DISABLED[app.session.config.realign_on_showhide as usize]
+                )
+                .into(),
+                "".into(),
+            )
+            .submit(app);
+        }
+        SystemAction::ToggleRotateLock => {
+            app.session.config.space_rotate_unlocked = !app.session.config.space_rotate_unlocked;
+            Toast::new(
+                ToastTopic::System,
+                format!(
+                    "Space rotate axis lock now {}.",
+                    ENABLED_DISABLED[!app.session.config.space_rotate_unlocked as usize]
+                )
+                .into(),
+                "".into(),
+            )
+            .submit(app);
+        }
        SystemAction::PlayspaceResetOffset => {
            app.tasks
                .enqueue(TaskType::System(SystemTask::ResetPlayspace));
@@ -305,6 +396,7 @@ fn run_system(action: &SystemAction, app: &mut AppState) {
                let at = now.add(i * sec);
                let display = 5 - i;
                Toast::new(
+                    ToastTopic::System,
                    format!("Fixing floor in {}", display).into(),
                    "Place either controller on the floor.".into(),
                )
@@ -320,13 +412,10 @@ fn run_system(action: &SystemAction, app: &mut AppState) {
        SystemAction::ToggleNotifications => {
            app.session.config.notifications_enabled = !app.session.config.notifications_enabled;
            Toast::new(
+                ToastTopic::System,
                format!(
                    "Notifications are {}.",
-                    if app.session.config.notifications_enabled {
-                        "enabled"
-                    } else {
-                        "disabled"
-                    }
+                    ENABLED_DISABLED[app.session.config.notifications_enabled as usize]
                )
                .into(),
                "".into(),
@@ -337,13 +426,10 @@ fn run_system(action: &SystemAction, app: &mut AppState) {
            app.session.config.notifications_sound_enabled =
                !app.session.config.notifications_sound_enabled;
            Toast::new(
+                ToastTopic::System,
                format!(
                    "Notification sounds are {}.",
-                    if app.session.config.notifications_sound_enabled {
-                        "enabled"
-                    } else {
-                        "disabled"
-                    }
+                    ENABLED_DISABLED[app.session.config.notifications_sound_enabled as usize]
                )
                .into(),
                "".into(),
@@ -351,11 +437,13 @@ fn run_system(action: &SystemAction, app: &mut AppState) {
            .submit(app);
        }
        SystemAction::PersistConfig => {
-            if let Err(e) = save_watch(app) {
-                log::error!("Failed to save watch config: {:?}", e);
-            };
-            if let Err(e) = save_notifications(app) {
-                log::error!("Failed to save notifications config: {:?}", e);
+            if let Err(e) = save_settings(&app.session.config) {
+                log::error!("Failed to save config: {:?}", e);
+            }
+        }
+        SystemAction::PersistLayout => {
+            if let Err(e) = save_layout(&app.session.config) {
+                log::error!("Failed to save layout: {:?}", e);
            }
        }
    }
@@ -385,7 +473,7 @@ fn run_exec(args: &ExecArgs, toast: &Option<Arc<str>>, press: &mut PressData, ap
        Ok(proc) => {
            press.child = Some(proc);
            if let Some(toast) = toast.as_ref() {
-                Toast::new(toast.clone(), "".into()).submit(app);
+                Toast::new(ToastTopic::System, toast.clone(), "".into()).submit(app);
            }
        }
        Err(e) => {
@@ -400,11 +488,11 @@ fn run_watch(data: &WatchAction, app: &mut AppState) {
            app.tasks.enqueue(TaskType::Overlay(
                OverlaySelector::Name(WATCH_NAME.into()),
                Box::new(|app, o| {
-                    if o.saved_scale.is_none() {
-                        o.saved_scale = Some(o.spawn_scale);
+                    if o.saved_transform.is_none() {
                        o.want_visible = false;
-                        o.saved_scale = Some(0.0);
+                        o.saved_transform = Some(o.transform);
                        Toast::new(
+                            ToastTopic::System,
                            "Watch hidden".into(),
                            "Use show/hide binding to restore.".into(),
                        )
@@ -412,8 +500,9 @@ fn run_watch(data: &WatchAction, app: &mut AppState) {
                        .submit(app);
                    } else {
                        o.want_visible = true;
-                        o.saved_scale = None;
-                        Toast::new("Watch restored".into(), "".into()).submit(app);
+                        o.saved_transform = None;
+                        Toast::new(ToastTopic::System, "Watch restored".into(), "".into())
+                            .submit(app);
                    }
                }),
            ));
@@ -425,20 +514,24 @@ fn run_watch(data: &WatchAction, app: &mut AppState) {
                Box::new(|app, o| {
                    if let RelativeTo::Hand(0) = o.relative_to {
                        o.relative_to = RelativeTo::Hand(1);
-                        o.spawn_rotation = Quat::from_slice(&app.session.config.watch_rot)
+                        o.spawn_rotation = app.session.config.watch_rot
                            * Quat::from_rotation_x(PI)
                            * Quat::from_rotation_z(PI);
-                        o.spawn_point = Vec3A::from_slice(&app.session.config.watch_pos);
+                        o.spawn_point = app.session.config.watch_pos;
                        o.spawn_point.x *= -1.;
                    } else {
                        o.relative_to = RelativeTo::Hand(0);
-                        o.spawn_rotation = Quat::from_slice(&app.session.config.watch_rot);
-                        o.spawn_point = Vec3A::from_slice(&app.session.config.watch_pos);
+                        o.spawn_rotation = app.session.config.watch_rot;
+                        o.spawn_point = app.session.config.watch_pos;
                    }
                    o.dirty = true;
-                    Toast::new("Watch switched".into(), "Check your other hand".into())
-                        .with_timeout(3.)
-                        .submit(app);
+                    Toast::new(
+                        ToastTopic::System,
+                        "Watch switched".into(),
+                        "Check your other hand".into(),
+                    )
+                    .with_timeout(3.)
+                    .submit(app);
                }),
            ));
            audio_thump(app);
@@ -475,7 +568,7 @@ fn run_watch(data: &WatchAction, app: &mut AppState) {
                OverlaySelector::Name(WATCH_NAME.into()),
                Box::new(move |app, o| {
                    o.spawn_rotation *= rot;
-                    app.session.config.watch_rot = o.spawn_rotation.into();
+                    app.session.config.watch_rot = o.spawn_rotation;
                    o.dirty = true;
                }),
            ));
@@ -491,7 +584,7 @@ fn run_watch(data: &WatchAction, app: &mut AppState) {
                OverlaySelector::Name(WATCH_NAME.into()),
                Box::new(move |app, o| {
                    o.spawn_point[axis] += delta;
-                    app.session.config.watch_pos = o.spawn_point.into();
+                    app.session.config.watch_pos = o.spawn_point;
                    o.dirty = true;
                }),
            ));
@@ -506,7 +599,12 @@ fn run_overlay(overlay: &OverlaySelector, action: &OverlayAction, app: &mut AppS
                overlay.clone(),
                Box::new(|app, o| {
                    o.reset(app, true);
-                    Toast::new(format!("{} has been reset!", o.name).into(), "".into()).submit(app);
+                    Toast::new(
+                        ToastTopic::System,
+                        format!("{} has been reset!", o.name).into(),
+                        "".into(),
+                    )
+                    .submit(app);
                }),
            ));
        }
@@ -519,6 +617,20 @@ fn run_overlay(overlay: &OverlaySelector, action: &OverlayAction, app: &mut AppS
                        o.show_hide = o.want_visible;
                        o.reset(app, false);
                    }
+
+                    let mut state_dirty = false;
+                    if !o.want_visible {
+                        state_dirty |= app.session.config.show_screens.arc_rm(o.name.as_ref());
+                    } else if o.want_visible {
+                        state_dirty |= app.session.config.show_screens.arc_set(o.name.clone());
+                    }
+
+                    if state_dirty {
+                        match save_layout(&app.session.config) {
+                            Ok(_) => log::debug!("Saved state"),
+                            Err(e) => log::error!("Failed to save state: {:?}", e),
+                        }
+                    }
                }),
            ));
        }
@@ -531,13 +643,18 @@ fn run_overlay(overlay: &OverlaySelector, action: &OverlayAction, app: &mut AppS
                    o.show_hide = o.recenter;
                    if !o.recenter {
                        Toast::new(
+                            ToastTopic::System,
                            format!("{} is now locked in place!", o.name).into(),
                            "".into(),
                        )
                        .submit(app);
                    } else {
-                        Toast::new(format!("{} is now unlocked!", o.name).into(), "".into())
-                            .submit(app);
+                        Toast::new(
+                            ToastTopic::System,
+                            format!("{} is now unlocked!", o.name).into(),
+                            "".into(),
+                        )
+                        .submit(app);
                    }
                }),
            ));
@@ -550,13 +667,18 @@ fn run_overlay(overlay: &OverlaySelector, action: &OverlayAction, app: &mut AppS
                    o.interactable = !o.interactable;
                    if !o.interactable {
                        Toast::new(
+                            ToastTopic::System,
                            format!("{} is now non-interactable!", o.name).into(),
                            "".into(),
                        )
                        .submit(app);
                    } else {
-                        Toast::new(format!("{} is now interactable!", o.name).into(), "".into())
-                            .submit(app);
+                        Toast::new(
+                            ToastTopic::System,
+                            format!("{} is now interactable!", o.name).into(),
+                            "".into(),
+                        )
+                        .submit(app);
                    }
                }),
            ));
@@ -587,9 +709,13 @@ fn run_window(window: &Arc<str>, action: &WindowAction, app: &mut AppState) {
                Box::new({
                    let name = window.clone();
                    move |app| {
-                        Toast::new("Check your desktop for popup.".into(), "".into())
-                            .with_sound(true)
-                            .submit(app);
+                        Toast::new(
+                            ToastTopic::System,
+                            "Check your desktop for popup.".into(),
+                            "".into(),
+                        )
+                        .with_sound(true)
+                        .submit(app);
                        crate::overlays::mirror::new_mirror(name.clone(), false, &app.session)
                    }
                }),
@@ -613,11 +739,8 @@ fn run_window(window: &Arc<str>, action: &WindowAction, app: &mut AppState) {
    }
 }

+const THUMP_AUDIO_WAV: &[u8] = include_bytes!("../../res/380885.wav");
+
 fn audio_thump(app: &mut AppState) {
-    if let Some(handle) = app.audio.get_handle() {
-        let wav = include_bytes!("../../res/380885.wav");
-        let cursor = Cursor::new(wav);
-        let source = Decoder::new_wav(cursor).unwrap();
-        let _ = handle.play_raw(source.convert_samples());
-    }
+    app.audio.play(THUMP_AUDIO_WAV);
 }
@@ -1,6 +1,6 @@
 use chrono::Local;
 use chrono_tz::Tz;
-use glam::Vec3;
+use glam::Vec4;
 use smallvec::SmallVec;
 use std::{
    io::Read,
@@ -13,7 +13,7 @@ use crate::{gui::modular::FALLBACK_COLOR, state::AppState};

 use serde::Deserialize;

-use super::{color_parse_or_default, ExecArgs, ModularControl, ModularData};
+use super::{color_parse_or_default, ExecArgs, GuiColor, ModularControl, ModularData};

 #[derive(Deserialize)]
 #[serde(tag = "source")]
@@ -29,32 +29,45 @@ pub enum LabelContent {
        format: Arc<str>,
        timezone: Option<Arc<str>>,
    },
+    Timer {
+        format: Arc<str>,
+    },
    Battery {
        device: usize,
        low_threshold: f32,
        low_color: Arc<str>,
        charging_color: Arc<str>,
    },
+    DragMultiplier,
+    Ipd,
 }

 pub enum LabelData {
    Battery {
        device: usize,
        low_threshold: f32,
-        normal_color: Vec3,
-        low_color: Vec3,
-        charging_color: Vec3,
+        normal_color: GuiColor,
+        low_color: GuiColor,
+        charging_color: GuiColor,
    },
    Clock {
        format: Arc<str>,
        timezone: Option<Tz>,
    },
+    Timer {
+        format: Arc<str>,
+        start: Instant,
+    },
    Exec {
        last_exec: Instant,
        interval: f32,
        command: Vec<Arc<str>>,
        child: Option<process::Child>,
    },
+    Ipd {
+        last_ipd: f32,
+    },
+    DragMultiplier,
 }

 pub fn modular_label_init(label: &mut ModularControl, content: &LabelContent) {
@@ -75,7 +88,7 @@ pub fn modular_label_init(label: &mut ModularControl, content: &LabelContent) {
            let tz: Option<Tz> = timezone.as_ref().map(|tz| {
                tz.parse().unwrap_or_else(|_| {
                    log::error!("Failed to parse timezone '{}'", &tz);
-                    label.set_fg_color(FALLBACK_COLOR);
+                    label.set_fg_color(*FALLBACK_COLOR);
                    Tz::UTC
                })
            });
@@ -85,6 +98,10 @@ pub fn modular_label_init(label: &mut ModularControl, content: &LabelContent) {
                timezone: tz,
            })
        }
+        LabelContent::Timer { format } => Some(LabelData::Timer {
+            format: format.clone(),
+            start: Instant::now(),
+        }),
        LabelContent::Exec { command, interval } => Some(LabelData::Exec {
            last_exec: Instant::now(),
            interval: *interval,
@@ -95,6 +112,8 @@ pub fn modular_label_init(label: &mut ModularControl, content: &LabelContent) {
            label.set_text(text);
            None
        }
+        LabelContent::Ipd => Some(LabelData::Ipd { last_ipd: -1. }),
+        LabelContent::DragMultiplier => Some(LabelData::DragMultiplier),
    };

    if let Some(state) = state {
@@ -104,6 +123,7 @@ pub fn modular_label_init(label: &mut ModularControl, content: &LabelContent) {
 }

 pub(super) fn label_update(control: &mut ModularControl, _: &mut (), app: &mut AppState) {
+    // want panic
    let ModularData::Label(data) = control.state.as_mut().unwrap() else {
        panic!("Label control has no state");
    };
@@ -137,7 +157,7 @@ pub(super) fn label_update(control: &mut ModularControl, _: &mut (), app: &mut A
                        };
                        (text, color)
                    })
-                    .unwrap_or_else(|| ("".into(), Vec3::ZERO));
+                    .unwrap_or_else(|| ("".into(), Vec4::ZERO));

                control.set_text(&text);
                control.set_fg_color(color);
@@ -155,6 +175,14 @@ pub(super) fn label_update(control: &mut ModularControl, _: &mut (), app: &mut A
                control.set_text(&format!("{}", &date.format(&format)));
            }
        }
+        LabelData::Timer { format, start } => {
+            let mut format = format.clone().to_lowercase();
+            let duration = start.elapsed().as_secs();
+            format = format.replace("%s", &format!("{:02}", (duration % 60)));
+            format = format.replace("%m", &format!("{:02}", ((duration / 60) % 60)));
+            format = format.replace("%h", &format!("{:02}", ((duration / 60) / 60)));
+            control.set_text(&format);
+        }
        LabelData::Exec {
            last_exec,
            interval,
@@ -219,5 +247,14 @@ pub(super) fn label_update(control: &mut ModularControl, _: &mut (), app: &mut A
                };
            }
        }
+        LabelData::Ipd { last_ipd } => {
+            if (app.input_state.ipd - *last_ipd).abs() > 0.05 {
+                *last_ipd = app.input_state.ipd;
+                control.set_text(&format!("{:.1}", app.input_state.ipd));
+            }
+        }
+        LabelData::DragMultiplier => {
+            control.set_text(&format!("{:.1}", app.session.config.space_drag_multiplier));
+        }
    }
 }
@@ -1,30 +1,30 @@
 pub mod button;
 pub mod label;
-//pub mod slider;

-use std::sync::Arc;
+use std::{fs::File, sync::Arc};

-use glam::Vec3;
+use glam::Vec4;
 use serde::Deserialize;
+use vulkano::{command_buffer::CommandBufferUsage, image::view::ImageView};

-use crate::{backend::common::OverlaySelector, state::AppState};
+use crate::{
+    backend::common::OverlaySelector, config::AStrMapExt, config_io::CONFIG_ROOT_PATH,
+    graphics::dds::WlxCommandBufferDds, state::AppState,
+};

 use self::{
    button::{modular_button_init, ButtonAction, ButtonData, OverlayAction},
    label::{modular_label_init, LabelContent, LabelData},
 };

-use super::{color_parse, Canvas, CanvasBuilder, Control};
+use super::{
+    canvas::{builder::CanvasBuilder, control::Control, Canvas},
+    color_parse, GuiColor, FALLBACK_COLOR,
+};

 type ModularControl = Control<(), ModularData>;
 type ExecArgs = Vec<Arc<str>>;

-const FALLBACK_COLOR: Vec3 = Vec3 {
-    x: 1.,
-    y: 0.,
-    z: 1.,
-};
-
 #[derive(Deserialize)]
 pub struct ModularUiConfig {
    pub width: f32,
@@ -54,17 +54,33 @@ pub struct OverlayListTemplate {
 pub enum ModularElement {
    Panel {
        rect: [f32; 4],
+        corner_radius: Option<f32>,
        bg_color: Arc<str>,
    },
    Label {
        rect: [f32; 4],
+        corner_radius: Option<f32>,
        font_size: isize,
        fg_color: Arc<str>,
        #[serde(flatten)]
        data: LabelContent,
    },
+    CenteredLabel {
+        rect: [f32; 4],
+        corner_radius: Option<f32>,
+        font_size: isize,
+        fg_color: Arc<str>,
+        #[serde(flatten)]
+        data: LabelContent,
+    },
+    Sprite {
+        rect: [f32; 4],
+        sprite: Arc<str>,
+        sprite_st: Option<[f32; 4]>,
+    },
    Button {
        rect: [f32; 4],
+        corner_radius: Option<f32>,
        font_size: isize,
        fg_color: Arc<str>,
        bg_color: Arc<str>,
@@ -75,6 +91,7 @@ pub enum ModularElement {
    /// Convenience type to save you from having to create a bunch of labels
    BatteryList {
        rect: [f32; 4],
+        corner_radius: Option<f32>,
        font_size: isize,
        fg_color: Arc<str>,
        fg_color_low: Arc<str>,
@@ -85,6 +102,7 @@ pub enum ModularElement {
    },
    OverlayList {
        rect: [f32; 4],
+        corner_radius: Option<f32>,
        font_size: isize,
        fg_color: Arc<str>,
        bg_color: Arc<str>,
@@ -114,13 +132,13 @@ pub enum ModularData {
 pub fn modular_canvas(
    size: &[u32; 2],
    elements: &[ModularElement],
-    state: &AppState,
+    state: &mut AppState,
 ) -> anyhow::Result<Canvas<(), ModularData>> {
    let mut canvas = CanvasBuilder::new(
        size[0] as _,
        size[1] as _,
        state.graphics.clone(),
-        state.format,
+        state.graphics.native_format,
        (),
    )?;
    let empty_str: Arc<str> = Arc::from("");
@@ -128,38 +146,94 @@ pub fn modular_canvas(
        match elem {
            ModularElement::Panel {
                rect: [x, y, w, h],
+                corner_radius,
                bg_color,
            } => {
-                canvas.bg_color = color_parse(bg_color).unwrap_or(FALLBACK_COLOR);
-                canvas.panel(*x, *y, *w, *h);
+                canvas.bg_color = color_parse(bg_color).unwrap_or(*FALLBACK_COLOR);
+                canvas.panel(*x, *y, *w, *h, corner_radius.unwrap_or_default());
            }
            ModularElement::Label {
                rect: [x, y, w, h],
+                corner_radius,
                font_size,
                fg_color,
                data,
            } => {
                canvas.font_size = *font_size;
-                canvas.fg_color = color_parse(fg_color).unwrap_or(FALLBACK_COLOR);
-                let label = canvas.label(*x, *y, *w, *h, empty_str.clone());
+                canvas.fg_color = color_parse(fg_color).unwrap_or(*FALLBACK_COLOR);
+                let label = canvas.label(
+                    *x,
+                    *y,
+                    *w,
+                    *h,
+                    corner_radius.unwrap_or_default(),
+                    empty_str.clone(),
+                );
                modular_label_init(label, data);
            }
+            ModularElement::CenteredLabel {
+                rect: [x, y, w, h],
+                corner_radius,
+                font_size,
+                fg_color,
+                data,
+            } => {
+                canvas.font_size = *font_size;
+                canvas.fg_color = color_parse(fg_color).unwrap_or(*FALLBACK_COLOR);
+                let label = canvas.label_centered(
+                    *x,
+                    *y,
+                    *w,
+                    *h,
+                    corner_radius.unwrap_or_default(),
+                    empty_str.clone(),
+                );
+                modular_label_init(label, data);
+            }
+            ModularElement::Sprite {
+                rect: [x, y, w, h],
+                sprite,
+                sprite_st,
+            } => match sprite_from_path(sprite.clone(), state) {
+                Ok(view) => {
+                    let sprite = canvas.sprite(*x, *y, *w, *h);
+                    sprite.fg_color = Vec4::ONE;
+                    sprite.set_sprite(view);
+
+                    let st = sprite_st
+                        .map(|st| Vec4::from_slice(&st))
+                        .unwrap_or_else(|| Vec4::new(1., 1., 0., 0.));
+                    sprite.set_sprite_st(st);
+                }
+                Err(e) => {
+                    log::warn!("Could not load custom UI sprite: {:?}", e);
+                }
+            },
            ModularElement::Button {
                rect: [x, y, w, h],
+                corner_radius,
                font_size,
                bg_color,
                fg_color,
                text,
                data,
            } => {
-                canvas.bg_color = color_parse(bg_color).unwrap_or(FALLBACK_COLOR);
-                canvas.fg_color = color_parse(fg_color).unwrap_or(FALLBACK_COLOR);
+                canvas.bg_color = color_parse(bg_color).unwrap_or(*FALLBACK_COLOR);
+                canvas.fg_color = color_parse(fg_color).unwrap_or(*FALLBACK_COLOR);
                canvas.font_size = *font_size;
-                let button = canvas.button(*x, *y, *w, *h, text.clone());
+                let button = canvas.button(
+                    *x,
+                    *y,
+                    *w,
+                    *h,
+                    corner_radius.unwrap_or_default(),
+                    text.clone(),
+                );
                modular_button_init(button, data);
            }
            ModularElement::BatteryList {
                rect: [x, y, w, h],
+                corner_radius,
                font_size,
                fg_color,
                fg_color_low,
@@ -177,7 +251,7 @@ pub fn modular_canvas(
                    ListLayout::Vertical => (*w, *h / num_buttons),
                };

-                let fg_color = color_parse(fg_color).unwrap_or(FALLBACK_COLOR);
+                let fg_color = color_parse(fg_color).unwrap_or(*FALLBACK_COLOR);
                canvas.font_size = *font_size;
                canvas.fg_color = fg_color;

@@ -187,6 +261,7 @@ pub fn modular_canvas(
                        button_y + 2.,
                        button_w - 4.,
                        button_h - 4.,
+                        corner_radius.unwrap_or_default(),
                        empty_str.clone(),
                    );
                    modular_label_init(
@@ -211,6 +286,7 @@ pub fn modular_canvas(
            }
            ModularElement::OverlayList {
                rect: [x, y, w, h],
+                corner_radius,
                font_size,
                fg_color,
                bg_color,
@@ -225,8 +301,8 @@ pub fn modular_canvas(
                    ListLayout::Vertical => (*w, *h / num_buttons),
                };

-                canvas.bg_color = color_parse(bg_color).unwrap_or(FALLBACK_COLOR);
-                canvas.fg_color = color_parse(fg_color).unwrap_or(FALLBACK_COLOR);
+                canvas.bg_color = color_parse(bg_color).unwrap_or(*FALLBACK_COLOR);
+                canvas.fg_color = color_parse(fg_color).unwrap_or(*FALLBACK_COLOR);
                canvas.font_size = *font_size;

                for screen in state.screens.iter() {
@@ -235,6 +311,7 @@ pub fn modular_canvas(
                        button_y + 2.,
                        button_w - 4.,
                        button_h - 4.,
+                        corner_radius.unwrap_or_default(),
                        screen.name.clone(),
                    );

@@ -326,9 +403,35 @@ pub fn modular_canvas(
    Ok(canvas.build())
 }

-pub fn color_parse_or_default(color: &str) -> Vec3 {
+pub fn color_parse_or_default(color: &str) -> GuiColor {
    color_parse(color).unwrap_or_else(|e| {
        log::error!("Failed to parse color '{}': {}", color, e);
-        FALLBACK_COLOR
+        *FALLBACK_COLOR
    })
 }
+
+fn sprite_from_path(path: Arc<str>, app: &mut AppState) -> anyhow::Result<Arc<ImageView>> {
+    if let Some(view) = app.sprites.arc_get(&path) {
+        return Ok(view.clone());
+    }
+
+    let real_path = CONFIG_ROOT_PATH.join(&*path);
+
+    let Ok(f) = File::open(real_path) else {
+        anyhow::bail!("Could not open custom sprite at: {}", path);
+    };
+
+    let mut command_buffer = app
+        .graphics
+        .create_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
+
+    match command_buffer.texture2d_dds(f) {
+        Ok(image) => {
+            command_buffer.build_and_execute_now()?;
+            Ok(ImageView::new_default(image)?)
+        }
+        Err(e) => {
+            anyhow::bail!("Could not use custom sprite at: {}\n{:?}", path, e);
+        }
+    }
+}
@@ -7,11 +7,25 @@ use input_linux::{
 };
 use libc::{input_event, timeval};
 use once_cell::sync::Lazy;
-use std::fs::File;
 use std::mem::transmute;
+use std::{fs::File, sync::atomic::AtomicBool};
 use strum::{EnumIter, EnumString, IntoEnumIterator};
+use xkbcommon::xkb;
+
+#[cfg(feature = "wayland")]
+mod wayland;
+
+#[cfg(feature = "x11")]
+mod x11;
+
+pub static USE_UINPUT: AtomicBool = AtomicBool::new(true);

 pub fn initialize() -> Box<dyn HidProvider> {
+    if !USE_UINPUT.load(std::sync::atomic::Ordering::Relaxed) {
+        log::info!("Uinput disabled by user.");
+        return Box::new(DummyProvider {});
+    }
+
    if let Some(uinput) = UInputProvider::try_new() {
        log::info!("Initialized uinput.");
        return Box::new(uinput);
@@ -30,19 +44,34 @@ pub fn initialize() -> Box<dyn HidProvider> {

 pub trait HidProvider {
    fn mouse_move(&mut self, pos: Vec2);
-    fn send_button(&self, button: u16, down: bool);
-    fn wheel(&self, delta: i32);
+    fn send_button(&mut self, button: u16, down: bool);
+    fn wheel(&mut self, delta: i32);
    fn set_modifiers(&mut self, mods: u8);
-    fn send_key(&self, key: u16, down: bool);
+    fn send_key(&self, key: VirtualKey, down: bool);
    fn set_desktop_extent(&mut self, extent: Vec2);
-    fn on_new_frame(&mut self);
+    fn set_desktop_origin(&mut self, origin: Vec2);
+    fn commit(&mut self);
+}
+
+struct MouseButtonAction {
+    button: u16,
+    down: bool,
+}
+
+#[derive(Default)]
+struct MouseAction {
+    last_requested_pos: Option<Vec2>,
+    pos: Option<Vec2>,
+    button: Option<MouseButtonAction>,
+    scroll: Option<i32>,
 }

 pub struct UInputProvider {
    handle: UInputHandle<File>,
    desktop_extent: Vec2,
-    mouse_moved: bool,
+    desktop_origin: Vec2,
    cur_modifiers: u8,
+    current_action: MouseAction,
 }

 pub struct DummyProvider;
@@ -135,26 +164,30 @@ impl UInputProvider {
                return Some(UInputProvider {
                    handle,
                    desktop_extent: Vec2::ZERO,
-                    mouse_moved: false,
+                    desktop_origin: Vec2::ZERO,
+                    current_action: Default::default(),
                    cur_modifiers: 0,
                });
            }
        }
        None
    }
-}

-impl HidProvider for UInputProvider {
-    fn mouse_move(&mut self, pos: Vec2) {
-        if self.mouse_moved {
-            return;
+    fn send_button_internal(&self, button: u16, down: bool) {
+        let time = get_time();
+        let events = [
+            new_event(time, EV_KEY, button, down as _),
+            new_event(time, EV_SYN, 0, 0),
+        ];
+        if let Err(res) = self.handle.write(&events) {
+            log::error!("send_button: {}", res.to_string());
        }
-        self.mouse_moved = true;
-
+    }
+    fn mouse_move_internal(&mut self, pos: Vec2) {
        #[cfg(debug_assertions)]
        log::trace!("Mouse move: {:?}", pos);

-        let pos = pos * (MOUSE_EXTENT / self.desktop_extent);
+        let pos = (pos - self.desktop_origin) * (MOUSE_EXTENT / self.desktop_extent);

        let time = get_time();
        let events = [
@@ -166,17 +199,7 @@ impl HidProvider for UInputProvider {
            log::error!("{}", res.to_string());
        }
    }
-    fn send_button(&self, button: u16, down: bool) {
-        let time = get_time();
-        let events = [
-            new_event(time, EV_KEY, button, down as _),
-            new_event(time, EV_SYN, 0, 0),
-        ];
-        if let Err(res) = self.handle.write(&events) {
-            log::error!("send_button: {}", res.to_string());
-        }
-    }
-    fn wheel(&self, delta: i32) {
+    fn wheel_internal(&self, delta: i32) {
        let time = get_time();
        let events = [
            new_event(time, EV_REL, RelativeAxis::Wheel as _, delta),
@@ -186,22 +209,26 @@ impl HidProvider for UInputProvider {
            log::error!("wheel: {}", res.to_string());
        }
    }
+}
+
+impl HidProvider for UInputProvider {
    fn set_modifiers(&mut self, modifiers: u8) {
        let changed = self.cur_modifiers ^ modifiers;
-        for i in 0..7 {
+        for i in 0..8 {
            let m = 1 << i;
            if changed & m != 0 {
                if let Some(vk) = MODS_TO_KEYS.get(m).into_iter().flatten().next() {
-                    self.send_key(*vk as u16, modifiers & m != 0);
+                    self.send_key(*vk, modifiers & m != 0);
                }
            }
        }
        self.cur_modifiers = modifiers;
    }
-    fn send_key(&self, key: u16, down: bool) {
+    fn send_key(&self, key: VirtualKey, down: bool) {
+        log::debug!("send_key: {:?} {}", key, down);
        let time = get_time();
        let events = [
-            new_event(time, EV_KEY, key - 8, down as _),
+            new_event(time, EV_KEY, (key as u16) - 8, down as _),
            new_event(time, EV_SYN, 0, 0),
        ];
        if let Err(res) = self.handle.write(&events) {
@@ -209,22 +236,53 @@ impl HidProvider for UInputProvider {
        }
    }
    fn set_desktop_extent(&mut self, extent: Vec2) {
-        log::info!("Desktop extent: {:?}", extent);
        self.desktop_extent = extent;
    }
-    fn on_new_frame(&mut self) {
-        self.mouse_moved = false;
+    fn set_desktop_origin(&mut self, origin: Vec2) {
+        self.desktop_origin = origin;
+    }
+    fn mouse_move(&mut self, pos: Vec2) {
+        if self.current_action.pos.is_none() && self.current_action.scroll.is_none() {
+            self.current_action.pos = Some(pos);
+        }
+        self.current_action.last_requested_pos = Some(pos);
+    }
+    fn send_button(&mut self, button: u16, down: bool) {
+        if self.current_action.button.is_none() {
+            self.current_action.button = Some(MouseButtonAction { button, down });
+            self.current_action.pos = self.current_action.last_requested_pos;
+        }
+    }
+    fn wheel(&mut self, delta: i32) {
+        if self.current_action.scroll.is_none() {
+            self.current_action.scroll = Some(delta);
+            // Pass mouse motion events only if not scrolling
+            // (allows scrolling on all Chromium-based applications)
+            self.current_action.pos = None;
+        }
+    }
+    fn commit(&mut self) {
+        if let Some(pos) = self.current_action.pos.take() {
+            self.mouse_move_internal(pos);
+        }
+        if let Some(button) = self.current_action.button.take() {
+            self.send_button_internal(button.button, button.down);
+        }
+        if let Some(scroll) = self.current_action.scroll.take() {
+            self.wheel_internal(scroll);
+        }
    }
 }

 impl HidProvider for DummyProvider {
    fn mouse_move(&mut self, _pos: Vec2) {}
-    fn send_button(&self, _button: u16, _down: bool) {}
-    fn wheel(&self, _delta: i32) {}
+    fn send_button(&mut self, _button: u16, _down: bool) {}
+    fn wheel(&mut self, _delta: i32) {}
    fn set_modifiers(&mut self, _modifiers: u8) {}
-    fn send_key(&self, _key: u16, _down: bool) {}
+    fn send_key(&self, _key: VirtualKey, _down: bool) {}
    fn set_desktop_extent(&mut self, _extent: Vec2) {}
-    fn on_new_frame(&mut self) {}
+    fn set_desktop_origin(&mut self, _origin: Vec2) {}
+    fn commit(&mut self) {}
 }

 #[inline]
@@ -440,3 +498,103 @@ pub static MODS_TO_KEYS: Lazy<IdMap<KeyModifier, Vec<VirtualKey>>> = Lazy::new(|
        META => vec![VirtualKey::Meta],
    }
 });
+
+pub enum KeyType {
+    Symbol,
+    NumPad,
+    Other,
+}
+
+macro_rules! key_between {
+    ($key:expr, $start:expr, $end:expr) => {
+        $key as u32 >= $start as u32 && $key as u32 <= $end as u32
+    };
+}
+
+macro_rules! key_is {
+    ($key:expr, $val:expr) => {
+        $key as u32 == $val as u32
+    };
+}
+
+pub fn get_key_type(key: VirtualKey) -> KeyType {
+    if key_between!(key, VirtualKey::N1, VirtualKey::Plus)
+        || key_between!(key, VirtualKey::Q, VirtualKey::Oem6)
+        || key_between!(key, VirtualKey::A, VirtualKey::Oem3)
+        || key_between!(key, VirtualKey::Oem5, VirtualKey::Oem2)
+        || key_is!(key, VirtualKey::Oem102)
+    {
+        KeyType::Symbol
+    } else if key_between!(key, VirtualKey::KP_7, VirtualKey::KP_0)
+        && !key_is!(key, VirtualKey::KP_Subtract)
+        && !key_is!(key, VirtualKey::KP_Add)
+    {
+        KeyType::NumPad
+    } else {
+        KeyType::Other
+    }
+}
+
+pub struct XkbKeymap {
+    pub keymap: xkb::Keymap,
+}
+
+impl XkbKeymap {
+    pub fn label_for_key(&self, key: VirtualKey, modifier: KeyModifier) -> String {
+        let mut state = xkb::State::new(&self.keymap);
+        if modifier > 0 {
+            if let Some(mod_key) = MODS_TO_KEYS.get(modifier) {
+                state.update_key(
+                    xkb::Keycode::from(mod_key[0] as u32),
+                    xkb::KeyDirection::Down,
+                );
+            }
+        }
+        state.key_get_utf8(xkb::Keycode::from(key as u32))
+    }
+
+    pub fn has_altgr(&self) -> bool {
+        let state0 = xkb::State::new(&self.keymap);
+        let mut state1 = xkb::State::new(&self.keymap);
+        state1.update_key(
+            xkb::Keycode::from(VirtualKey::Meta as u32),
+            xkb::KeyDirection::Down,
+        );
+
+        for key in [
+            VirtualKey::N0,
+            VirtualKey::N1,
+            VirtualKey::N2,
+            VirtualKey::N3,
+            VirtualKey::N4,
+            VirtualKey::N5,
+            VirtualKey::N6,
+            VirtualKey::N7,
+            VirtualKey::N8,
+            VirtualKey::N9,
+        ] {
+            let sym0 = state0.key_get_one_sym(xkb::Keycode::from(key as u32));
+            let sym1 = state1.key_get_one_sym(xkb::Keycode::from(key as u32));
+            if sym0 != sym1 {
+                return true;
+            }
+        }
+        false
+    }
+}
+
+#[cfg(feature = "wayland")]
+pub use wayland::get_keymap_wl;
+
+#[cfg(not(feature = "wayland"))]
+pub fn get_keymap_wl() -> anyhow::Result<XkbKeymap> {
+    anyhow::bail!("Wayland support not enabled.")
+}
+
+#[cfg(feature = "x11")]
+pub use x11::get_keymap_x11;
+
+#[cfg(not(feature = "x11"))]
+pub fn get_keymap_x11() -> anyhow::Result<XkbKeymap> {
+    anyhow::bail!("X11 support not enabled.")
+}
@@ -0,0 +1,142 @@
+use wlx_capture::wayland::wayland_client::{
+    globals::{registry_queue_init, GlobalListContents},
+    protocol::{
+        wl_keyboard::{self, WlKeyboard},
+        wl_registry::WlRegistry,
+        wl_seat::{self, Capability, WlSeat},
+    },
+    Connection, Dispatch, Proxy, QueueHandle,
+};
+use xkbcommon::xkb;
+
+use super::XkbKeymap;
+
+struct WlKeymapHandler {
+    seat: WlSeat,
+    keyboard: Option<WlKeyboard>,
+    keymap: Option<XkbKeymap>,
+}
+
+impl Drop for WlKeymapHandler {
+    fn drop(&mut self) {
+        if let Some(keyboard) = &self.keyboard {
+            keyboard.release();
+        }
+        self.seat.release();
+    }
+}
+
+pub fn get_keymap_wl() -> anyhow::Result<XkbKeymap> {
+    let connection = Connection::connect_to_env()?;
+    let (globals, mut queue) = registry_queue_init::<WlKeymapHandler>(&connection)?;
+    let qh = queue.handle();
+    let seat: WlSeat = globals
+        .bind(&qh, 4..=9, ())
+        .expect(WlSeat::interface().name);
+
+    let mut me = WlKeymapHandler {
+        seat,
+        keyboard: None,
+        keymap: None,
+    };
+
+    // this gets us the wl_seat
+    let _ = queue.blocking_dispatch(&mut me);
+
+    // this gets us the wl_keyboard
+    let _ = queue.blocking_dispatch(&mut me);
+
+    if let Some(keymap) = me.keymap.take() {
+        Ok(keymap)
+    } else {
+        Err(anyhow::anyhow!("Could not load keymap"))
+    }
+}
+
+impl Dispatch<WlRegistry, GlobalListContents> for WlKeymapHandler {
+    fn event(
+        _state: &mut Self,
+        _proxy: &WlRegistry,
+        _event: <WlRegistry as Proxy>::Event,
+        _data: &GlobalListContents,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+    }
+}
+
+impl Dispatch<WlSeat, ()> for WlKeymapHandler {
+    fn event(
+        state: &mut Self,
+        proxy: &WlSeat,
+        event: <WlSeat as Proxy>::Event,
+        _data: &(),
+        _conn: &Connection,
+        qhandle: &QueueHandle<Self>,
+    ) {
+        match event {
+            wl_seat::Event::Capabilities { capabilities } => {
+                let capability = capabilities
+                    .into_result()
+                    .unwrap_or(wl_seat::Capability::empty());
+                if capability.contains(Capability::Keyboard) {
+                    state.keyboard = Some(proxy.get_keyboard(qhandle, ()));
+                }
+            }
+            wl_seat::Event::Name { name } => {
+                log::debug!("Using WlSeat: {}", name);
+            }
+            _ => {}
+        }
+    }
+}
+
+impl Dispatch<WlKeyboard, ()> for WlKeymapHandler {
+    fn event(
+        state: &mut Self,
+        _proxy: &WlKeyboard,
+        event: <WlKeyboard as Proxy>::Event,
+        _data: &(),
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+        match event {
+            wl_keyboard::Event::Keymap { format, fd, size } => {
+                let format = format
+                    .into_result()
+                    .unwrap_or(wl_keyboard::KeymapFormat::NoKeymap);
+
+                if matches!(format, wl_keyboard::KeymapFormat::XkbV1) {
+                    let context = xkb::Context::new(xkb::CONTEXT_NO_DEFAULT_INCLUDES);
+                    let maybe_keymap = unsafe {
+                        xkb::Keymap::new_from_fd(
+                            &context,
+                            fd,
+                            size as _,
+                            xkb::KEYMAP_FORMAT_TEXT_V1,
+                            xkb::KEYMAP_COMPILE_NO_FLAGS,
+                        )
+                    };
+
+                    match maybe_keymap {
+                        Ok(Some(keymap)) => {
+                            state.keymap = Some(XkbKeymap { keymap });
+                        }
+                        Ok(None) => {
+                            log::error!("Could not load keymap: no keymap");
+                            log::error!("Default layout will be used.");
+                        }
+                        Err(err) => {
+                            log::error!("Could not load keymap: {}", err);
+                            log::error!("Default layout will be used.");
+                        }
+                    }
+                }
+            }
+            wl_keyboard::Event::RepeatInfo { rate, delay } => {
+                log::debug!("WlKeyboard RepeatInfo rate: {}, delay: {}", rate, delay);
+            }
+            _ => {}
+        }
+    }
+}
@@ -0,0 +1,35 @@
+use xkbcommon::xkb::{
+    self,
+    x11::{
+        get_core_keyboard_device_id, keymap_new_from_device, setup_xkb_extension,
+        SetupXkbExtensionFlags, MIN_MAJOR_XKB_VERSION, MIN_MINOR_XKB_VERSION,
+    },
+};
+
+use super::XkbKeymap;
+
+pub fn get_keymap_x11() -> anyhow::Result<XkbKeymap> {
+    let context = xkb::Context::new(xkb::CONTEXT_NO_FLAGS);
+
+    let (conn, _) = xcb::Connection::connect(None)?;
+    setup_xkb_extension(
+        &conn,
+        MIN_MAJOR_XKB_VERSION,
+        MIN_MINOR_XKB_VERSION,
+        SetupXkbExtensionFlags::NoFlags,
+        &mut 0,
+        &mut 0,
+        &mut 0,
+        &mut 0,
+    );
+
+    let device_id = get_core_keyboard_device_id(&conn);
+    if device_id == -1 {
+        return Err(anyhow::anyhow!(
+            "get_core_keyboard_device_id returned -1. Check your XKB installation."
+        ));
+    }
+    let keymap = keymap_new_from_device(&context, &conn, device_id, xkb::KEYMAP_COMPILE_NO_FLAGS);
+
+    Ok(XkbKeymap { keymap })
+}
@@ -9,16 +9,20 @@ mod overlays;
 mod shaders;
 mod state;

-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc,
+use std::{
+    path::PathBuf,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
 };

 use clap::Parser;
-use flexi_logger::FileSpec;
+use flexi_logger::{Duplicate, FileSpec, LogSpecification};
+use sysinfo::Pid;

 /// The lightweight desktop overlay for OpenVR and OpenXR
-#[derive(Parser, Debug)]
+#[derive(Default, Parser, Debug)]
 #[command(version, about, long_about = None)]
 struct Args {
    #[cfg(feature = "openvr")]
@@ -31,32 +35,53 @@ struct Args {
    #[arg(long)]
    openxr: bool,

+    /// Show the working set of overlay on startup
+    #[arg(long)]
+    show: bool,
+
    /// Uninstall OpenVR manifest and exit
    #[arg(long)]
    uninstall: bool,

+    /// Replace running WlxOverlay-S instance
+    #[arg(long)]
+    replace: bool,
+
+    /// Allow multiple running instances of WlxOverlay-S (things may break!)
+    #[arg(long)]
+    multi: bool,
+
    /// Path to write logs to
-    #[arg(short, long, value_name = "FOLDER")]
+    #[arg(short, long, value_name = "FILE_PATH")]
    log_to: Option<String>,
+
+    #[cfg(feature = "uidev")]
+    /// Show a desktop window of a UI panel for development
+    #[arg(short, long, value_name = "UI_NAME")]
+    uidev: Option<String>,
 }

 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let args = Args::parse();
-    if let Some(ref log_to) = args.log_to {
-        flexi_logger::Logger::try_with_env_or_str("info")?
-            .log_to_file(FileSpec::default().directory(log_to))
-            .log_to_stdout()
-            .start()?;
-        println!("Logging to: {}", &log_to);
+    let mut args = if std::env::args().skip(1).any(|a| !a.is_empty()) {
+        Args::parse()
    } else {
-        flexi_logger::Logger::try_with_env_or_str("info")?.start()?;
+        Args::default()
+    };
+
+    if !args.multi && !ensure_single_instance(args.replace) {
+        println!("Looks like WlxOverlay-S is already running.");
+        println!("Use --replace and I will terminate it for you.");
+        return Ok(());
    }

+    logging_init(&mut args)?;
+
    log::info!(
        "Welcome to {} version {}!",
        env!("CARGO_PKG_NAME"),
-        env!("CARGO_PKG_VERSION")
+        env!("WLX_BUILD"),
    );
+    log::info!("It is {}.", chrono::Local::now().format("%c"));

    #[cfg(feature = "openvr")]
    if args.uninstall {
@@ -64,6 +89,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
        return Ok(());
    }

+    #[cfg(feature = "uidev")]
+    if let Some(panel_name) = args.uidev.as_ref() {
+        crate::backend::uidev::uidev_run(panel_name.as_str())?;
+        return Ok(());
+    }
+
    let running = Arc::new(AtomicBool::new(true));
    let _ = ctrlc::set_handler({
        let running = running.clone();
@@ -83,7 +114,7 @@ fn auto_run(running: Arc<AtomicBool>, args: Args) {
    #[cfg(feature = "openxr")]
    if !args_get_openvr(&args) {
        use crate::backend::openxr::openxr_run;
-        match openxr_run(running.clone()) {
+        match openxr_run(running.clone(), args.show) {
            Ok(()) => return,
            Err(BackendError::NotSupported) => (),
            Err(e) => {
@@ -96,7 +127,7 @@ fn auto_run(running: Arc<AtomicBool>, args: Args) {
    #[cfg(feature = "openvr")]
    if !args_get_openxr(&args) {
        use crate::backend::openvr::openvr_run;
-        match openvr_run(running.clone()) {
+        match openvr_run(running.clone(), args.show) {
            Ok(()) => return,
            Err(BackendError::NotSupported) => (),
            Err(e) => {
@@ -136,3 +167,77 @@ fn args_get_openxr(_args: &Args) -> bool {

    ret
 }
+
+fn logging_init(args: &mut Args) -> anyhow::Result<()> {
+    let log_file = args
+        .log_to
+        .take()
+        .or_else(|| std::env::var("WLX_LOGFILE").ok())
+        .or_else(|| Some("/tmp/wlx.log".to_string()));
+
+    if let Some(log_to) = log_file.filter(|s| !s.is_empty()) {
+        if let Err(e) = file_logging_init(&log_to) {
+            log::error!("Failed to initialize file logging: {}", e);
+            flexi_logger::Logger::try_with_env_or_str("info")?.start()?;
+        }
+    } else {
+        flexi_logger::Logger::try_with_env_or_str("info")?.start()?;
+    }
+
+    log_panics::init();
+    Ok(())
+}
+
+fn file_logging_init(log_to: &str) -> anyhow::Result<()> {
+    let file_spec = FileSpec::try_from(PathBuf::from(log_to))?;
+    let log_spec = LogSpecification::env_or_parse("info")?;
+
+    let duplicate = log_spec
+        .module_filters()
+        .iter()
+        .find(|m| m.module_name.is_none())
+        .map(|m| match m.level_filter {
+            log::LevelFilter::Trace => Duplicate::Trace,
+            log::LevelFilter::Debug => Duplicate::Debug,
+            log::LevelFilter::Info => Duplicate::Info,
+            log::LevelFilter::Warn => Duplicate::Warn,
+            _ => Duplicate::Error,
+        });
+
+    flexi_logger::Logger::with(log_spec)
+        .log_to_file(file_spec)
+        .duplicate_to_stderr(duplicate.unwrap_or(Duplicate::Error))
+        .start()?;
+    println!("Logging to: {}", log_to);
+    Ok(())
+}
+
+fn ensure_single_instance(replace: bool) -> bool {
+    let mut path = std::env::var("XDG_RUNTIME_DIR")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| PathBuf::from("/tmp"));
+    path.push("wlx-overlay-s.pid");
+
+    if path.exists() {
+        // load contents
+        if let Ok(pid_str) = std::fs::read_to_string(&path) {
+            if let Ok(pid) = pid_str.trim().parse::<u32>() {
+                let mut system = sysinfo::System::new();
+                system.refresh_processes(sysinfo::ProcessesToUpdate::Some(&[Pid::from_u32(pid)]));
+                if let Some(proc) = system.process(sysinfo::Pid::from_u32(pid)) {
+                    if replace {
+                        proc.kill_with(sysinfo::Signal::Term);
+                        proc.wait();
+                    } else {
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+
+    let pid = std::process::id().to_string();
+    std::fs::write(path, pid).unwrap();
+
+    true
+}
@@ -0,0 +1,33 @@
+use glam::Vec3A;
+use once_cell::sync::Lazy;
+use std::sync::Arc;
+
+use crate::backend::overlay::{OverlayData, OverlayState, RelativeTo};
+use crate::config::{load_known_yaml, ConfigType};
+use crate::gui::modular::{modular_canvas, ModularUiConfig};
+use crate::state::AppState;
+
+pub static ANCHOR_NAME: Lazy<Arc<str>> = Lazy::new(|| Arc::from("anchor"));
+
+pub fn create_anchor<O>(state: &mut AppState) -> anyhow::Result<OverlayData<O>>
+where
+    O: Default,
+{
+    let config = load_known_yaml::<ModularUiConfig>(ConfigType::Anchor);
+
+    Ok(OverlayData {
+        state: OverlayState {
+            name: ANCHOR_NAME.clone(),
+            want_visible: false,
+            interactable: false,
+            grabbable: false,
+            z_order: 67,
+            spawn_scale: config.width,
+            spawn_point: Vec3A::NEG_Z * 0.5,
+            relative_to: RelativeTo::Stage,
+            ..Default::default()
+        },
+        backend: Box::new(modular_canvas(&config.size, &config.elements, state)?),
+        ..Default::default()
+    })
+}
@@ -12,7 +12,7 @@ use crate::{
 const SETTINGS_NAME: &str = "settings";

 pub fn create_custom(
-    state: &AppState,
+    state: &mut AppState,
    name: Arc<str>,
 ) -> Option<(OverlayState, Box<dyn OverlayBackend>)> {
    let config = if &*name == SETTINGS_NAME {
@@ -1,6 +1,5 @@
 use std::{
    collections::HashMap,
-    io::Cursor,
    process::{Child, Command},
    str::FromStr,
 };
@@ -11,14 +10,19 @@ use crate::{
        overlay::{OverlayData, OverlayState},
    },
    config::{self, ConfigType},
-    gui::{color_parse, CanvasBuilder, Control},
-    hid::{KeyModifier, VirtualKey, ALT, CTRL, KEYS_TO_MODS, META, SHIFT, SUPER},
+    gui::{
+        canvas::{builder::CanvasBuilder, control::Control},
+        color_parse, KeyCapType,
+    },
+    hid::{
+        get_key_type, KeyModifier, KeyType, VirtualKey, XkbKeymap, ALT, CTRL, KEYS_TO_MODS, META,
+        NUM_LOCK, SHIFT, SUPER,
+    },
    state::AppState,
 };
 use glam::{vec2, vec3a, Affine2, Vec4};
 use once_cell::sync::Lazy;
 use regex::Regex;
-use rodio::{Decoder, Source};
 use serde::{Deserialize, Serialize};

 const PIXELS_PER_UNIT: f32 = 80.;
@@ -27,7 +31,10 @@ const AUTO_RELEASE_MODS: [KeyModifier; 5] = [SHIFT, CTRL, ALT, SUPER, META];

 pub const KEYBOARD_NAME: &str = "kbd";

-pub fn create_keyboard<O>(app: &AppState) -> anyhow::Result<OverlayData<O>>
+pub fn create_keyboard<O>(
+    app: &AppState,
+    keymap: Option<XkbKeymap>,
+) -> anyhow::Result<OverlayData<O>>
 where
    O: Default,
 {
@@ -45,15 +52,18 @@ where
        size.x as _,
        size.y as _,
        app.graphics.clone(),
-        app.format,
+        app.graphics.native_format,
        data,
    )?;

-    canvas.bg_color = color_parse("#101010").unwrap(); //safe
-    canvas.panel(0., 0., size.x, size.y);
+    canvas.bg_color = color_parse("#181926").unwrap(); //safe
+    canvas.panel(0., 0., size.x, size.y, 12.);

    canvas.font_size = 18;
-    canvas.bg_color = color_parse("#202020").unwrap(); //safe
+    canvas.fg_color = color_parse("#cad3f5").unwrap(); //safe
+    canvas.bg_color = color_parse("#1e2030").unwrap(); //safe
+
+    let has_altgr = keymap.as_ref().map_or(false, |k| k.has_altgr());

    let unit_size = size.x / LAYOUT.row_size;
    let h = unit_size - 2. * BUTTON_PADDING;
@@ -68,8 +78,43 @@ where
            let w = unit_size * my_size - 2. * BUTTON_PADDING;

            if let Some(key) = LAYOUT.main_layout[row][col].as_ref() {
+                let mut label = Vec::with_capacity(2);
                let mut maybe_state: Option<KeyButtonData> = None;
+                let mut cap_type = KeyCapType::Regular;
+
                if let Ok(vk) = VirtualKey::from_str(key) {
+                    if let Some(keymap) = keymap.as_ref() {
+                        match get_key_type(vk) {
+                            KeyType::Symbol => {
+                                let label0 = keymap.label_for_key(vk, 0);
+                                let label1 = keymap.label_for_key(vk, SHIFT);
+
+                                if label0.chars().next().map_or(false, |f| f.is_alphabetic()) {
+                                    label.push(label1);
+                                    if has_altgr {
+                                        cap_type = KeyCapType::RegularAltGr;
+                                        label.push(keymap.label_for_key(vk, META));
+                                    } else {
+                                        cap_type = KeyCapType::Regular;
+                                    }
+                                } else {
+                                    label.push(label0);
+                                    label.push(label1);
+                                    if has_altgr {
+                                        label.push(keymap.label_for_key(vk, META));
+                                        cap_type = KeyCapType::ReversedAltGr;
+                                    } else {
+                                        cap_type = KeyCapType::Reversed;
+                                    }
+                                }
+                            }
+                            KeyType::NumPad => {
+                                label.push(keymap.label_for_key(vk, NUM_LOCK));
+                            }
+                            KeyType::Other => {}
+                        }
+                    }
+
                    if let Some(mods) = KEYS_TO_MODS.get(vk) {
                        maybe_state = Some(KeyButtonData::Modifier {
                            modifier: *mods,
@@ -83,20 +128,28 @@ where
                        verbs: key_events_for_macro(macro_verbs),
                    });
                } else if let Some(exec_args) = LAYOUT.exec_commands.get(key) {
-                    maybe_state = Some(KeyButtonData::Exec {
-                        program: exec_args
-                            .first()
-                            .expect("Keyboard: Invalid EXEC args")
-                            .clone(),
-                        args: exec_args.iter().skip(1).cloned().collect(),
-                    });
+                    if exec_args.is_empty() {
+                        log::error!("Keyboard: EXEC args empty for {}", key);
+                        continue;
+                    }
+                    let mut iter = exec_args.iter().cloned();
+                    if let Some(program) = iter.next() {
+                        maybe_state = Some(KeyButtonData::Exec {
+                            program,
+                            args: iter.by_ref().take_while(|arg| arg[..] != *"null").collect(),
+                            release_program: iter.next(),
+                            release_args: iter.collect(),
+                        })
+                    };
                } else {
                    log::error!("Unknown key: {}", key);
                }

                if let Some(state) = maybe_state {
-                    let label = LAYOUT.label_for_key(key);
-                    let button = canvas.key_button(x, y, w, h, &label);
+                    if label.is_empty() {
+                        label = LAYOUT.label_for_key(key);
+                    }
+                    let button = canvas.key_button(x, y, w, h, 12., cap_type, &label);
                    button.state = Some(state);
                    button.on_press = Some(key_press);
                    button.on_release = Some(key_release);
@@ -120,9 +173,10 @@ where
            name: KEYBOARD_NAME.into(),
            grabbable: true,
            recenter: true,
+            anchored: true,
            interactable: true,
            spawn_scale: width,
-            spawn_point: vec3a(0., -0.5, -1.),
+            spawn_point: vec3a(0., -0.5, 0.),
            interaction_transform,
            ..Default::default()
        },
@@ -146,7 +200,7 @@ fn key_press(
                app.hid_provider.set_modifiers(data.modifiers);
            }

-            app.hid_provider.send_key(*vk as _, true);
+            app.hid_provider.send_key(*vk, true);
            *pressed = true;
        }
        Some(KeyButtonData::Modifier { modifier, sticky }) => {
@@ -158,10 +212,10 @@ fn key_press(
        Some(KeyButtonData::Macro { verbs }) => {
            data.key_click(app);
            for (vk, press) in verbs {
-                app.hid_provider.send_key(*vk as _, *press);
+                app.hid_provider.send_key(*vk, *press);
            }
        }
-        Some(KeyButtonData::Exec { program, args }) => {
+        Some(KeyButtonData::Exec { program, args, .. }) => {
            // Reap previous processes
            data.processes
                .retain_mut(|child| !matches!(child.try_wait(), Ok(Some(_))));
@@ -182,7 +236,7 @@ fn key_release(
 ) {
    match control.state.as_mut() {
        Some(KeyButtonData::Key { vk, pressed }) => {
-            app.hid_provider.send_key(*vk as _, false);
+            app.hid_provider.send_key(*vk, false);
            *pressed = false;

            for m in AUTO_RELEASE_MODS.iter() {
@@ -198,11 +252,26 @@ fn key_release(
                app.hid_provider.set_modifiers(data.modifiers);
            }
        }
+        Some(KeyButtonData::Exec {
+            release_program,
+            release_args,
+            ..
+        }) => {
+            // Reap previous processes
+            data.processes
+                .retain_mut(|child| !matches!(child.try_wait(), Ok(Some(_))));
+
+            if let Some(program) = release_program {
+                if let Ok(child) = Command::new(program).args(release_args).spawn() {
+                    data.processes.push(child);
+                }
+            }
+        }
        _ => {}
    }
 }

-static PRESS_COLOR: Vec4 = Vec4::new(1.0, 1.0, 1.0, 0.5);
+static PRESS_COLOR: Vec4 = Vec4::new(198. / 255., 160. / 255., 246. / 255., 0.5);

 fn test_highlight(
    control: &Control<KeyboardData, KeyButtonData>,
@@ -227,33 +296,40 @@ struct KeyboardData {
    processes: Vec<Child>,
 }

+const KEY_AUDIO_WAV: &[u8] = include_bytes!("../res/421581.wav");
+
 impl KeyboardData {
    fn key_click(&mut self, app: &mut AppState) {
-        if !app.session.config.keyboard_sound_enabled {
-            return;
-        }
-
-        if let Some(handle) = app.audio.get_handle() {
-            // https://freesound.org/people/UberBosser/sounds/421581/
-            let wav = include_bytes!("../res/421581.wav");
-            let cursor = Cursor::new(wav);
-            let source = Decoder::new_wav(cursor).unwrap();
-            let _ = handle.play_raw(source.convert_samples());
+        if app.session.config.keyboard_sound_enabled {
+            app.audio.play(KEY_AUDIO_WAV);
        }
    }
 }

 enum KeyButtonData {
-    Key { vk: VirtualKey, pressed: bool },
-    Modifier { modifier: KeyModifier, sticky: bool },
-    Macro { verbs: Vec<(VirtualKey, bool)> },
-    Exec { program: String, args: Vec<String> },
+    Key {
+        vk: VirtualKey,
+        pressed: bool,
+    },
+    Modifier {
+        modifier: KeyModifier,
+        sticky: bool,
+    },
+    Macro {
+        verbs: Vec<(VirtualKey, bool)>,
+    },
+    Exec {
+        program: String,
+        args: Vec<String>,
+        release_program: Option<String>,
+        release_args: Vec<String>,
+    },
 }

 static LAYOUT: Lazy<Layout> = Lazy::new(Layout::load_from_disk);

 static MACRO_REGEX: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^([A-Za-z0-1_-]+)(?: +(UP|DOWN))?$").unwrap());
+    Lazy::new(|| Regex::new(r"^([A-Za-z0-9_-]+)(?: +(UP|DOWN))?$").unwrap()); // want panic

 #[derive(Debug, Deserialize, Serialize)]
 pub struct Layout {
@@ -314,11 +390,17 @@ impl Layout {
            key = &key[3..];
        }
        if key.contains('_') {
-            key = key.split('_').next().unwrap();
+            key = key.split('_').next().unwrap_or_else(|| {
+                log::error!(
+                    "keyboard.yaml: Key '{}' must not start or end with '_'!",
+                    key
+                );
+                "???"
+            });
        }
        vec![format!(
            "{}{}",
-            key.chars().next().unwrap().to_uppercase(),
+            key.chars().next().unwrap().to_uppercase(), // safe because we checked is_empty
            &key[1..].to_lowercase()
        )]
    }
@@ -1,35 +1,40 @@
-use std::{sync::Arc, thread::JoinHandle};
+use std::{
+    sync::Arc,
+    task::{Context, Poll},
+};

-use futures::executor;
-use glam::vec3a;
+use futures::{Future, FutureExt};
 use wlx_capture::pipewire::{pipewire_select_screen, PipewireCapture, PipewireSelectScreenResult};

 use crate::{
    backend::{
-        common::{OverlaySelector, TaskType},
+        common::OverlaySelector,
        overlay::{
            ui_transform, OverlayBackend, OverlayRenderer, OverlayState, SplitOverlayBackend,
        },
+        task::TaskType,
    },
    state::{AppSession, AppState},
 };

 use super::screen::ScreenRenderer;
+type PinnedSelectorFuture = core::pin::Pin<
+    Box<dyn Future<Output = Result<PipewireSelectScreenResult, wlx_capture::pipewire::AshpdError>>>,
+>;

 pub struct MirrorRenderer {
    name: Arc<str>,
    renderer: Option<ScreenRenderer>,
-    selector: Option<JoinHandle<Option<PipewireSelectScreenResult>>>,
+    selector: Option<PinnedSelectorFuture>,
    last_extent: [u32; 3],
 }
 impl MirrorRenderer {
    pub fn new(name: Arc<str>) -> Self {
+        let selector = Box::pin(pipewire_select_screen(None, false, false, false, false));
        Self {
            name,
            renderer: None,
-            selector: Some(std::thread::spawn(|| {
-                executor::block_on(pipewire_select_screen(None, false, false, false)).ok()
-            })),
+            selector: Some(selector),
            last_extent: [0; 3],
        }
    }
@@ -40,40 +45,44 @@ impl OverlayRenderer for MirrorRenderer {
        Ok(())
    }
    fn render(&mut self, app: &mut AppState) -> anyhow::Result<()> {
-        if let Some(selector) = self.selector.take() {
-            if !selector.is_finished() {
-                self.selector = Some(selector);
-                return Ok(());
-            }
+        if let Some(mut selector) = self.selector.take() {
+            let maybe_pw_result = match selector
+                .poll_unpin(&mut Context::from_waker(futures::task::noop_waker_ref()))
+            {
+                Poll::Ready(result) => result,
+                Poll::Pending => {
+                    self.selector = Some(selector);
+                    return Ok(());
+                }
+            };

-            // safe unwrap because we know it's finished
-            if let Some(pw_result) = selector.join().unwrap() {
-                log::info!(
-                    "{}: PipeWire node selected: {}",
-                    self.name.clone(),
-                    pw_result.node_id
-                );
-                let capture = PipewireCapture::new(self.name.clone(), pw_result.node_id, 60);
-                self.renderer = Some(ScreenRenderer::new_raw(
-                    self.name.clone(),
-                    Box::new(capture),
-                ));
-                app.tasks.enqueue(TaskType::Overlay(
-                    OverlaySelector::Name(self.name.clone()),
-                    Box::new(|app, o| {
-                        o.grabbable = true;
-                        o.interactable = true;
-                        o.reset(app, false);
-                    }),
-                ));
-            } else {
-                log::warn!("Failed to create pipewire mirror");
-                self.renderer = None;
-                // drop self
-                app.tasks
-                    .enqueue(TaskType::DropOverlay(OverlaySelector::Name(
+            match maybe_pw_result {
+                Ok(pw_result) => {
+                    let node_id = pw_result.streams.first().unwrap().node_id; // streams guaranteed to have at least one element
+                    log::info!("{}: PipeWire node selected: {}", self.name.clone(), node_id);
+                    let capture = PipewireCapture::new(self.name.clone(), node_id);
+                    self.renderer = Some(ScreenRenderer::new_raw(
                        self.name.clone(),
-                    )));
+                        Box::new(capture),
+                    ));
+                    app.tasks.enqueue(TaskType::Overlay(
+                        OverlaySelector::Name(self.name.clone()),
+                        Box::new(|app, o| {
+                            o.grabbable = true;
+                            o.interactable = true;
+                            o.reset(app, false);
+                        }),
+                    ));
+                }
+                Err(e) => {
+                    log::warn!("Failed to create mirror due to PipeWire error: {:?}", e);
+                    self.renderer = None;
+                    // drop self
+                    app.tasks
+                        .enqueue(TaskType::DropOverlay(OverlaySelector::Name(
+                            self.name.clone(),
+                        )));
+                }
            }
        }

@@ -111,6 +120,10 @@ impl OverlayRenderer for MirrorRenderer {
    fn view(&mut self) -> Option<std::sync::Arc<vulkano::image::view::ImageView>> {
        self.renderer.as_mut().and_then(|r| r.view())
    }
+
+    fn extent(&mut self) -> Option<[u32; 3]> {
+        Some(self.last_extent)
+    }
 }

 pub fn new_mirror(
@@ -123,7 +136,6 @@ pub fn new_mirror(
        show_hide,
        want_visible: true,
        spawn_scale: 0.5 * session.config.desktop_view_scale,
-        spawn_point: vec3a(0., 0.5, -0.5),
        ..Default::default()
    };
    let backend = Box::new(SplitOverlayBackend {
@@ -1,3 +1,4 @@
+pub mod anchor;
 pub mod custom;
 pub mod keyboard;
 #[cfg(feature = "wayland")]
@@ -1,28 +1,40 @@
-use std::{
-    io::Cursor,
-    ops::Add,
-    sync::{atomic::AtomicUsize, Arc},
-    time::Instant,
-};
+use std::{f32::consts::PI, ops::Add, sync::Arc, time::Instant};

-use rodio::{Decoder, Source};
-
-use glam::vec3a;
+use glam::{vec3a, Quat};
+use idmap_derive::IntegerId;
+use once_cell::sync::Lazy;
+use serde::{Deserialize, Serialize};

 use crate::{
    backend::{
-        common::{OverlaySelector, TaskType},
+        common::OverlaySelector,
        overlay::{OverlayBackend, OverlayState, RelativeTo},
+        task::TaskType,
    },
-    gui::{color_parse, CanvasBuilder},
-    state::AppState,
+    gui::{canvas::builder::CanvasBuilder, color_parse},
+    state::{AppState, LeftRight},
 };

 const FONT_SIZE: isize = 16;
 const PADDING: (f32, f32) = (25., 7.);
 const PIXELS_TO_METERS: f32 = 1. / 2000.;
+const TOAST_AUDIO_WAV: &[u8] = include_bytes!("../res/557297.wav");
+static TOAST_NAME: Lazy<Arc<str>> = Lazy::new(|| "toast".into());

-static AUTO_INCREMENT: AtomicUsize = AtomicUsize::new(0);
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub enum DisplayMethod {
+    Hide,
+    Center,
+    Watch,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, IntegerId, Serialize, Deserialize)]
+pub enum ToastTopic {
+    System,
+    DesktopNotification,
+    XSNotification,
+    IpdChange,
+}

 pub struct Toast {
    pub title: Arc<str>,
@@ -30,17 +42,19 @@ pub struct Toast {
    pub opacity: f32,
    pub timeout: f32,
    pub sound: bool,
+    pub topic: ToastTopic,
 }

 #[allow(dead_code)]
 impl Toast {
-    pub fn new(title: Arc<str>, body: Arc<str>) -> Self {
+    pub fn new(topic: ToastTopic, title: Arc<str>, body: Arc<str>) -> Self {
        Toast {
            title,
            body,
            opacity: 1.0,
            timeout: 3.0,
            sound: false,
+            topic,
        }
    }
    pub fn with_timeout(mut self, timeout: f32) -> Self {
@@ -59,41 +73,74 @@ impl Toast {
        self.submit_at(app, Instant::now());
    }
    pub fn submit_at(self, app: &mut AppState, instant: Instant) {
-        let auto_increment = AUTO_INCREMENT.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
-        let name: Arc<str> = format!("toast-{}", auto_increment).into();
-        let selector = OverlaySelector::Name(name.clone());
+        let selector = OverlaySelector::Name(TOAST_NAME.clone());

        let destroy_at = instant.add(std::time::Duration::from_secs_f32(self.timeout));

        let has_sound = self.sound && app.session.config.notifications_sound_enabled;

+        // drop any toast that was created before us.
+        // (DropOverlay only drops overlays that were
+        // created before current frame)
+        app.tasks
+            .enqueue_at(TaskType::DropOverlay(selector.clone()), instant);
+
+        // CreateOverlay only creates the overlay if
+        // the selector doesn't exist yet, so in case
+        // multiple toasts are submitted for the same
+        // frame, only the first one gets created
        app.tasks.enqueue_at(
            TaskType::CreateOverlay(
                selector.clone(),
-                Box::new(move |app| new_toast(self, name, app)),
+                Box::new(move |app| {
+                    let mut maybe_toast = new_toast(self, app);
+                    if let Some((state, _)) = maybe_toast.as_mut() {
+                        state.auto_movement(app);
+                        app.tasks.enqueue_at(
+                            // at timeout, drop the overlay by ID instead
+                            // in order to avoid dropping any newer toasts
+                            TaskType::DropOverlay(OverlaySelector::Id(state.id)),
+                            destroy_at,
+                        );
+                    }
+                    maybe_toast
+                }),
            ),
            instant,
        );

-        app.tasks
-            .enqueue_at(TaskType::DropOverlay(selector), destroy_at);
-
        if has_sound {
-            if let Some(handle) = app.audio.get_handle() {
-                let wav = include_bytes!("../res/557297.wav");
-                let cursor = Cursor::new(wav);
-                let source = Decoder::new_wav(cursor).unwrap();
-                let _ = handle.play_raw(source.convert_samples());
-            }
+            app.audio.play(TOAST_AUDIO_WAV);
        }
    }
 }

-fn new_toast(
-    toast: Toast,
-    name: Arc<str>,
-    app: &mut AppState,
-) -> Option<(OverlayState, Box<dyn OverlayBackend>)> {
+fn new_toast(toast: Toast, app: &mut AppState) -> Option<(OverlayState, Box<dyn OverlayBackend>)> {
+    let current_method = app
+        .session
+        .toast_topics
+        .get(toast.topic)
+        .copied()
+        .unwrap_or(DisplayMethod::Hide);
+
+    let (spawn_point, spawn_rotation, relative_to) = match current_method {
+        DisplayMethod::Hide => return None,
+        DisplayMethod::Center => (vec3a(0., -0.2, -0.5), Quat::IDENTITY, RelativeTo::Head),
+        DisplayMethod::Watch => {
+            let mut watch_pos = app.session.config.watch_pos + vec3a(-0.005, -0.05, 0.02);
+            let mut watch_rot = app.session.config.watch_rot;
+            let relative_to = match app.session.config.watch_hand {
+                LeftRight::Left => RelativeTo::Hand(0),
+                LeftRight::Right => {
+                    watch_pos.x = -watch_pos.x;
+                    watch_rot = watch_rot * Quat::from_rotation_x(PI) * Quat::from_rotation_z(PI);
+                    RelativeTo::Hand(1)
+                }
+            };
+            (watch_pos, watch_rot, relative_to)
+        }
+    };
+
    let title = if toast.title.len() > 0 {
        toast.title
    } else {
@@ -131,29 +178,29 @@ fn new_toast(
    .ok()?;

    canvas.font_size = FONT_SIZE;
-    canvas.fg_color = color_parse("#aaaaaa").unwrap(); // want panic
-    canvas.bg_color = color_parse("#333333").unwrap(); // want panic
-    canvas.panel(0., 0., size.0, size.1);
+    canvas.fg_color = color_parse("#cad3f5").unwrap(); // want panic
+    canvas.bg_color = color_parse("#1e2030").unwrap(); // want panic
+    canvas.panel(0., 0., size.0, size.1, 16.);

    if toast.body.len() > 0 {
-        log::info!("{}: {}", title, toast.body);
-        canvas.label(PADDING.0, 54., og_width, size.1 - 54., toast.body);
+        canvas.label(PADDING.0, 54., og_width, size.1 - 54., 3., toast.body);

-        canvas.fg_color = color_parse("#101010").unwrap(); // want panic
-        canvas.bg_color = color_parse("#666666").unwrap(); // want panic
-        canvas.panel(0., 0., size.0, 30.);
-        canvas.label_centered(PADDING.0, 16., og_width, FONT_SIZE as f32 + 2., title);
+        canvas.fg_color = color_parse("#b8c0e0").unwrap(); // want panic
+        canvas.bg_color = color_parse("#24273a").unwrap(); // want panic
+        canvas.panel(0., 0., size.0, 30., 16.);
+        canvas.label_centered(PADDING.0, 16., og_width, FONT_SIZE as f32 + 2., 16., title);
    } else {
-        log::info!("Toast: {}", title);
-        canvas.label_centered(PADDING.0, 0., og_width, size.1, title);
+        canvas.label_centered(PADDING.0, 0., og_width, size.1, 16., title);
    }

    let state = OverlayState {
-        name,
+        name: TOAST_NAME.clone(),
        want_visible: true,
        spawn_scale: size.0 * PIXELS_TO_METERS,
-        spawn_point: vec3a(0., -0.2, -0.5),
-        relative_to: RelativeTo::Head,
+        spawn_rotation,
+        spawn_point,
+        z_order: 70,
+        relative_to,
        ..Default::default()
    };
    let backend = Box::new(canvas.build());
@@ -1,27 +1,23 @@
-use glam::{Quat, Vec3A};
-use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
+use glam::Vec3A;

 use crate::{
    backend::overlay::{ui_transform, OverlayData, OverlayState, RelativeTo},
-    config::{
-        def_half, def_left, def_point7, def_watch_pos, def_watch_rot, load_known_yaml, ConfigType,
+    config::{load_known_yaml, ConfigType},
+    gui::{
+        canvas::Canvas,
+        modular::{modular_canvas, ModularData, ModularUiConfig},
    },
-    config_io,
-    gui::modular::{modular_canvas, ModularUiConfig},
-    state::{AppState, LeftRight},
+    state::AppState,
 };

 pub const WATCH_NAME: &str = "watch";

-pub fn create_watch<O>(state: &AppState) -> anyhow::Result<OverlayData<O>>
+pub fn create_watch<O>(state: &mut AppState) -> anyhow::Result<OverlayData<O>>
 where
    O: Default,
 {
    let config = load_known_yaml::<ModularUiConfig>(ConfigType::Watch);

-    let canvas = modular_canvas(&config.size, &config.elements, state)?;
-
    let relative_to = RelativeTo::Hand(state.session.config.watch_hand as usize);

    Ok(OverlayData {
@@ -29,23 +25,33 @@ where
            name: WATCH_NAME.into(),
            want_visible: true,
            interactable: true,
+            z_order: 68,
            spawn_scale: config.width,
-            spawn_point: Vec3A::from_slice(&state.session.config.watch_pos),
-            spawn_rotation: Quat::from_slice(&state.session.config.watch_rot),
+            spawn_point: state.session.config.watch_pos,
+            spawn_rotation: state.session.config.watch_rot,
            interaction_transform: ui_transform(&config.size),
            relative_to,
            ..Default::default()
        },
-        backend: Box::new(canvas),
+        backend: Box::new(create_watch_canvas(Some(config), state)?),
        ..Default::default()
    })
 }

+pub fn create_watch_canvas(
+    config: Option<ModularUiConfig>,
+    state: &mut AppState,
+) -> anyhow::Result<Canvas<(), ModularData>> {
+    let config = config.unwrap_or_else(|| load_known_yaml::<ModularUiConfig>(ConfigType::Watch));
+
+    modular_canvas(&config.size, &config.elements, state)
+}
+
 pub fn watch_fade<D>(app: &mut AppState, watch: &mut OverlayData<D>)
 where
    D: Default,
 {
-    if watch.state.saved_scale.is_some_and(|s| s < f32::EPSILON) {
+    if watch.state.saved_transform.is_some() {
        watch.state.want_visible = false;
        return;
    }
@@ -69,41 +75,3 @@ where
        watch.state.alpha = watch.state.alpha.clamp(0., 1.);
    }
 }
-
-#[derive(Deserialize, Serialize)]
-pub struct WatchConf {
-    #[serde(default = "def_watch_pos")]
-    pub watch_pos: [f32; 3],
-
-    #[serde(default = "def_watch_rot")]
-    pub watch_rot: [f32; 4],
-
-    #[serde(default = "def_left")]
-    pub watch_hand: LeftRight,
-
-    #[serde(default = "def_half")]
-    pub watch_view_angle_min: f32,
-
-    #[serde(default = "def_point7")]
-    pub watch_view_angle_max: f32,
-}
-
-fn get_config_path() -> PathBuf {
-    let mut path = config_io::get_conf_d_path();
-    path.push("watch_state.yaml");
-    path
-}
-pub fn save_watch(app: &mut AppState) -> anyhow::Result<()> {
-    let conf = WatchConf {
-        watch_pos: app.session.config.watch_pos,
-        watch_rot: app.session.config.watch_rot,
-        watch_hand: app.session.config.watch_hand,
-        watch_view_angle_min: app.session.config.watch_view_angle_min,
-        watch_view_angle_max: app.session.config.watch_view_angle_max,
-    };
-
-    let yaml = serde_yaml::to_string(&conf)?;
-    std::fs::write(get_config_path(), yaml)?;
-
-    Ok(())
-}
@@ -35,11 +35,21 @@
      "type": "boolean",
      "requirement": "optional"
    },
+    {
+      "name": "/actions/default/in/MoveMouse",
+      "type": "boolean",
+      "requirement": "optional"
+    },
    {
      "name": "/actions/default/in/SpaceDrag",
      "type": "boolean",
      "requirement": "optional"
    },
+    {
+      "name": "/actions/default/in/SpaceRotate",
+      "type": "boolean",
+      "requirement": "optional"
+    },
    {
      "name": "/actions/default/in/LeftHand",
      "type": "pose",
@@ -67,6 +67,9 @@
               "inputs" : {
                  "click" : {
                     "output" : "/actions/default/in/click"
+                  },
+                  "touch": {
+                     "output": "/actions/default/in/movemouse"
                  }
               },
               "mode" : "button",
@@ -80,6 +83,9 @@
               "inputs" : {
                  "click" : {
                     "output" : "/actions/default/in/click"
+                  },
+                  "touch": {
+                     "output": "/actions/default/in/movemouse"
                  }
               },
               "mode" : "button",
@@ -67,6 +67,9 @@
               "inputs" : {
                  "click" : {
                     "output" : "/actions/default/in/click"
+                  },
+                  "touch": {
+                     "output": "/actions/default/in/movemouse"
                  }
               },
               "mode": "button",
@@ -76,6 +79,9 @@
               "inputs" : {
                  "click" : {
                     "output" : "/actions/default/in/click"
+                  },
+                  "touch": {
+                     "output": "/actions/default/in/movemouse"
                  }
               },
               "mode": "button",
@@ -0,0 +1,29 @@
+# looking to make changes? 
+# drop me in ~/.config/wlxoverlay/anchor.yaml
+#
+
+width: 0.1
+
+size: [200, 200]
+
+# +X: right, +Y: up, +Z: back
+spawn_pos: [0, 0, -1]
+
+elements:
+  - type: Panel
+    rect: [98, 0, 4, 200]
+    corner_radius: 0
+    bg_color: "#ffff00"
+
+  - type: Panel
+    rect: [0, 98, 200, 4]
+    corner_radius: 0
+    bg_color: "#ffff00"
+
+  - type: Label
+    rect: [8, 90, 600, 70]
+    corner_radius: 0
+    font_size: 18
+    fg_color: "#ffff00"
+    source: Static
+    text: Center
@@ -11,3 +11,17 @@ keyboard_sound_enabled: true
 keyboard_scale: 1.0
 desktop_view_scale: 1.0
 watch_scale: 1.0
+
+# Enable / disable sliding windows back and forth with the scroll action
+# Default: true
+allow_sliding: true
+
+# Enable / disable realigning the working set windows when they are shown/hidden
+# Default: true
+realign_on_showhide: true
+
+# When enabled, the mouse pointer will not be moved on the screen, unless the trigger is touched
+# allowing for moving both pointers off the screens to the keyboard, while keeping the cursor position
+# unchanged, for when the desktop is configured to move the focus with the mouse cursor
+# Default: false
+focus_follows_mouse_mode: false
@@ -22,44 +22,24 @@ row_size: 23

 # Specifies the size of each key. The sum of any given row must equal RowSize
 key_sizes:
-    - [1.5,0.5, 1, 1, 1, 1,0.5,1, 1, 1, 1,0.5,1, 1, 1, 1, 0.5, 1, 1, 1, 4.5]
-    - [1,   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,     0.5, 1, 1, 1, 0.5, 1, 1, 1, 1]
-    - [1.5,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.5,  0.5, 1, 1, 1, 0.5, 1, 1, 1, 1]
-    - [1.75,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2.25,   4,                 1, 1, 1, 1]
-    - [2.25,    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2.75,    1.5,    1, 1.5,    1, 1, 1, 1]
-    - [1.25, 1.25, 1.25, 6.25, 1.25, 1.25, 1.25, 1.25, 0.5, 1, 1, 1, 0.5, 2,    1, 1]
+    - [1.5,0.5, 1, 1, 1, 1,0.5,1, 1, 1, 1,0.5,1, 1, 1, 1, 0.5, 1, 1, 1, 0.5, 1, 1, 1, 1]
+    - [1,   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,     0.5, 1, 1, 1, 0.5,    1, 1, 1, 1]
+    - [1.5,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.5,  0.5, 1, 1, 1, 0.5,    1, 1, 1, 1]
+    - [1.75,  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2.25,   4,                    1, 1, 1, 1]
+    - [1.25, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2.75,    1.5,    1, 1.5,       1, 1, 1, 1]
+    - [1.25, 1.25, 1.25, 6.25, 1.25, 1.25, 1.25, 1.25, 0.5, 1, 1, 1, 0.5,    2,    1, 1]

 # The main (blue) layout of the keyboard.
 # Accepted are:
-# - virtual keys, for a full list go to https://github.com/galister/X11Overlay/blob/master/Types/VirtualKey.cs
-# - ExecCommands (defined below)
-# - Macros (defined below)
+# - virtual keys. For a full list, look at enum VirtualKey in https://github.com/galister/wlx-overlay-s/blob/main/src/hid.rs
+# - exec_commands (defined below)
+# - macros (defined below)
 # - ~ (null) will leave an empty space with the corresponding size from key_sizes
 main_layout:
-    - ["Escape", ~, "F1", "F2", "F3", "F4", ~, "F5", "F6", "F7", "F8", ~, "F9", "F10", "F11", "F12", ~, "Print", "Scroll", "Pause", ~]
+    - ["Escape", ~, "F1", "F2", "F3", "F4", ~, "F5", "F6", "F7", "F8", ~, "F9", "F10", "F11", "F12", ~, "Print", "Scroll", "Pause", ~, "COPY", "PASTE", ~, "KILL"]
    - ["Oem3", "N1", "N2", "N3", "N4", "N5", "N6", "N7", "N8", "N9", "N0", "Minus", "Plus", "BackSpace", ~, "Insert", "Home", "Prior", ~, "NumLock", "KP_Divide", "KP_Multiply", "KP_Subtract"]
    - ["Tab", "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P", "Oem4", "Oem6", "Oem5", ~, "Delete", "End", "Next", ~, "KP_7", "KP_8", "KP_9", "KP_Add"]
    - ["XF86Favorites", "A", "S", "D", "F", "G", "H", "J", "K", "L", "Oem1", "Oem7", "Return", ~, "KP_4", "KP_5", "KP_6", ~]
-    - ["LShift", "Z", "X", "C", "V", "B", "N", "M", "Comma", "Period", "Oem2", "RShift", ~, "Up", ~, "KP_1", "KP_2", "KP_3", "KP_Enter"]
-    - ["LCtrl", "LSuper", "LAlt", "Space", "Meta", "RSuper", "Menu", "RCtrl", ~, "Left", "Down", "Right", ~, "KP_0", "KP_Decimal", ~]
-
-# When using the purple pointer...
-# None   - No special functionality when using purple pointer
-# Shift  - Use same functionality as the orange pointer
-# Ctrl   - Use Main layout with Ctrl modifier
-# Super  - Use Main layout with Super (WinKey) modifier
-# Meta   - Use Main layout with Meta (AltGr) modifier
-# Layout - Use the alt_layout defined below
-alt_layout_mode: Ctrl
-
-# The alt (fn) layout of the keyboard. Only takes effect when alt_layout_mode: Layout
-# Accepted values are the same as for MainLayout.
-# The default layout here is a dummy. Change it to fit your liking.
-alt_layout:
-    - ["Escape", ~, "F1", "F2", "F3", "F4", ~, "F5", "F6", "F7", "F8", ~, "F9", "F10", "F11", "F12", ~, "Print", "Scroll", "Pause", ~, "COPY", "PASTE"]
-    - ["Oem3", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "Minus", "Plus", "BackSpace", ~, "Insert", "Home", "Prior", ~, "NumLock", "KP_Divide", "KP_Multiply", "KP_Subtract"]
-    - ["Tab", "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P", "Oem4", "Oem6", "Oem5", ~, "Delete", "End", "Next", ~, "KP_7", "KP_8", "KP_9", "KP_Add"]
-    - ["XF86Favorites", "A", "S", "D", "F", "G", "H", "J", "K", "L", "Oem1", "Oem7", "Return", ~, "KP_4", "KP_5", "KP_6", ~]
    - ["LShift", "Oem102", "Z", "X", "C", "V", "B", "N", "M", "Comma", "Period", "Oem2", "RShift", ~, "Up", ~, "KP_1", "KP_2", "KP_3", "KP_Enter"]
    - ["LCtrl", "LSuper", "LAlt", "Space", "Meta", "RSuper", "Menu", "RCtrl", ~, "Left", "Down", "Right", ~, "KP_0", "KP_Decimal", ~]

@@ -70,7 +50,7 @@ exec_commands:

 # Series of keypresses to be used in a layout.
 # Format: keyName [DOWN|UP]
-# keyName must be a valid key from `xmodmap -pke`
+# keyName must be a valid virtual key from the VirtualKey enum (see above)
 # DOWN|UP: can be omitted for an implicit "keyName DOWN, keyName UP"
 macros:
    KILL: [ "LSuper DOWN", "LCtrl DOWN", "Escape", "LCtrl UP", "LSuper UP" ]
@@ -78,52 +58,55 @@ macros:
    PASTE: [ "LCtrl DOWN", "V", "LCtrl UP" ]

 # Custom labels to use.
-# Key: element of MainLayout / AltLayout
+# Key: element of main_layout
 # Value: Array of strings. 0th element is the upper row, 1st element is lower row.
 # For empty labels, use [] (do not use ~)
 labels:
-    "N1":            ["1", "!"]
-    "N2":            ["2", "@"]
-    "N3":            ["3", "#"]
-    "N4":            ["4", "$"]
-    "N5":            ["5", "%"]
-    "N6":            ["6", "^"]
-    "N7":            ["7", "&"]
-    "N8":            ["8", "*"]
-    "N9":            ["9", "("]
-    "N0":            ["0", ")"]
-    "Escape":       ["Esc"]
-    "Prior":        ["PgUp"]
-    "Next":         ["PgDn"]
-    "NumLock":      ["Num"]
-    "Space":        []
-    "LAlt":         ["Alt"]
-    "LCtrl":        ["Ctrl"]
-    "RCtrl":        ["Ctrl"]
-    "LSuper":       ["Super"]
-    "RSuper":       ["Super"]
-    "LShift":       ["Shift"]
-    "RShift":       ["Shift"]
-    "Insert":       ["Ins"]
-    "Delete":       ["Del"]
-    "Minus":        ["-", "_"]
-    "Plus":         ["=", "+"]
-    "BackSpace":    ["<<"]
-    "Comma":        [" ,",  "<"]
-    "Period":       [" .",  ">"]
-    "Oem1":         [" ;",  ":"]
-    "Oem2":         [" /",  "?"]
-    "Oem3":         ["`", "~"]
-    "Oem4":         [" [",  "{"]
-    "Oem5":         [" \\", "|"]
-    "Oem6":         [" ]",  "}"]
-    "Oem7":         [" '",  "\""]
-    "Oem102":       [" \\", "|"]
-    "KP_Divide":    [" /"]
-    "KP_Add":       [" +"]
-    "KP_Multiply":  [" *"]
-    "KP_Decimal":   [" ."]
-    "KP_Subtract":  [" -"]
-    "KP_Enter":     ["Ent"]
-    "XF86Favorites": ["Rofi"]
+    "Escape":         ["Esc"]
+    "Prior":          ["PgUp"]
+    "Next":           ["PgDn"]
+    "NumLock":        ["Num"]
+    "Space":          []
+    "LAlt":           ["Alt"]
+    "LCtrl":          ["Ctrl"]
+    "RCtrl":          ["Ctrl"]
+    "LSuper":         ["Super"]
+    "RSuper":         ["Super"]
+    "LShift":         ["Shift"]
+    "RShift":         ["Shift"]
+    "Insert":         ["Ins"]
+    "Delete":         ["Del"]
+    "BackSpace":      ["<<"]
+    "KP_Divide":      [" /"]
+    "KP_Add":         [" +"]
+    "KP_Multiply":    [" *"]
+    "KP_Decimal":     [" ."]
+    "KP_Subtract":    [" -"]
+    "KP_Enter":       ["Ent"]
+    "Print":          ["Prn"]
+    "Scroll":         ["Scr"]
+    "Pause":          ["Brk"]
+    "XF86Favorites":  ["Menu"] # fallback labels below
+    "N1":             ["1", "!"]
+    "N2":             ["2", "@"]
+    "N3":             ["3", "#"]
+    "N4":             ["4", "$"]
+    "N5":             ["5", "%"]
+    "N6":             ["6", "^"]
+    "N7":             ["7", "&"]
+    "N8":             ["8", "*"]
+    "N9":             ["9", "("]
+    "N0":             ["0", ")"]
+    "Minus":          ["-", "_"]
+    "Plus":           ["=", "+"]
+    "Comma":          [" ,",  "<"]
+    "Period":         [" .",  ">"]
+    "Oem1":           [" ;",  ":"]
+    "Oem2":           [" /",  "?"]
+    "Oem3":           ["`", "~"]
+    "Oem4":           [" [",  "{"]
+    "Oem5":           [" \\", "|"]
+    "Oem6":           [" ]",  "}"]
+    "Oem7":           [" '",  "\""]
+    "Oem102":         [" \\", "|"] 

@@ -12,20 +12,23 @@ spawn_pos: [0, -0.1, -0.5]
 elements:
  - type: Panel
    rect: [0, 0, 600, 800]
-    bg_color: "#102030"
+    corner_radius: 8
+    bg_color: "#1e2030"

  - type: Label
    rect: [15, 35, 600, 70]
+    corner_radius: 6
    font_size: 24
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: Settings

  - type: Button
    rect: [560, 0, 40, 40]
+    corner_radius: 8
    font_size: 16
-    bg_color: "#880000"
-    fg_color: "#ffffff"
+    bg_color: "#ed8796"
+    fg_color: "#24273a"
    text: X
    click_down:
      - type: Window
@@ -34,33 +37,38 @@ elements:

  - type: Panel
    rect: [50, 53, 500, 1]
-    bg_color: "#c0c0c0"
+    corner_radius: 6
+    bg_color: "#6e738d"

  ####### Watch Section #######

  - type: Label
    rect: [15, 85, 570, 24]
+    corner_radius: 6
    font_size: 18
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: Watch

  - type: Panel
    rect: [250, 105, 1, 100]
-    bg_color: "#c0c0c0"
+    corner_radius: 6
+    bg_color: "#6e738d"

  - type: Label
    rect: [288, 105, 100, 24]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: Visibility

  - type: Button
    rect: [270, 120, 100, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#306060"
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
    text: "Hide"
    click_down:
      - type: Watch
@@ -68,9 +76,10 @@ elements:

  - type: Button
    rect: [270, 170, 100, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#306060"
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
    text: "Swap Hand"
    click_down:
      - type: Watch
@@ -78,20 +87,23 @@ elements:

  - type: Panel
    rect: [390, 105, 1, 100]
-    bg_color: "#c0c0c0"
+    corner_radius: 6
+    bg_color: "#6e738d"

  - type: Label
    rect: [430, 105, 120, 24]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: Watch Fade

  - type: Button
    rect: [410, 120, 140, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#306060"
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
    text: "Cutoff Point"
    click_down:
      - type: Toast
@@ -107,9 +119,10 @@ elements:

  - type: Button
    rect: [410, 170, 140, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#306060"
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
    text: "Cutoff Strength"
    click_down:
      - type: Toast
@@ -125,16 +138,18 @@ elements:

  - type: Label
    rect: [25, 140, 90, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: Rotation

  - type: Button
    rect: [108, 120, 30, 30]
+    corner_radius: 15
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#306060"
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
    text: "X"
    click_down:
      - type: Toast
@@ -150,9 +165,10 @@ elements:

  - type: Button
    rect: [153, 120, 30, 30]
+    corner_radius: 15
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#306060"
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
    text: "Y"
    click_down:
      - type: Toast
@@ -168,9 +184,10 @@ elements:

  - type: Button
    rect: [198, 120, 30, 30]
+    corner_radius: 15
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#306060"
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
    text: "Z"
    click_down:
      - type: Toast
@@ -186,16 +203,18 @@ elements:

  - type: Label
    rect: [25, 190, 90, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: Position

  - type: Button
    rect: [108, 170, 30, 30]
+    corner_radius: 15
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#306060"
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
    text: "X"
    click_down:
      - type: Toast
@@ -211,9 +230,10 @@ elements:

  - type: Button
    rect: [153, 170, 30, 30]
+    corner_radius: 15
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#306060"
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
    text: "Y"
    click_down:
      - type: Toast
@@ -229,9 +249,10 @@ elements:

  - type: Button
    rect: [198, 170, 30, 30]
+    corner_radius: 15
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#306060"
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
    text: "Z"
    click_down:
      - type: Toast
@@ -247,28 +268,32 @@ elements:

  - type: Panel
    rect: [50, 220, 500, 1]
-    bg_color: "#c0c0c0"
+    corner_radius: 6
+    bg_color: "#6e738d"

  ####### Mirror Section #######
  - type: Label
    rect: [15, 255, 570, 24]
+    corner_radius: 6
    font_size: 18
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: Mirrors

  - type: Label
    rect: [25, 290, 30, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: M1

  - type: Button
    rect: [60, 270, 110, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#707070"
+    fg_color: "#cad3f5"
+    bg_color: "#494d64"
    text: "Show/Hide"
    click_down: # ToggleVisible if exists, else create
      - type: Overlay
@@ -280,9 +305,10 @@ elements:

  - type: Button
    rect: [185, 270, 60, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#707070"
+    fg_color: "#cad3f5"
+    bg_color: "#494d64"
    text: "Lock"
    click_down:
      - type: Overlay
@@ -291,9 +317,10 @@ elements:

  - type: Button
    rect: [258, 270, 30, 30]
+    corner_radius: 15
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#880000"
+    fg_color: "#24273a"
+    bg_color: "#ed8796"
    text: "X"
    click_down:
      - type: Window
@@ -302,16 +329,18 @@ elements:

  - type: Label
    rect: [25, 340, 30, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: M2

  - type: Button
    rect: [60, 320, 110, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#707070"
+    fg_color: "#cad3f5"
+    bg_color: "#494d64"
    text: "Show/Hide"
    click_down:
      - type: Overlay
@@ -323,9 +352,10 @@ elements:

  - type: Button
    rect: [185, 320, 60, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#707070"
+    fg_color: "#cad3f5"
+    bg_color: "#494d64"
    text: "Lock"
    click_down:
      - type: Overlay
@@ -334,9 +364,10 @@ elements:

  - type: Button
    rect: [258, 320, 30, 30]
+    corner_radius: 15
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#880000"
+    fg_color: "#24273a"
+    bg_color: "#ed8796"
    text: "X"
    click_down:
      - type: Window
@@ -345,16 +376,18 @@ elements:

  - type: Label
    rect: [25, 390, 30, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: M3

  - type: Button
    rect: [60, 370, 110, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#707070"
+    fg_color: "#cad3f5"
+    bg_color: "#494d64"
    text: "Show/Hide"
    click_down:
      - type: Overlay
@@ -366,9 +399,10 @@ elements:

  - type: Button
    rect: [185, 370, 60, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#707070"
+    fg_color: "#cad3f5"
+    bg_color: "#494d64"
    text: "Lock"
    click_down:
      - type: Overlay
@@ -377,9 +411,10 @@ elements:

  - type: Button
    rect: [258, 370, 30, 30]
+    corner_radius: 15
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#880000"
+    fg_color: "#24273a"
+    bg_color: "#ed8796"
    text: "X"
    click_down:
      - type: Window
@@ -388,29 +423,33 @@ elements:

  - type: Panel
    rect: [300, 240, 1, 200]
-    bg_color: "#c0c0c0"
+    corner_radius: 6
+    bg_color: "#6e738d"

  ####### Color Gain Section #######

  - type: Label
    rect: [325, 255, 90, 24]
+    corner_radius: 6
    font_size: 18
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: Color Gain

  - type: Label
    rect: [470, 255, 90, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: (SteamVR)

  - type: Button
    rect: [330, 270, 60, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#707070"
+    fg_color: "#cad3f5"
+    bg_color: "#494d64"
    text: "All"
    click_down:
      - type: Toast
@@ -426,9 +465,10 @@ elements:

  - type: Button
    rect: [405, 270, 30, 30]
+    corner_radius: 15
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#701010"
+    fg_color: "#24273a"
+    bg_color: "#e78284"
    text: "R"
    click_down:
      - type: Toast
@@ -444,9 +484,10 @@ elements:

  - type: Button
    rect: [450, 270, 30, 30]
+    corner_radius: 15
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#107010"
+    fg_color: "#24273a"
+    bg_color: "#a6d189"
    text: "G"
    click_down:
      - type: Toast
@@ -462,9 +503,10 @@ elements:

  - type: Button
    rect: [495, 270, 30, 30]
+    corner_radius: 15
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#101070"
+    fg_color: "#24273a"
+    bg_color: "#8caaee"
    text: "B"
    click_down:
      - type: Toast
@@ -480,81 +522,149 @@ elements:

  - type: Panel
    rect: [325, 315, 225, 1]
-    bg_color: "#c0c0c0"
+    corner_radius: 6
+    bg_color: "#6e738d"

  ####### Playspace Section #######

  - type: Label
    rect: [325, 345, 90, 24]
+    corner_radius: 6
    font_size: 18
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: Playspace

  - type: Button
    rect: [330, 360, 220, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#206060"
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
    text: "Fix Floor"
    click_down:
      - type: System
        action: PlayspaceFixFloor
+      - type: Window
+        target: "settings"
+        action: Destroy

  - type: Button
    rect: [330, 410, 220, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#206060"
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
    text: "Reset Offset"
    click_down:
      - type: System
        action: PlayspaceResetOffset
+      - type: Window
+        target: "settings"
+        action: Destroy

  ####### Notifications Section #######

  - type: Panel
    rect: [50, 460, 500, 1]
-    bg_color: "#c0c0c0"
+    corner_radius: 6
+    bg_color: "#6e738d"

  - type: Label
    rect: [325, 490, 90, 24]
+    corner_radius: 6
    font_size: 18
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Static
    text: Notifications

  - type: Button
    rect: [330, 505, 220, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#606020"
+    fg_color: "#24273a"
+    bg_color: "#e64553"
    text: "Enabled"
    click_down:
      - type: System
        action: ToggleNotifications
+    highlight: Notifications

  - type: Button
    rect: [330, 555, 220, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#606020"
+    fg_color: "#24273a"
+    bg_color: "#e64553"
    text: "Sound Enabled"
    click_down:
      - type: System
        action: ToggleNotificationSounds
+    highlight: NotificationSounds
+
+  ####### Behavior Section #######
+  - type: Label
+    rect: [15, 490, 570, 24]
+    corner_radius: 6
+    font_size: 18
+    fg_color: "#cad3f5"
+    source: Static
+    text: Behavior
+
+  - type: Button
+    rect: [30, 505, 220, 30]
+    corner_radius: 6
+    font_size: 12
+    fg_color: "#24273a"
+    bg_color: "#e64553"
+    text: "Auto-Realign"
+    click_down:
+      - type: System
+        action: ToggleAutoRealign
+    highlight: AutoRealign
+
+  - type: Button
+    rect: [30, 555, 220, 30]
+    corner_radius: 6
+    font_size: 12
+    fg_color: "#24273a"
+    bg_color: "#e64553"
+    text: "Grab+Scroll Slide"
+    click_down:
+      - type: System
+        action: ToggleAllowSliding
+    highlight: AllowSliding
+
+  ####### Footer Section #######

  - type: Panel
    rect: [50, 605, 500, 1]
-    bg_color: "#c0c0c0"
+    corner_radius: 6
+    bg_color: "#6e738d"

  - type: Button
    rect: [330, 625, 220, 30]
+    corner_radius: 6
    font_size: 12
-    fg_color: "#ffffff"
-    bg_color: "#206060"
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
    text: "Save Config"
    click_down:
      - type: System
        action: PersistConfig
+      - type: Toast
+        message: Settings saved successfully.
+
+  - type: Button
+    rect: [30, 625, 250, 30]
+    corner_radius: 6
+    font_size: 12
+    fg_color: "#24273a"
+    bg_color: "#eed49f"
+    text: "Save Overlay Layout"
+    click_down:
+      - type: System
+        action: PersistLayout
+      - type: Toast
+        message: Saved. You will see this layout on next startup.

@@ -9,14 +9,16 @@ size: [400, 200]
 elements:
  # background panel
  - type: Panel
-    rect: [0, 0, 400, 200]
-    bg_color: "#353535"
+    rect: [0, 30, 400, 130]
+    corner_radius: 20
+    bg_color: "#24273a"

  - type: Button
    rect: [2, 162, 26, 36]
-    font_size: 14
-    bg_color: "#808040"
-    fg_color: "#ffffff"
+    corner_radius: 4
+    font_size: 15
+    bg_color: "#c6a0f6"
+    fg_color: "#24273a"
    text: "C"
    click_up: # destroy if exists, otherwise create
      - type: Window
@@ -29,9 +31,10 @@ elements:
  # Keyboard button
  - type: Button
    rect: [32, 162, 60, 36]
-    font_size: 14
-    fg_color: "#FFFFFF"
-    bg_color: "#406050"
+    corner_radius: 4
+    font_size: 15
+    fg_color: "#24273a"
+    bg_color: "#a6da95"
    text: Kbd
    click_up:
      - type: Overlay
@@ -63,9 +66,10 @@ elements:
  # bottom row, of keyboard + overlays
  - type: OverlayList
    rect: [94, 160, 306, 40]
-    font_size: 14
-    fg_color: "#FFFFFF"
-    bg_color: "#405060"
+    corner_radius: 4
+    font_size: 15
+    fg_color: "#cad3f5"
+    bg_color: "#1e2030"
    layout: Horizontal
    click_up: ToggleVisible
    long_click_up: Reset
@@ -79,25 +83,28 @@ elements:
  # local clock
  - type: Label
    rect: [19, 90, 200, 50]
-    font_size: 46
-    fg_color: "#ffffff"
+    corner_radius: 4
+    font_size: 46 # Use 32 for 12-hour time
+    fg_color: "#cad3f5"
    source: Clock
    format: "%H:%M" # 23:59
-    #format: "%h:%M %p" # 11:59 PM
+    #format: "%I:%M %p" # 11:59 PM
 
  # local date
  - type: Label
    rect: [20, 117, 200, 20]
+    corner_radius: 4
    font_size: 14
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Clock
    format: "%x" # local date representation

  # local day-of-week
  - type: Label
    rect: [20, 137, 200, 50]
+    corner_radius: 4
    font_size: 14
-    fg_color: "#ffffff"
+    fg_color: "#cad3f5"
    source: Clock
    format: "%A" # Tuesday
    #format: "%a" # Tue
@@ -105,62 +112,69 @@ elements:
  # alt clock 1
  - type: Label
    rect: [210, 90, 200, 50]
-    font_size: 24
-    fg_color: "#99BBAA"
+    corner_radius: 4
+    font_size: 24 # Use 18 for 12-hour time
+    fg_color: "#8bd5ca"
    source: Clock
    timezone: "Asia/Tokyo" # change TZ1 here
    format: "%H:%M" # 23:59
-    #format: "%h:%M %p" # 11:59 PM
+    #format: "%I:%M %p" # 11:59 PM
  - type: Label
    rect: [210, 60, 200, 50]
+    corner_radius: 4
    font_size: 14
-    fg_color: "#99BBAA"
+    fg_color: "#8bd5ca"
    source: Static
    text: "Tokyo" # change TZ1 label here
 
  # alt clock 2
  - type: Label
    rect: [210, 150, 200, 50]
-    font_size: 24
-    fg_color: "#AA99BB"
+    corner_radius: 4
+    font_size: 24 # Use 18 for 12-hour time
+    fg_color: "#b7bdf8"
    source: Clock
    timezone: "America/Chicago" # change TZ2 here
    format: "%H:%M" # 23:59
-    #format: "%h:%M %p" # 11:59 PM
+    #format: "%I:%M %p" # 11:59 PM
  - type: Label
    rect: [210, 120, 200, 50]
+    corner_radius: 4
    font_size: 14
-    fg_color: "#AA99BB"
+    fg_color: "#b7bdf8"
    source: Static
    text: "Chicago" # change TZ2 label here

  # batteries
  - type: BatteryList
-    rect: [0, 0, 400, 30]
-    font_size: 14
-    fg_color: "#99BBAA"
+    rect: [0, 5, 400, 30]
+    corner_radius: 4
+    font_size: 16
+    fg_color: "#8bd5ca"
    fg_color_low: "#B06060"
    fg_color_charging: "#6080A0"
    num_devices: 9
    layout: Horizontal
-    low_threshold: 20
+    low_threshold: 33

  # volume buttons
  - type: Button
-    rect: [327, 52, 46, 32]
-    font_size: 14
-    fg_color: "#FFFFFF"
-    bg_color: "#505050"
-    text: "+"
+    rect: [315, 52, 70, 32]
+    corner_radius: 4
+    font_size: 13
+    fg_color: "#cad3f5"
+    bg_color: "#5b6078"
+    text: "Vol +"
    click_down:
      - type: Exec
        command: [ "pactl", "set-sink-volume", "@DEFAULT_SINK@", "+5%" ]
  - type: Button
-    rect: [327, 116, 46, 32]
-    font_size: 14
-    fg_color: "#FFFFFF"
-    bg_color: "#505050"
-    text: "-"
+    rect: [315, 116, 70, 32]
+    corner_radius: 4
+    font_size: 13
+    fg_color: "#cad3f5"
+    bg_color: "#5b6078"
+    text: "Vol -"
    click_down:
      - type: Exec
        command: [ "pactl", "set-sink-volume", "@DEFAULT_SINK@", "-5%" ]
@@ -27,15 +27,30 @@ pub mod frag_color {

            layout (set = 0, binding = 0) uniform ColorBlock {
                uniform vec4 in_color;
+                uniform vec2 corner_radius;
            };

            void main()
            {
+                out_color.r = corner_radius.r;
                out_color = in_color;
+
+                vec2 uv_circ = ((1. - corner_radius) - (abs(in_uv + vec2(-0.5)) * 2.))/corner_radius;
+                float dist = length(uv_circ);
+
+                out_color.a = mix(out_color.a, 0.,
+                        float(dist > 1.)
+                        * float(uv_circ.x < 0.)
+                        * float(uv_circ.y < 0.));
            }
        ",
    }
 }
+            //layout (location = 1) in float corner_radius;
+                //out_color = in_color;
+                // Some equation that determines whether to keep the pixel
+                // Use Lerp not if
+                //out_color.a = 0;

 pub mod frag_glyph {
    vulkano_shaders::shader! {
@@ -61,6 +76,52 @@ pub mod frag_glyph {
    }
 }

+pub mod frag_sprite2 {
+    vulkano_shaders::shader! {
+        ty: "fragment",
+        src: r"#version 310 es
+            precision highp float;
+
+            layout (location = 0) in vec2 in_uv;
+            layout (location = 0) out vec4 out_color;
+
+            layout (set = 0, binding = 0) uniform sampler2D in_texture;
+            layout (set = 1, binding = 0) uniform UniBlock {
+                uniform vec4 st;
+                uniform vec4 mul;
+            };
+
+            void main()
+            {
+                out_color = texture(in_texture, (in_uv * st.xy) + st.zw) * mul;
+            }
+        ",
+    }
+}
+
+pub mod frag_sprite2_hl {
+    vulkano_shaders::shader! {
+        ty: "fragment",
+        src: r"#version 310 es
+            precision highp float;
+
+            layout (location = 0) in vec2 in_uv;
+            layout (location = 0) out vec4 out_color;
+
+            layout (set = 0, binding = 0) uniform sampler2D in_texture;
+            layout (set = 1, binding = 0) uniform UniBlock {
+                uniform vec4 st;
+                uniform vec4 mul;
+            };
+
+            void main()
+            {
+                out_color = texture(in_texture, (in_uv * st.xy) + st.zw).a * mul;
+            }
+        ",
+    }
+}
+
 pub mod frag_sprite {
    vulkano_shaders::shader! {
        ty: "fragment",
@@ -80,6 +141,31 @@ pub mod frag_sprite {
    }
 }

+pub mod frag_grid {
+    vulkano_shaders::shader! {
+        ty: "fragment",
+        src: r"#version 310 es
+            precision highp float;
+
+            layout (location = 0) in vec2 in_uv;
+            layout (location = 0) out vec4 out_color;
+
+            void main()
+            {
+                float fade = max(1.0 - 2.0 * length(in_uv.xy + vec2(-0.5, -0.5)), 0.0);
+                float grid;
+
+                if (fract(in_uv.x / 0.0005) < 0.01 || fract(in_uv.y / 0.0005) < 0.01) {
+                    grid = 1.0;
+                } else {
+                    grid = 0.0;
+                }
+                out_color = vec4(1.0, 1.0, 1.0, grid * fade);
+            }
+        ",
+    }
+}
+
 pub mod frag_screen {
    vulkano_shaders::shader! {
        ty: "fragment",
@@ -94,6 +180,12 @@ pub mod frag_screen {
            void main()
            {
                out_color = texture(in_texture, in_uv);
+
+                // linear to srgb
+                bvec4 cutoff = lessThan(out_color, vec4(0.0031308));
+                vec4 higher = (pow(out_color, vec4(0.4166667)) * vec4(1.055)) - vec4(0.055);
+                vec4 lower = out_color*vec4(12.92);
+                out_color = mix(higher, lower, cutoff);
                out_color.a = 1.0;
            }
        ",
@@ -129,3 +221,26 @@ pub mod frag_srgb {
        ",
    }
 }
+
+pub mod frag_swapchain {
+    vulkano_shaders::shader! {
+        ty: "fragment",
+        src: r"#version 310 es
+            precision highp float;
+
+            layout (location = 0) in vec2 in_uv;
+            layout (location = 0) out vec4 out_color;
+
+            layout (set = 0, binding = 0) uniform sampler2D in_texture;
+            layout (set = 1, binding = 0) uniform AlphaBlock {
+                uniform float alpha;
+            };
+
+            void main()
+            {
+                out_color = texture(in_texture, in_uv);
+                out_color.a *= alpha;
+            }
+        ",
+    }
+}
@@ -1,20 +1,25 @@
-use std::{path::PathBuf, sync::Arc};
+use std::{io::Cursor, sync::Arc};

 use anyhow::bail;
-use glam::Vec3;
-use rodio::{OutputStream, OutputStreamHandle};
+use glam::Affine3A;
+use idmap::IdMap;
+use rodio::{Decoder, OutputStream, OutputStreamHandle, Source};
 use serde::{Deserialize, Serialize};
 use smallvec::{smallvec, SmallVec};
-use vulkano::format::Format;
+use vulkano::image::view::ImageView;

 use crate::{
-    backend::{common::TaskContainer, input::InputState},
-    config::GeneralConfig,
+    backend::{input::InputState, task::TaskContainer},
+    config::{AStrMap, GeneralConfig},
    config_io,
    graphics::WlxGraphics,
    gui::font::FontCache,
    hid::HidProvider,
-    shaders::{frag_color, frag_glyph, frag_screen, frag_sprite, frag_srgb, vert_common},
+    overlays::toast::{DisplayMethod, ToastTopic},
+    shaders::{
+        frag_color, frag_glyph, frag_grid, frag_screen, frag_sprite, frag_sprite2, frag_sprite2_hl,
+        frag_swapchain, vert_common,
+    },
 };

 pub struct AppState {
@@ -22,11 +27,12 @@ pub struct AppState {
    pub session: AppSession,
    pub tasks: TaskContainer,
    pub graphics: Arc<WlxGraphics>,
-    pub format: vulkano::format::Format,
    pub input_state: InputState,
    pub hid_provider: Box<dyn HidProvider>,
    pub audio: AudioOutput,
    pub screens: SmallVec<[ScreenMeta; 8]>,
+    pub anchor: Affine3A,
+    pub sprites: AStrMap<Arc<ImageView>>,
 }

 impl AppState {
@@ -46,38 +52,46 @@ impl AppState {
            let shader = frag_glyph::load(graphics.device.clone())?;
            shaders.insert("frag_glyph", shader);

+            let shader = frag_grid::load(graphics.device.clone())?;
+            shaders.insert("frag_grid", shader);
+
            let shader = frag_sprite::load(graphics.device.clone())?;
            shaders.insert("frag_sprite", shader);

+            let shader = frag_sprite2::load(graphics.device.clone())?;
+            shaders.insert("frag_sprite2", shader);
+
+            let shader = frag_sprite2_hl::load(graphics.device.clone())?;
+            shaders.insert("frag_sprite2_hl", shader);
+
            let shader = frag_screen::load(graphics.device.clone())?;
            shaders.insert("frag_screen", shader);

-            let shader = frag_srgb::load(graphics.device.clone())?;
-            shaders.insert("frag_srgb", shader);
+            let shader = frag_swapchain::load(graphics.device.clone())?;
+            shaders.insert("frag_swapchain", shader);
        }

+        let session = AppSession::load();
+
        Ok(AppState {
-            fc: FontCache::new()?,
-            session: AppSession::load(),
+            fc: FontCache::new(session.config.primary_font.clone())?,
+            session,
            tasks: TaskContainer::new(),
            graphics,
-            format: Format::R8G8B8A8_UNORM,
            input_state: InputState::new(),
            hid_provider: crate::hid::initialize(),
            audio: AudioOutput::new(),
            screens: smallvec![],
+            anchor: Affine3A::IDENTITY,
+            sprites: AStrMap::new(),
        })
    }
 }

 pub struct AppSession {
-    pub config_root_path: PathBuf,
    pub config: GeneralConfig,

-    pub color_norm: Vec3,
-    pub color_shift: Vec3,
-    pub color_alt: Vec3,
-    pub color_grab: Vec3,
+    pub toast_topics: IdMap<ToastTopic, DisplayMethod>,
 }

 impl AppSession {
@@ -86,29 +100,18 @@ impl AppSession {
        log::info!("Config root path: {}", config_root_path.to_string_lossy());
        let config = GeneralConfig::load_from_disk();

+        let mut toast_topics = IdMap::new();
+        toast_topics.insert(ToastTopic::System, DisplayMethod::Center);
+        toast_topics.insert(ToastTopic::DesktopNotification, DisplayMethod::Center);
+        toast_topics.insert(ToastTopic::XSNotification, DisplayMethod::Center);
+
+        config.notification_topics.iter().for_each(|(k, v)| {
+            toast_topics.insert(*k, *v);
+        });
+
        AppSession {
-            config_root_path,
            config,
-            color_norm: Vec3 {
-                x: 0.,
-                y: 1.,
-                z: 1.,
-            },
-            color_shift: Vec3 {
-                x: 1.,
-                y: 1.,
-                z: 0.,
-            },
-            color_alt: Vec3 {
-                x: 1.,
-                y: 0.,
-                z: 1.,
-            },
-            color_grab: Vec3 {
-                x: 1.,
-                y: 0.,
-                z: 0.,
-            },
+            toast_topics,
        }
    }
 }
@@ -126,23 +129,39 @@ impl AudioOutput {
        }
    }

-    pub fn get_handle(&mut self) -> Option<&OutputStreamHandle> {
+    fn get_handle(&mut self) -> Option<&OutputStreamHandle> {
        if self.audio_stream.is_none() && self.first_try {
            self.first_try = false;
            if let Ok((stream, handle)) = OutputStream::try_default() {
                self.audio_stream = Some((stream, handle));
            } else {
-                log::error!("Failed to open audio stream");
+                log::error!("Failed to open audio stream. Audio will not work.");
                return None;
            }
        }
        self.audio_stream.as_ref().map(|(_, h)| h)
    }
+
+    pub fn play(&mut self, wav_bytes: &'static [u8]) {
+        let Some(handle) = self.get_handle() else {
+            return;
+        };
+        let cursor = Cursor::new(wav_bytes);
+        let source = match Decoder::new_wav(cursor) {
+            Ok(source) => source,
+            Err(e) => {
+                log::error!("Failed to play sound: {:?}", e);
+                return;
+            }
+        };
+        let _ = handle.play_raw(source.convert_samples());
+    }
 }

 pub struct ScreenMeta {
    pub name: Arc<str>,
    pub id: usize,
+    pub native_handle: u32,
 }

 #[derive(Serialize, Deserialize, Clone, Copy, Default)]
@@ -0,0 +1,787 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="127.99999"
+   height="127.99999"
+   viewBox="0 0 266.92913 266.92913"
+   version="1.1"
+   id="svg1"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs1">
+    <linearGradient
+       id="linearGradient207">
+      <stop
+         style="stop-color:#131a23;stop-opacity:1;"
+         offset="0"
+         id="stop206" />
+      <stop
+         style="stop-color:#1c1c2a;stop-opacity:1;"
+         offset="1"
+         id="stop207" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient205">
+      <stop
+         style="stop-color:#141e2c;stop-opacity:1;"
+         offset="0"
+         id="stop204" />
+      <stop
+         style="stop-color:#121220;stop-opacity:1;"
+         offset="1"
+         id="stop205" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient203">
+      <stop
+         style="stop-color:#13bead;stop-opacity:1;"
+         offset="0"
+         id="stop202" />
+      <stop
+         style="stop-color:#003d5e;stop-opacity:1;"
+         offset="1"
+         id="stop203" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient201">
+      <stop
+         style="stop-color:#296c43;stop-opacity:1;"
+         offset="0.18888886"
+         id="stop199" />
+      <stop
+         style="stop-color:#133d59;stop-opacity:1;"
+         offset="0.61091447"
+         id="stop200" />
+      <stop
+         style="stop-color:#9b2adf;stop-opacity:1;"
+         offset="1"
+         id="stop201" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient3">
+      <stop
+         style="stop-color:#6ef8d2;stop-opacity:1;"
+         offset="0.18888886"
+         id="stop2" />
+      <stop
+         style="stop-color:#529ac5;stop-opacity:1;"
+         offset="0.61091447"
+         id="stop1" />
+      <stop
+         style="stop-color:#ad47da;stop-opacity:1;"
+         offset="1"
+         id="stop3" />
+    </linearGradient>
+    <rect
+       x="469.23965"
+       y="156.99583"
+       width="427.99774"
+       height="256.79865"
+       id="rect253" />
+    <linearGradient
+       id="linearGradient252">
+      <stop
+         style="stop-color:#4fffe5;stop-opacity:1;"
+         offset="0"
+         id="stop252" />
+      <stop
+         style="stop-color:#009ee3;stop-opacity:1;"
+         offset="1"
+         id="stop253" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient245">
+      <stop
+         style="stop-color:#2bedda;stop-opacity:1;"
+         offset="0"
+         id="stop245" />
+      <stop
+         style="stop-color:#2ab7ff;stop-opacity:1;"
+         offset="1"
+         id="stop246" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient243">
+      <stop
+         style="stop-color:#6700de;stop-opacity:1;"
+         offset="0"
+         id="stop243" />
+      <stop
+         style="stop-color:#3a007e;stop-opacity:1;"
+         offset="1"
+         id="stop244" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient240">
+      <stop
+         style="stop-color:#171f2f;stop-opacity:1;"
+         offset="0"
+         id="stop239" />
+      <stop
+         style="stop-color:#151524;stop-opacity:1;"
+         offset="1"
+         id="stop240" />
+    </linearGradient>
+    <linearGradient
+       id="linearGradient215">
+      <stop
+         style="stop-color:#1d2a3b;stop-opacity:1;"
+         offset="0"
+         id="stop215" />
+      <stop
+         style="stop-color:#161625;stop-opacity:1;"
+         offset="1"
+         id="stop216" />
+    </linearGradient>
+    <linearGradient
+       xlink:href="#linearGradient205"
+       id="linearGradient229"
+       x1="99.80159"
+       y1="131.5479"
+       x2="202.55092"
+       y2="87.0336"
+       gradientUnits="userSpaceOnUse" />
+    <linearGradient
+       xlink:href="#linearGradient215"
+       id="linearGradient233"
+       x1="92.869743"
+       y1="181.052"
+       x2="121.33655"
+       y2="183.86719"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1.1342199,0,0,1,-15.127262,-23.265656)" />
+    <linearGradient
+       xlink:href="#linearGradient207"
+       id="linearGradient237"
+       x1="205.14536"
+       y1="157.47878"
+       x2="248.50272"
+       y2="157.47878"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="translate(3.3018171,-23.265656)" />
+    <linearGradient
+       xlink:href="#linearGradient240"
+       id="linearGradient239"
+       x1="216.49715"
+       y1="115.60864"
+       x2="264.67487"
+       y2="115.60864"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.86737908,0,0,1.6992902,9.5668621,-102.30952)" />
+    <linearGradient
+       xlink:href="#linearGradient243"
+       id="linearGradient244"
+       x1="131.10333"
+       y1="249.97314"
+       x2="217.58331"
+       y2="249.97314"
+       gradientUnits="userSpaceOnUse" />
+    <linearGradient
+       xlink:href="#linearGradient245"
+       id="linearGradient246"
+       x1="67.408493"
+       y1="29.699856"
+       x2="68.862946"
+       y2="141.21988"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.61796247,0,0,1.2554659,16.242695,-39.997664)" />
+    <radialGradient
+       xlink:href="#linearGradient252"
+       id="radialGradient253"
+       cx="171.10719"
+       cy="62.119579"
+       fx="171.10719"
+       fy="62.119579"
+       r="61.437805"
+       gradientTransform="matrix(1.3097725,0.31767857,-0.15662969,0.9822146,-47.993998,-30.138803)"
+       gradientUnits="userSpaceOnUse" />
+    <radialGradient
+       xlink:href="#linearGradient3"
+       id="radialGradient2"
+       cx="187.37721"
+       cy="76.353279"
+       fx="187.37721"
+       fy="76.353279"
+       r="59.889355"
+       gradientTransform="matrix(1.0943327,1.0413486,-1.0278224,0.84312646,53.734372,-179.01419)"
+       gradientUnits="userSpaceOnUse" />
+    <filter
+       style="color-interpolation-filters:sRGB"
+       id="filter3"
+       x="0"
+       y="0"
+       width="1"
+       height="1">
+      <feColorMatrix
+         values="1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 -0 "
+         result="colormatrix"
+         id="feColorMatrix3" />
+      <feComposite
+         in2="colormatrix"
+         operator="arithmetic"
+         k2="0.830816"
+         result="composite"
+         id="feComposite3"
+         k1="0"
+         k3="0"
+         k4="0" />
+    </filter>
+    <meshgradient
+       id="meshgradient34"
+       gradientUnits="userSpaceOnUse"
+       x="110.558"
+       y="74.668777">
+      <meshrow
+         id="meshrow127">
+        <meshpatch
+           id="meshpatch127">
+          <stop
+             path="c 49.4918,5.29683e-08  91.3225,-12.4833  140.812,-12.4833"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop127" />
+          <stop
+             path="c 0,54.6408  1.13459,114.673  1.13459,169.312"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop128" />
+          <stop
+             path="c -49.4918,-0.000864729  -94.6866,-11.9178  -144.745,-15.039"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop129" />
+          <stop
+             path="c -3.12413,-56.6274  3.07869,-85.7321  2.79848,-141.79"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop130" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+    <meshgradient
+       id="meshgradient1064"
+       gradientUnits="userSpaceOnUse"
+       x="110.558"
+       y="74.668777">
+      <meshrow
+         id="meshrow1068">
+        <meshpatch
+           id="meshpatch1068">
+          <stop
+             path="c 49.4918,5.29683e-08  91.3225,-12.4833  140.812,-12.4833"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1065" />
+          <stop
+             path="c 0,54.6408  1.13459,114.673  1.13459,169.312"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1066" />
+          <stop
+             path="c -49.4918,-0.000864729  -88.2028,-11.9178  -138.261,-15.039"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1067" />
+          <stop
+             path="c -3.12375,-56.6274  -3.40501,-85.7321  -3.68559,-141.79"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1068" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+    <meshgradient
+       id="meshgradient1068"
+       gradientUnits="userSpaceOnUse"
+       x="110.558"
+       y="74.668777">
+      <meshrow
+         id="meshrow1072">
+        <meshpatch
+           id="meshpatch1072">
+          <stop
+             path="c 49.4918,5.29683e-08  91.3225,-12.4833  140.812,-12.4833"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1069" />
+          <stop
+             path="c 0,54.6408  1.13459,114.673  1.13459,169.312"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1070" />
+          <stop
+             path="c -49.4918,-0.000864729  -88.2028,-11.9178  -138.261,-15.039"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1071" />
+          <stop
+             path="c -3.12375,-56.6274  -3.40501,-85.7321  -3.68559,-141.79"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1072" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+    <meshgradient
+       id="meshgradient1072"
+       gradientUnits="userSpaceOnUse"
+       x="110.558"
+       y="74.668777">
+      <meshrow
+         id="meshrow1076">
+        <meshpatch
+           id="meshpatch1076">
+          <stop
+             path="c 49.4918,5.29683e-08  91.3225,-12.4833  140.812,-12.4833"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1073" />
+          <stop
+             path="c 0,54.6408  1.13459,114.673  1.13459,169.312"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1074" />
+          <stop
+             path="c -49.4918,-0.000864729  -88.2028,-11.9178  -138.261,-15.039"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1075" />
+          <stop
+             path="c -3.12375,-56.6274  -3.40501,-85.7321  -3.68559,-141.79"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1076" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+    <meshgradient
+       id="meshgradient1076"
+       gradientUnits="userSpaceOnUse"
+       x="110.558"
+       y="74.668777">
+      <meshrow
+         id="meshrow1080">
+        <meshpatch
+           id="meshpatch1080">
+          <stop
+             path="c 49.4918,5.29683e-08  91.3225,-12.4833  140.812,-12.4833"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1077" />
+          <stop
+             path="c 0,54.6408  1.13459,114.673  1.13459,169.312"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1078" />
+          <stop
+             path="c -49.4918,-0.000864729  -88.2028,-11.9178  -138.261,-15.039"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1079" />
+          <stop
+             path="c -3.12375,-56.6274  -3.40501,-85.7321  -3.68559,-141.79"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1080" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+    <meshgradient
+       id="meshgradient1080"
+       gradientUnits="userSpaceOnUse"
+       x="110.558"
+       y="74.668777">
+      <meshrow
+         id="meshrow1084">
+        <meshpatch
+           id="meshpatch1084">
+          <stop
+             path="c 49.4918,5.29683e-08  91.3225,-12.4833  140.812,-12.4833"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1081" />
+          <stop
+             path="c 0,54.6408  1.13459,114.673  1.13459,169.312"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1082" />
+          <stop
+             path="c -49.4918,-0.000864729  -88.2028,-11.9178  -138.261,-15.039"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1083" />
+          <stop
+             path="c -3.12375,-56.6274  -3.40501,-85.7321  -3.68559,-141.79"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1084" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+    <meshgradient
+       id="meshgradient1096"
+       gradientUnits="userSpaceOnUse"
+       x="110.558"
+       y="74.668777">
+      <meshrow
+         id="meshrow1100">
+        <meshpatch
+           id="meshpatch1100">
+          <stop
+             path="c 49.4918,5.29683e-08  91.3225,-12.4833  140.812,-12.4833"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1097" />
+          <stop
+             path="c 0,54.6408  1.13459,114.673  1.13459,169.312"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1098" />
+          <stop
+             path="c -49.4918,-0.000864729  -88.2028,-11.9178  -138.261,-15.039"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1099" />
+          <stop
+             path="c -3.12375,-56.6274  -3.40501,-85.7321  -3.68559,-141.79"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1100" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+    <meshgradient
+       id="meshgradient1100"
+       gradientUnits="userSpaceOnUse"
+       x="110.558"
+       y="74.668777">
+      <meshrow
+         id="meshrow1104">
+        <meshpatch
+           id="meshpatch1104">
+          <stop
+             path="c 49.4918,5.29683e-08  91.3225,-12.4833  140.812,-12.4833"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1101" />
+          <stop
+             path="c 0,54.6408  1.13459,114.673  1.13459,169.312"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1102" />
+          <stop
+             path="c -49.4918,-0.000864729  -88.2028,-11.9178  -138.261,-15.039"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1103" />
+          <stop
+             path="c -3.12375,-56.6274  -3.40501,-85.7321  -3.68559,-141.79"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1104" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+    <meshgradient
+       id="meshgradient1104"
+       gradientUnits="userSpaceOnUse"
+       x="110.558"
+       y="74.668777">
+      <meshrow
+         id="meshrow1108">
+        <meshpatch
+           id="meshpatch1108">
+          <stop
+             path="c 49.4918,5.29683e-08  91.3225,-12.4833  140.812,-12.4833"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1105" />
+          <stop
+             path="c 0,54.6408  1.13459,114.673  1.13459,169.312"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1106" />
+          <stop
+             path="c -49.4918,-0.000864729  -88.2028,-11.9178  -138.261,-15.039"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1107" />
+          <stop
+             path="c -3.12375,-56.6274  -3.40501,-85.7321  -3.68559,-141.79"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1108" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+    <meshgradient
+       id="meshgradient1108"
+       gradientUnits="userSpaceOnUse"
+       x="110.558"
+       y="74.668777">
+      <meshrow
+         id="meshrow1112">
+        <meshpatch
+           id="meshpatch1112">
+          <stop
+             path="c 49.4918,5.29683e-08  91.3225,-12.4833  140.812,-12.4833"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1109" />
+          <stop
+             path="c 0,54.6408  1.13459,114.673  1.13459,169.312"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1110" />
+          <stop
+             path="c -49.4918,-0.000864729  -88.2028,-11.9178  -138.261,-15.039"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop1111" />
+          <stop
+             path="c -3.12375,-56.6274  -3.40501,-85.7321  -3.68559,-141.79"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop1112" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+    <radialGradient
+       xlink:href="#linearGradient201"
+       id="radialGradient158"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(1.0943327,1.0413486,-1.0278224,0.84312646,53.734372,-179.01419)"
+       cx="187.37721"
+       cy="76.353279"
+       fx="187.37721"
+       fy="76.353279"
+       r="59.889355" />
+    <meshgradient
+       id="meshgradient194"
+       gradientUnits="userSpaceOnUse"
+       x="110.558"
+       y="74.668777">
+      <meshrow
+         id="meshrow198">
+        <meshpatch
+           id="meshpatch198">
+          <stop
+             path="c 49.4918,5.29683e-08  91.3225,-12.4833  140.812,-12.4833"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop195" />
+          <stop
+             path="c 0,54.6408  1.13459,114.673  1.13459,169.312"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop196" />
+          <stop
+             path="c -49.4918,-0.000864729  -94.6866,-11.9178  -144.745,-15.039"
+             style="stop-color:#ffffff;stop-opacity:1"
+             id="stop197" />
+          <stop
+             path="c -3.12413,-56.6274  3.07869,-85.7321  2.79848,-141.79"
+             style="stop-color:#000000;stop-opacity:1"
+             id="stop198" />
+        </meshpatch>
+      </meshrow>
+    </meshgradient>
+    <linearGradient
+       xlink:href="#linearGradient203"
+       id="linearGradient202"
+       gradientUnits="userSpaceOnUse"
+       gradientTransform="matrix(0.61796247,0,0,1.2554659,16.242695,-39.997664)"
+       x1="67.408493"
+       y1="29.699856"
+       x2="68.862946"
+       y2="141.21988" />
+  </defs>
+  <g
+     id="g149"
+     transform="matrix(1.1640862,0,0,1.1786589,-51.763614,-39.950388)"
+     style="fill:url(#meshgradient194);fill-opacity:1;stroke-width:1.8854;stroke-dasharray:none">
+    <path
+       id="path131"
+       transform="matrix(1.2719058,0,0,1.4270074,-21.946491,51.827348)"
+       d="m 106.41227,15.347935 c 5.88573,0.05091 14.45523,0.501242 24.74512,0.715711 10.75212,0.224103 21.71002,0.09046 33.3855,-0.902397 11.56688,-0.983619 21.25587,-2.601614 29.09629,-4.255097 7.50414,-1.5825667 12.0939,-2.8954835 12.0939,-2.8954835 2.38337,-0.6395079 4.6644,-0.4231372 6.34705,0.6809039 1.68166,1.1033914 2.62591,3.0114696 2.63347,5.2816606 0.11676,35.059188 0.35021,105.156527 0.35021,105.156527 0.008,2.27829 -0.8997,4.26525 -2.47303,5.49493 -1.56983,1.22696 -3.65403,1.58421 -5.76806,1.04798 -8.07471,-2.0482 -17.54467,-4.64445 -27.45415,-6.65824 -10.5929,-2.15267 -20.5883,-3.45795 -32.2097,-4.43925 -10.9767,-0.92687 -21.52112,-1.45411 -29.00668,-1.96936 -7.50092,-0.51631 -11.93293,-0.9747 -11.93293,-0.9747 -2.31451,-0.2304 -4.46367,-1.1889 -5.99471,-2.64509 -1.528202,-1.4535 -2.309552,-3.2706 -2.248995,-5.03805 0.9352,-27.295135 2.805035,-81.869035 2.805035,-81.869035 0.0602,-1.757937 0.66734,-3.488375 1.68977,-4.751741 1.03008,-1.272815 2.41472,-1.992478 3.94191,-1.979269 z"
+       style="display:inline;fill:url(#radialGradient158);fill-opacity:1" />
+  </g>
+  <g
+     id="g7"
+     transform="matrix(1.1060694,0,0,1.1060694,-41.526161,-29.183396)"
+     style="fill:url(#meshgradient34);fill-opacity:1;stroke-width:1.8854;stroke-dasharray:none">
+    <path
+       id="rect244-6"
+       style="display:inline;fill:url(#radialGradient2)"
+       transform="matrix(1.2719058,0,0,1.4270074,-21.946491,51.827348)"
+       d="m 103.72073,15.347885 c 5.98477,-0.05894 14.96096,0.42147 25.94373,0.682435 11.51485,0.273609 23.27966,0.167618 35.92949,-0.96063 12.5099,-1.115767 22.96911,-2.985754 31.43041,-4.904201 8.09368,-1.8350955 13.0266,-3.3586482 13.0266,-3.3586482 1.23185,-0.3563967 2.41212,-0.2500229 3.28358,0.3172073 0.87112,0.567012 1.36142,1.55023 1.36534,2.7272038 0.12592,37.8098291 0.37768,113.4068081 0.37768,113.4068081 0.004,1.1787 -0.4644,2.20311 -1.28837,2.8401 -0.82297,0.63621 -1.92793,0.82944 -3.06101,0.55093 -8.7386,-2.14792 -19.5453,-5.16545 -29.8955,-7.33259 -11.43622,-2.39454 -22.05044,-3.78746 -34.70545,-4.82724 -11.8829,-0.97635 -23.31917,-1.5259 -31.3494,-2.12486 -8.04581,-0.60011 -12.6987,-1.18299 -12.6987,-1.18299 -1.16984,-0.13877 -2.263662,-0.64729 -3.049003,-1.40643 -0.784523,-0.75834 -1.195889,-1.70248 -1.164526,-2.61785 1.008573,-29.436636 3.025119,-88.292244 3.025119,-88.292244 0.0313,-0.913325 0.34145,-1.806507 0.86287,-2.46653 0.52344,-0.662578 1.22186,-1.043132 1.96714,-1.050471 z" />
+    <g
+       id="g2"
+       style="display:inline;opacity:1;fill:url(#meshgradient1108);fill-opacity:1;stroke-width:3.24661;stroke-dasharray:none;filter:url(#filter3)"
+       transform="matrix(0.54226583,0,0,0.62191996,101.81226,71.639539)">
+      <g
+         id="layer7"
+         style="display:none;fill:url(#meshgradient1064);fill-opacity:1;stroke-width:3.24661;stroke-dasharray:none">
+        <path
+           style="opacity:1;fill:url(#radialGradient253);fill-opacity:1;stroke:#0e2a40;stroke-width:3.24661;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+           id="rect252"
+           width="139.75923"
+           height="126.21101"
+           x="119.69108"
+           y="35.196575"
+           ry="9.0267553"
+           d="m 120.36331,50.488531 c 22.919,0.09504 49.98768,-0.476422 79.20913,-3.036874 C 226.38036,45.102683 248.155,41.4726 248.155,41.4726 c 5.36963,-0.857646 9.72815,2.426665 9.77024,7.53464 0.30139,36.574682 0.90397,109.7021 0.90397,109.7021 0.0421,5.11079 -4.05701,8.89265 -9.06813,8.53726 -20.37405,-1.4449 -49.43903,-4.07704 -74.2521,-6.05433 -24.79299,-1.97568 -45.45503,-3.26366 -45.45503,-3.26366 -5.07373,-0.32266 -9.49277,-3.98864 -9.87382,-8.21873 -2.75244,-30.55483 -8.25566,-91.646173 -8.25566,-91.646173 -0.38171,-4.237397 3.3585,-7.596243 8.43884,-7.575176 z" />
+        <text
+           xml:space="preserve"
+           transform="matrix(0.33507603,0,0,0.37995311,-19.880019,-12.768516)"
+           id="text253"
+           style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:74.6667px;line-height:0.9;font-family:'Liberation Mono';-inkscape-font-specification:'Liberation Mono Bold';text-align:center;white-space:pre;shape-inside:url(#rect253);display:inline;opacity:1;fill:#ffffff;fill-opacity:1;stroke:none;stroke-width:9.099;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+           x="-154.80215"
+           y="0"><tspan
+             x="469.24023"
+             y="209.40346"
+             id="tspan3"><tspan
+               style="text-align:start"
+               id="tspan1">Overlay</tspan></tspan></text>
+      </g>
+      <g
+         id="layer3"
+         style="display:inline;fill:url(#meshgradient1068);fill-opacity:1;stroke-width:3.24661;stroke-dasharray:none">
+        <path
+           id="rect3"
+           style="fill:url(#linearGradient244)"
+           transform="matrix(1.1028866,0,0,1.1661471,-18.842135,-68.983005)"
+           d="m 141.5197,232.74856 c 14.50571,1.24952 29.33813,2.83394 45.80344,5.11698 14.71882,2.04087 26.37713,4.00976 26.37713,4.00976 2.86398,0.46696 5.26545,3.19012 5.36908,6.10293 0.0517,1.45262 0.15501,4.35698 0.15501,4.35698 0.0496,1.39306 -0.44478,2.62569 -1.36817,3.42126 -0.92361,0.79576 -2.20065,1.08963 -3.55361,0.82714 -12.99897,-2.52197 -27.24986,-5.06329 -43.77534,-7.27441 -14.99629,-2.00652 -27.73287,-3.15138 -27.73287,-3.15138 -1.48432,-0.14097 -2.96452,-0.77187 -4.10659,-1.75252 -1.14295,-0.98142 -1.85405,-2.23289 -1.97368,-3.48564 -0.12476,-1.30648 -0.37422,-3.91866 -0.37422,-3.91866 -0.24905,-2.60802 2.0839,-4.51913 5.17982,-4.25244 z" />
+      </g>
+      <g
+         id="layer4"
+         style="display:inline;fill:url(#meshgradient1072);fill-opacity:1;stroke-width:3.24661;stroke-dasharray:none">
+        <path
+           style="fill:url(#linearGradient237);fill-opacity:1"
+           id="rect210"
+           width="43.357353"
+           height="99.615921"
+           x="208.44717"
+           y="84.405167"
+           d="m 209.66955,92.272568 c 6.7322,-0.16598 14.38233,-0.41674 22.69259,-0.80776 7.59945,-0.357574 13.7461,-0.74835 13.7461,-0.74835 2.2821,-0.141431 4.15788,1.500306 4.18508,3.694161 0.37814,30.498741 1.13418,91.477921 1.13418,91.477921 0.0272,2.19437 -1.71574,3.74227 -3.86875,3.47186 -11.70171,-1.46967 -34.04157,-4.39345 -34.04157,-4.39345 -2.07685,-0.26609 -3.83887,-2.12889 -3.92956,-4.15029 -1.26828,-28.26615 -3.80407,-84.781487 -3.80407,-84.781487 -0.0907,-2.021933 1.64509,-3.707356 3.886,-3.762605 z"
+           transform="translate(-0.71814209,4.1703544)" />
+        <path
+           style="fill:url(#linearGradient233);fill-opacity:1"
+           id="rect211"
+           width="51.68074"
+           height="91.151398"
+           x="82.748856"
+           y="123.05398"
+           d="m 80.47685,123.1104 c 0.686911,0.0328 32.06099,1.49986 32.7479,1.53266 10.95124,0.50481 19.67641,0.89883 19.67641,0.89883 2.32431,25.95786 6.97152,77.858 6.97152,77.858 -9.90209,-0.93081 -20.61604,-1.79499 -33.20992,-2.65118 C 95.354127,199.9799 86.14795,199.45109 86.14795,199.45109 169.55658,1322.2439 -2.9317791,-999.68243 80.476849,123.1104 Z" />
+      </g>
+      <g
+         id="layer1"
+         style="display:inline;fill:url(#meshgradient1080);fill-opacity:1;stroke-width:3.24661;stroke-dasharray:none">
+        <path
+           id="rect2"
+           style="fill:#f7f2f1"
+           transform="matrix(0.88631797,0,0,1.14015,18.230141,-61.294282)"
+           d="m 177.90192,216.30228 c 4.14717,0.40612 8.19723,2.30928 11.27702,5.3317 3.07755,3.02023 4.91903,6.89742 5.1651,10.74356 0.28509,3.88205 -1.05797,7.41 -3.71104,9.77442 -2.6581,2.3689 -6.41781,3.38872 -10.51095,2.89322 -4.04996,-0.52413 -8.11166,-2.50573 -11.25007,-5.47805 -3.14352,-2.97716 -5.11709,-6.71723 -5.4435,-10.44075 -0.36747,-3.76009 0.95436,-7.21327 3.6799,-9.62456 2.72107,-2.40733 6.61999,-3.57393 10.79354,-3.19954 z" />
+        <g
+           id="g1"
+           style="display:inline;fill:url(#meshgradient1076);fill-opacity:1;stroke-width:3.66303;stroke-dasharray:none"
+           transform="matrix(0.92452299,0,0,0.88631797,9.9395114,1.6271212)">
+          <path
+             id="circle1"
+             style="fill:#f7f2f1;fill-opacity:1"
+             d="m 139.93601,95.963847 c -20.29293,-0.327742 -35.37169,12.686533 -33.94622,29.478073 2.20095,10.94672 6.63093,32.87821 6.63093,32.87821 -9.05268,15.33583 -10.18571,22.03628 -10.29884,33.07659 2.96627,19.00354 13.81154,24.51969 38.94596,29.90868 36.15907,5.19528 42.04946,4.56032 68.66554,4.20072 12.27862,-2.60897 18.25127,-5.37981 21.68277,-9.55692 3.43986,-4.18728 4.29703,-9.72457 6.56239,-18.09473 0.66388,-8.15956 2.03668,-24.58454 2.03668,-24.58454 7.50482,-1.34376 12.8393,-7.80874 12.7282,-15.64436 -0.13129,-7.84626 -5.69971,-14.5686 -13.48151,-16.4621 -0.098,-4.17663 -0.29393,-12.52739 -0.29393,-12.52739 -0.46041,-19.61437 -17.3574,-33.566518 -37.94796,-32.963422 -20.46321,0.599259 -40.93211,0.619777 -61.28401,0.291189 z" />
+        </g>
+      </g>
+      <g
+         id="layer2"
+         style="display:inline;fill:url(#meshgradient1100);fill-opacity:1"
+         transform="translate(21.838235,-8.7352941)">
+        <g
+           id="g214"
+           style="display:inline;fill:url(#meshgradient1096);fill-opacity:1"
+           transform="matrix(1.0198935,0,0,1,-23.322991,-14.530363)">
+          <path
+             id="path209"
+             style="fill:url(#linearGradient229);fill-opacity:1"
+             d="m 123.92491,83.962019 c -10.23363,3.055336 -30.4478,8.769077 -30.4478,8.769077 -1.266574,0.354181 -2.340048,1.022231 -3.091203,1.92289 -3.66068,4.389277 -10.991047,13.100584 -10.991047,13.100584 -0.758487,0.89849 -1.228249,1.96258 -1.36958,3.1033 -1.113915,8.99066 -3.416566,26.93286 -3.416566,26.93286 -0.124786,0.95989 0.722438,1.91928 1.904,2.15268 1.454515,0.2873 4.36818,0.86207 4.36818,0.86207 1.305308,0.25742 2.410726,1.09852 2.841498,2.16349 2.078656,5.13893 6.273055,15.43228 6.273055,15.43228 0.465412,1.13999 1.309593,2.18759 2.431102,3.01695 7.964041,5.8894 23.925201,17.82116 23.925201,17.82116 0.49221,0.37121 1.16511,0.48621 1.69621,0.28956 0.53113,-0.19667 0.81283,-0.66523 0.71061,-1.18144 -1.86375,-9.41224 -5.57902,-28.15964 -5.57902,-28.15964 -0.23671,-1.19457 -0.32758,-2.38954 -0.27137,-3.5669 0.24655,-5.16358 0.73595,-15.50177 0.73595,-15.50177 0.0557,-1.18033 0.23718,-2.34151 0.54212,-3.47069 0.34418,-1.27445 1.03202,-3.82514 1.03202,-3.82514 0.033,-0.12252 0.17246,-0.19517 0.32739,-0.17055 0.15493,0.0246 0.27838,0.13905 0.28986,0.2687 0.68381,7.72149 2.05103,23.15982 2.05103,23.15982 0.0905,1.02212 1.08936,1.92605 2.31385,2.09508 4.27477,0.59008 12.79471,1.77943 12.79471,1.77943 1.41308,0.1981 2.79841,0.64835 4.06229,1.32189 1.23086,0.65595 3.68783,1.97172 3.68783,1.97172 1.24659,0.66873 2.65004,1.02753 4.02626,1.02688 9.42581,-0.004 28.10015,-0.0477 28.10015,-0.0477 1.19102,-0.004 2.0812,-0.80851 2.07272,-1.87422 -0.1172,-14.72073 -0.2846,-44.28083 -0.2846,-44.28083 -0.0172,-0.34101 0.1913,-0.64824 0.5365,-0.79062 0.34517,-0.14237 0.76579,-0.0946 1.08168,0.12342 2.88494,14.55408 8.50435,43.91811 8.50435,43.91811 0.28446,1.50523 1.85925,2.65367 3.49696,2.54532 5.65269,-0.37401 16.95539,-1.1968 16.95539,-1.1968 1.75939,-0.13279 3.10121,-1.36401 3.27324,-3.00869 0.38599,-3.69047 1.17078,-11.0956 1.17078,-11.0956 0.0962,-0.90427 1.18054,-1.35932 2.03877,-0.85048 8.26249,4.89881 24.64155,15.05184 24.64155,15.05184 0.37183,0.23372 0.83479,0.26413 1.21337,0.0786 0.37855,-0.18553 0.61464,-0.55861 0.61807,-0.97696 0.0955,-11.66072 0.31069,-35.03859 0.31069,-35.03859 0.0109,-1.14289 0.97667,-2.09035 2.19074,-2.14539 3.12174,-0.14153 9.39326,-0.468 9.39326,-0.468 0.37027,-0.0201 0.69934,-0.25043 0.83496,-0.58446 0.13561,-0.33403 0.0512,-0.70638 -0.21436,-0.9442 -7.81079,-6.99479 -16.43955,-14.515563 -26.1194,-22.595271 -8.77789,-7.326845 -15.91626,-13.010686 -15.91626,-13.010686 -1.01856,-0.815898 -2.41915,-1.15111 -3.79248,-0.916782 -10.94116,1.866865 -22.85862,3.659431 -36.06911,5.337963 -11.95682,1.519241 -21.45555,2.496218 -21.45555,2.496218 -1.39301,0.148085 -2.834,-0.06908 -4.13536,-0.619375 -6.3046,-2.370273 -13.32808,-2.495056 -19.29264,-0.421108 z"
+             transform="matrix(0.88631797,0,0,0.88631797,18.192351,24.242627)" />
+        </g>
+        <path
+           id="path213"
+           style="fill:url(#linearGradient239);fill-opacity:1"
+           d="m 207.52109,60.934045 c -8.23842,3.588919 -24.48552,10.018705 -24.48552,10.018705 -1.51861,0.582881 -2.68634,1.721139 -3.18088,3.103388 -0.49485,1.383116 -0.2657,2.868097 0.61858,4.054476 2.75693,3.698772 8.20887,11.192989 8.20887,11.192989 1.4022,2.680164 4.71448,4.097029 7.92934,3.326928 1.72645,12.227559 5.07462,36.906589 5.07462,36.906589 0.21342,1.59436 1.08581,3.07164 2.42179,4.10728 1.33617,1.03578 3.03056,1.54758 4.71517,1.40807 7.54666,-0.625 22.90972,-2.17677 22.90972,-2.17677 1.729,-0.18647 3.31955,-1.04033 4.42227,-2.38314 1.10188,-1.3418 1.62109,-3.05726 1.43659,-4.75363 -2.02293,-18.60064 -6.18002,-55.217054 -6.18002,-55.217054 -0.19199,-1.664457 -1.08333,-3.096741 -2.48051,-3.984458 -1.39688,-0.887527 -3.18296,-1.157397 -4.96247,-0.76854 -3.32097,0.231699 -6.25797,-1.378914 -7.5354,-4.069393 -2.152,-2.217526 -5.88818,-2.503869 -8.91215,-0.76544 z"
+           transform="translate(-0.2555589,0.54640561)" />
+        <path
+           style="fill:#171924;fill-opacity:1"
+           id="path214"
+           transform="matrix(1.0516212,0,0,0.80145135,-20.213033,20.898021)"
+           d="m 209.95493,101.15277 c -0.67313,0.43587 -2.01669,1.30008 -2.01669,1.30008 -0.85322,0.5476 -1.90748,0.72789 -2.89215,0.49915 -0.98401,-0.2286 -1.80183,-0.8432 -2.23994,-1.67953 -5.44838,-10.400807 -16.60644,-30.574511 -16.60644,-30.574511 -1.03491,-1.840162 -0.3485,-4.128735 1.62421,-5.411585 0.67928,-0.441735 2.03939,-1.332269 2.03939,-1.332269 1.81519,-1.191236 4.29764,-0.767452 5.24275,0.925976 5.59588,10.02662 16.52383,30.690614 16.52383,30.690614 0.99835,1.923525 0.27865,4.317068 -1.67496,5.582075 z" />
+        <path
+           style="opacity:1;fill:none;fill-opacity:1"
+           d="m 122.67967,139.36755 c -0.82357,-9.77509 -2.46964,-29.32102 -2.46964,-29.32102"
+           id="path257" />
+      </g>
+      <g
+         id="layer6"
+         transform="matrix(1.2837662,0,0,1.2438198,-26.230112,-69.412133)"
+         style="display:none;fill:url(#meshgradient1104);fill-opacity:1;stroke-width:2.56926;stroke-dasharray:none">
+        <path
+           id="rect248"
+           style="display:inline;fill:#e8dad4;fill-opacity:1;stroke-width:2.65734"
+           d="m 77.184461,185.85877 c -3.118706,-0.17264 -5.488205,2.29474 -5.304089,5.53146 0.13927,2.44833 0.417725,7.34351 0.417725,7.34351 -1.402851,0.59241 -2.653274,1.38571 -3.674486,2.33019 -0.236417,0.22009 -0.709644,0.65998 -0.709644,0.65998 -1.977545,1.8376 -2.974523,4.13549 -2.748122,6.38664 0.226626,2.25339 1.661126,4.27793 4.013076,5.63294 8.752329,5.04251 26.562156,15.20978 26.562156,15.20978 2.382687,1.37696 5.445823,1.97949 8.478093,1.67643 3.03406,-0.30324 5.79105,-1.48794 7.67929,-3.30723 0.22606,-0.21761 0.67741,-0.65271 0.67741,-0.65271 1.88467,-1.81934 2.75357,-4.12747 2.43717,-6.41566 -0.31636,-2.28783 -1.79377,-4.36696 -4.11671,-5.76332 -8.70483,-5.23272 -26.118916,-15.30199 -26.118916,-15.30199 -0.343354,-0.18115 -0.701144,-0.34676 -1.071679,-0.49602 -0.1545,-2.22112 -0.463409,-6.66204 -0.463409,-6.66204 -0.225903,-3.24762 -2.937381,-5.99923 -6.057865,-6.17196 z" />
+        <path
+           style="display:inline;fill:#000000;fill-opacity:1;stroke-width:2.56926;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none"
+           id="rect249"
+           width="17.034109"
+           height="46.878986"
+           x="-35.362507"
+           y="197.14072"
+           ry="7.0004072"
+           transform="rotate(-25.912557)"
+           d="m -25.607053,190.65997 c 0.954332,0.11489 2.864353,0.34332 2.864353,0.34332 3.654339,0.43613 6.929644,3.61962 7.341128,7.17129 1.161399,10.02447 3.841123,30.33504 3.841123,30.33504 0.484383,3.61069 -2.136673,6.11741 -5.920033,5.60148 -0.98671,-0.13456 -2.964879,-0.40587 -2.964879,-0.40587 -3.801916,-0.5225 -7.270603,-3.85538 -7.733816,-7.43704 -0.727933,-5.62853 -1.524569,-12.07229 -2.279132,-18.88247 -0.69303,-6.25482 -1.162571,-11.20924 -1.162571,-11.20924 -0.337087,-3.50469 2.36905,-5.95528 6.013827,-5.51651 z" />
+        <path
+           style="display:inline;opacity:1;fill:#000000;fill-opacity:1;stroke:#000000;stroke-width:2.57015;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none;stroke-opacity:1"
+           id="path249"
+           transform="matrix(0.95785111,0.28726513,-0.15416741,0.98804474,0,0)"
+           d="m 98.986205,156.01933 c 0.04397,2.3882 -1.279417,4.68165 -3.685404,6.38016 -2.403397,1.69667 -5.680418,2.65151 -9.059264,2.63957 -3.384867,-0.012 -6.567546,-0.99058 -8.877987,-2.71373 -2.307258,-1.72078 -3.55527,-4.04087 -3.529229,-6.42695 0.02604,-2.38578 1.32169,-4.65607 3.610982,-6.31122 2.29219,-1.65725 5.412248,-2.5773 8.720324,-2.56317 3.304267,0.0141 6.534395,0.96178 8.95209,2.64405 2.41885,1.68308 3.824526,3.96359 3.868488,6.35129 z" />
+        <path
+           style="fill:#000000;fill-opacity:1;stroke-width:2.57357;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none"
+           id="rect250"
+           width="7.8031187"
+           height="16.862799"
+           x="-110.84097"
+           y="164.54688"
+           ry="3.9034963"
+           transform="matrix(0.73335892,-0.67984167,0.73746343,0.67538706,0,0)"
+           d="m -101.87538,159.04263 c 1.84328,0.21768 3.408551,2.02367 3.513601,4.07777 0.146486,2.86432 0.519191,8.6697 0.519191,8.6697 0.142102,2.08946 -1.251587,3.59084 -3.146462,3.34707 -1.89521,-0.24382 -3.52814,-2.13228 -3.65221,-4.20913 -0.17333,-2.90133 -0.43388,-8.62107 -0.43388,-8.62107 -0.0819,-2.0358 1.35712,-3.48195 3.19976,-3.26434 z" />
+        <path
+           style="fill:#000000;fill-opacity:1;stroke-width:2.57425;stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:none"
+           id="rect250-8"
+           width="6.729383"
+           height="14.503226"
+           x="-53.165482"
+           y="183.37346"
+           ry="3.3572891"
+           transform="matrix(0.85907063,-0.51185706,0.58537704,0.8107612,0,0)"
+           d="m -48.057815,179.27958 c 0.0045,5.2e-4 0.01343,0.002 0.01343,0.002 1.684503,0.1953 3.181426,1.74377 3.35774,3.48214 0.245974,2.42518 0.771465,7.30015 0.771465,7.30015 0.191885,1.75025 -1.023546,2.9947 -2.736088,2.78403 -0.0045,-5.6e-4 -0.01362,-0.002 -0.01362,-0.002 -1.712814,-0.21071 -3.24197,-1.791 -3.423893,-3.53301 -0.254136,-2.43348 -0.724711,-7.27128 -0.724711,-7.27128 -0.163482,-1.72813 1.071529,-2.95718 2.755678,-2.76192 z" />
+        <path
+           style="display:inline;opacity:1;fill:#ffeadd;fill-opacity:1"
+           id="rect251"
+           width="24.398001"
+           height="29.236685"
+           x="-0.062498044"
+           y="210.98186"
+           ry="8.1815834"
+           transform="rotate(-13.890784)"
+           d="m 10.397126,201.89974 c 2.668721,0.27854 8.029635,0.82565 8.029635,0.82565 4.527911,0.45965 8.540026,4.00409 8.974897,7.97222 0.411258,3.75267 1.268639,11.27213 1.268639,11.27213 0.458902,3.97834 -2.893831,6.77697 -7.584891,6.26362 -2.765816,-0.30267 -8.307752,-0.91835 -8.307752,-0.91835 -4.7137162,-0.52769 -8.7550485,-4.14078 -9.0912544,-8.07049 -0.3185485,-3.72333 -0.896104,-11.14698 -0.896104,-11.14698 -0.2937067,-3.91148 3.1144248,-6.66667 7.6068304,-6.1978 z" />
+      </g>
+    </g>
+  </g>
+  <g
+     id="layer5"
+     transform="matrix(1.2055888,0,0,1.4323266,-81.666225,20.057586)"
+     style="display:inline">
+    <path
+       style="display:inline;fill:url(#linearGradient202)"
+       id="path201"
+       width="71.254013"
+       height="163.40518"
+       x="21.551163"
+       y="-25.557249"
+       d="m 24.990746,-25.557249 h 64.374846 a 3.4395833,3.4395833 45 0 1 3.439584,3.439583 V 134.40835 a 3.4395833,3.4395833 135 0 1 -3.439584,3.43958 H 24.990746 a 3.4395833,3.4395833 45 0 1 -3.439583,-3.43958 l 0,-156.526016 a 3.4395833,3.4395833 135 0 1 3.439583,-3.439583 z"
+       transform="matrix(1.117986,0,0,1.0637076,65.897574,19.454539)" />
+    <path
+       style="fill:url(#linearGradient246)"
+       id="rect244"
+       width="71.254013"
+       height="163.40518"
+       x="21.551163"
+       y="-25.557249"
+       d="m 23.138663,-25.557249 h 68.079013 a 1.5875,1.5875 45 0 1 1.5875,1.5875 V 136.26043 a 1.5875,1.5875 135 0 1 -1.5875,1.5875 H 23.138663 a 1.5875,1.5875 45 0 1 -1.5875,-1.5875 V -23.969749 a 1.5875,1.5875 135 0 1 1.5875,-1.5875 z"
+       transform="matrix(0.99914067,0,0,1.0180357,72.889826,22.067296)" />
+    <g
+       id="text246"
+       style="font-size:160px;line-height:0.9;font-family:Cantarell;-inkscape-font-specification:Cantarell;white-space:pre;fill:#171924;stroke-width:3.77953;stroke-linecap:round;stroke-linejoin:round"
+       transform="matrix(0.46400539,0,0,0.36491553,52.372565,-26.641262)"
+       aria-label="W&#10;L&#10;X">
+      <path
+         style="font-weight:bold;font-family:'Liberation Mono';-inkscape-font-specification:'Liberation Mono Bold';text-align:center;text-anchor:middle"
+         d="m 199.41504,194.08435 h -19.375 l -5,-20.85937 q -3.90625,-14.76563 -7.03125,-28.82813 l -2.73438,11.48438 -3.4375,13.82812 -6.09375,24.375 h -19.375 L 119.88379,88.693725 h 20.23437 l 6.95313,54.296875 q 0.9375,7.5 1.25,20.78125 l 1.17187,-5.9375 3.125,-13.125 7.73438,-26.48437 h 15.23437 l 7.73438,26.48437 q 1.01562,3.51563 1.71875,6.95313 0.78125,3.35937 2.57812,12.10937 l 0.15625,-2.10937 q 0.46875,-12.57813 1.25,-18.67188 l 6.5625,-54.296875 h 20.23438 z"
+         id="path210" />
+      <path
+         style="font-weight:bold;font-family:'Liberation Mono';-inkscape-font-specification:'Liberation Mono Bold';text-align:center;text-anchor:middle"
+         d="M 136.36816,341.4649 V 236.07428 h 23.04688 v 87.57812 h 48.125 v 17.8125 z"
+         id="path211" />
+      <path
+         style="font-weight:bold;-inkscape-font-specification:'Cantarell Bold';fill:#f6f6f8"
+         d="m 193.8916,488.84546 h 24.8 l -44.64,-63.84 -29.76,-47.2 h -24.48 l 42.4,62.4 z m -76.96,0 h 23.68 l 27.04,-43.2 -10.4,-16.32 z m 59.2,-55.84 38.24,-55.2 h -24 l -24.96,39.04 z"
+         id="path212" />
+    </g>
+  </g>
+  <script
+     id="mesh_polyfill"
+     type="text/javascript">
+!function(){const t=&quot;http://www.w3.org/2000/svg&quot;,e=&quot;http://www.w3.org/1999/xlink&quot;,s=&quot;http://www.w3.org/1999/xhtml&quot;,r=2;if(document.createElementNS(t,&quot;meshgradient&quot;).x)return;const n=(t,e,s,r)=&gt;{let n=new x(.5*(e.x+s.x),.5*(e.y+s.y)),o=new x(.5*(t.x+e.x),.5*(t.y+e.y)),i=new x(.5*(s.x+r.x),.5*(s.y+r.y)),a=new x(.5*(n.x+o.x),.5*(n.y+o.y)),h=new x(.5*(n.x+i.x),.5*(n.y+i.y)),l=new x(.5*(a.x+h.x),.5*(a.y+h.y));return[[t,o,a,l],[l,h,i,r]]},o=t=&gt;{let e=t[0].distSquared(t[1]),s=t[2].distSquared(t[3]),r=.25*t[0].distSquared(t[2]),n=.25*t[1].distSquared(t[3]),o=e&gt;s?e:s,i=r&gt;n?r:n;return 18*(o&gt;i?o:i)},i=(t,e)=&gt;Math.sqrt(t.distSquared(e)),a=(t,e)=&gt;t.scale(2/3).add(e.scale(1/3)),h=t=&gt;{let e,s,r,n,o,i,a,h=new g;return t.match(/(\w+\(\s*[^)]+\))+/g).forEach(t=&gt;{let l=t.match(/[\w.-]+/g),d=l.shift();switch(d){case&quot;translate&quot;:2===l.length?e=new g(1,0,0,1,l[0],l[1]):(console.error(&quot;mesh.js: translate does not have 2 arguments!&quot;),e=new g(1,0,0,1,0,0)),h=h.append(e);break;case&quot;scale&quot;:1===l.length?s=new g(l[0],0,0,l[0],0,0):2===l.length?s=new g(l[0],0,0,l[1],0,0):(console.error(&quot;mesh.js: scale does not have 1 or 2 arguments!&quot;),s=new g(1,0,0,1,0,0)),h=h.append(s);break;case&quot;rotate&quot;:if(3===l.length&amp;&amp;(e=new g(1,0,0,1,l[1],l[2]),h=h.append(e)),l[0]){r=l[0]*Math.PI/180;let t=Math.cos(r),e=Math.sin(r);Math.abs(t)&lt;1e-16&amp;&amp;(t=0),Math.abs(e)&lt;1e-16&amp;&amp;(e=0),a=new g(t,e,-e,t,0,0),h=h.append(a)}else console.error(&quot;math.js: No argument to rotate transform!&quot;);3===l.length&amp;&amp;(e=new g(1,0,0,1,-l[1],-l[2]),h=h.append(e));break;case&quot;skewX&quot;:l[0]?(r=l[0]*Math.PI/180,n=Math.tan(r),o=new g(1,0,n,1,0,0),h=h.append(o)):console.error(&quot;math.js: No argument to skewX transform!&quot;);break;case&quot;skewY&quot;:l[0]?(r=l[0]*Math.PI/180,n=Math.tan(r),i=new g(1,n,0,1,0,0),h=h.append(i)):console.error(&quot;math.js: No argument to skewY transform!&quot;);break;case&quot;matrix&quot;:6===l.length?h=h.append(new g(...l)):console.error(&quot;math.js: Incorrect number of arguments for matrix!&quot;);break;default:console.error(&quot;mesh.js: Unhandled transform type: &quot;+d)}}),h},l=t=&gt;{let e=[],s=t.split(/[ ,]+/);for(let t=0,r=s.length-1;t&lt;r;t+=2)e.push(new x(parseFloat(s[t]),parseFloat(s[t+1])));return e},d=(t,e)=&gt;{for(let s in e)t.setAttribute(s,e[s])},c=(t,e,s,r,n)=&gt;{let o,i,a=[0,0,0,0];for(let h=0;h&lt;3;++h)e[h]&lt;t[h]&amp;&amp;e[h]&lt;s[h]||t[h]&lt;e[h]&amp;&amp;s[h]&lt;e[h]?a[h]=0:(a[h]=.5*((e[h]-t[h])/r+(s[h]-e[h])/n),o=Math.abs(3*(e[h]-t[h])/r),i=Math.abs(3*(s[h]-e[h])/n),a[h]&gt;o?a[h]=o:a[h]&gt;i&amp;&amp;(a[h]=i));return a},u=[[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0],[-3,3,0,0,-2,-1,0,0,0,0,0,0,0,0,0,0],[2,-2,0,0,1,1,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0],[0,0,0,0,0,0,0,0,-3,3,0,0,-2,-1,0,0],[0,0,0,0,0,0,0,0,2,-2,0,0,1,1,0,0],[-3,0,3,0,0,0,0,0,-2,0,-1,0,0,0,0,0],[0,0,0,0,-3,0,3,0,0,0,0,0,-2,0,-1,0],[9,-9,-9,9,6,3,-6,-3,6,-6,3,-3,4,2,2,1],[-6,6,6,-6,-3,-3,3,3,-4,4,-2,2,-2,-2,-1,-1],[2,0,-2,0,0,0,0,0,1,0,1,0,0,0,0,0],[0,0,0,0,2,0,-2,0,0,0,0,0,1,0,1,0],[-6,6,6,-6,-4,-2,4,2,-3,3,-3,3,-2,-1,-2,-1],[4,-4,-4,4,2,2,-2,-2,2,-2,2,-2,1,1,1,1]],f=t=&gt;{let e=[];for(let s=0;s&lt;16;++s){e[s]=0;for(let r=0;r&lt;16;++r)e[s]+=u[s][r]*t[r]}return e},p=(t,e,s)=&gt;{const r=e*e,n=s*s,o=e*e*e,i=s*s*s;return t[0]+t[1]*e+t[2]*r+t[3]*o+t[4]*s+t[5]*s*e+t[6]*s*r+t[7]*s*o+t[8]*n+t[9]*n*e+t[10]*n*r+t[11]*n*o+t[12]*i+t[13]*i*e+t[14]*i*r+t[15]*i*o},y=t=&gt;{let e=[],s=[],r=[];for(let s=0;s&lt;4;++s)e[s]=[],e[s][0]=n(t[0][s],t[1][s],t[2][s],t[3][s]),e[s][1]=[],e[s][1].push(...n(...e[s][0][0])),e[s][1].push(...n(...e[s][0][1])),e[s][2]=[],e[s][2].push(...n(...e[s][1][0])),e[s][2].push(...n(...e[s][1][1])),e[s][2].push(...n(...e[s][1][2])),e[s][2].push(...n(...e[s][1][3]));for(let t=0;t&lt;8;++t){s[t]=[];for(let r=0;r&lt;4;++r)s[t][r]=[],s[t][r][0]=n(e[0][2][t][r],e[1][2][t][r],e[2][2][t][r],e[3][2][t][r]),s[t][r][1]=[],s[t][r][1].push(...n(...s[t][r][0][0])),s[t][r][1].push(...n(...s[t][r][0][1])),s[t][r][2]=[],s[t][r][2].push(...n(...s[t][r][1][0])),s[t][r][2].push(...n(...s[t][r][1][1])),s[t][r][2].push(...n(...s[t][r][1][2])),s[t][r][2].push(...n(...s[t][r][1][3]))}for(let t=0;t&lt;8;++t){r[t]=[];for(let e=0;e&lt;8;++e)r[t][e]=[],r[t][e][0]=s[t][0][2][e],r[t][e][1]=s[t][1][2][e],r[t][e][2]=s[t][2][2][e],r[t][e][3]=s[t][3][2][e]}return r};class x{constructor(t,e){this.x=t||0,this.y=e||0}toString(){return`(x=${this.x}, y=${this.y})`}clone(){return new x(this.x,this.y)}add(t){return new x(this.x+t.x,this.y+t.y)}scale(t){return void 0===t.x?new x(this.x*t,this.y*t):new x(this.x*t.x,this.y*t.y)}distSquared(t){let e=this.x-t.x,s=this.y-t.y;return e*e+s*s}transform(t){let e=this.x*t.a+this.y*t.c+t.e,s=this.x*t.b+this.y*t.d+t.f;return new x(e,s)}}class g{constructor(t,e,s,r,n,o){void 0===t?(this.a=1,this.b=0,this.c=0,thiLine truncated
+</script>
+</svg>
Author	SHA1	Message	Date
galister	3f425820d7	release 0.5.0	2024-09-19 05:29:27 +09:00
galister	6a2d8b9f90	fresh watch style	2024-09-19 03:09:09 +09:00
galister	583a5f7fe0	openxr: toggle for space rotate axis lock	2024-09-18 04:06:37 +09:00
galister	03f2eaf97f	fps-stabilize openxr smoothing	2024-09-16 07:05:26 +09:00
galister	21331b5c42	fps-aware openxr pointer smoothing	2024-09-16 05:09:10 +09:00
galister	72a82530ae	fix openxr space rotate	2024-09-16 05:01:15 +09:00
galister	13d9284bb8	move mouse move-scroll exclusivity to hid module	2024-09-11 06:03:22 +09:00
galister	b0a33a1181	openxr: laser pointer smoothing	2024-09-09 07:54:19 +09:00
galister	4f38d1ad44	make pipewire default on wlroots	2024-08-24 02:21:43 +09:00
galister	c6bc880bc3	add logging for screen pipeline	2024-08-20 16:49:35 +09:00
galister	0a2be76150	change some version stuff	2024-08-20 16:40:08 +09:00
galister	1a87823847	rename github action	2024-08-20 14:04:44 +09:00
galister	e763e15bdc	build dev appimages	2024-08-20 14:02:12 +09:00
galister	6a3b60f298	feat: screen_render_down	2024-08-20 13:54:18 +09:00
Adalyn Black	397b3eedd1	Use git hash if no tags can be found	2024-08-19 17:35:58 +02:00
hypevhs	9d18628354	feat: XR binding for playspace reset	2024-08-15 21:30:39 +02:00
galister	dc985f6da6	docs: update known issues	2024-08-13 07:43:37 +00:00
raku-cat	850601b3b9	Update wlx-capture	2024-08-12 12:16:10 +00:00
galister	8a4c7a400f	dirty versions	2024-08-11 06:41:17 +09:00
galister	d9287f3250	Release 0.4.4	2024-08-11 06:23:38 +09:00
hypevhs	378ea120c8	Fix mirrors spawning behind head	2024-08-10 20:34:55 +00:00
galister	f4cc49ca69	fix keyboard macro regex	2024-08-09 23:25:59 +00:00
galister	57ff3aa1dd	clippy	2024-08-09 10:19:57 +00:00
galister	0808383e70	corner_radius is optional	2024-08-09 10:19:57 +00:00
galister	c71911998e	upright screen fix	2024-08-09 08:38:37 +09:00
galister	50c3f49989	hmd pose from view space	2024-08-09 08:38:37 +09:00
Aleksander	b6a07c43a5	Fix scrolling for all Electron-based applications	2024-08-07 18:12:20 +00:00
galister	ee3fbff44c	release 0.4.3	2024-08-04 06:57:11 +09:00
galister	c29bbbb142	review unwraps	2024-08-03 20:50:34 +09:00
Aleksander	aca177635e	Input source: Update monado devices only if they are available Fixes .unwrap() panic in the simulated Monado driver	2024-08-02 20:20:34 +00:00
galister	c3c8694e1a	update deps	2024-08-02 16:49:55 +00:00
Torge Matthies	1de9cea397	feat: openxr battery status	2024-08-02 16:33:09 +00:00
galister	939a537d20	fix: ipd label not visible on uidev	2024-08-01 18:36:03 +09:00
Adalyn Black	26124be6ef	Improved the clarity of some sentences in the README	2024-07-31 09:45:03 +00:00
galister	3d0611052f	switch to using libmonado-rs	2024-07-31 05:28:34 +09:00
galister	dcc2cd0575	openxr: configurable screen downscale	2024-07-29 22:14:25 +09:00
galister	57ff3ec3bc	settings: auto-close on fix floor & reset offset	2024-07-25 09:10:03 +09:00
Adalyn Black	e14b35bece	Cattpuccin Macchiato Re-theme	2024-07-24 23:59:39 +00:00
Adalyn Black	88da3c832a	Removed unused render_rect function	2024-07-24 23:59:39 +00:00
Adalyn Black	7b4576bd52	Removed unused imports	2024-07-24 23:59:39 +00:00
Adalyn Black	a98b7a210f	Switched to shader for corner rounding	2024-07-24 23:59:39 +00:00
Adalyn Black	32e0e7656a	Moved corner radius property to be separate from the rect struct	2024-07-24 23:59:39 +00:00
Adalyn Black	f27c320231	feat: rounded corners A proof of concept commit for rounded corners. Currently unoptimized and in need of reorganization too. May also make keyboard keys invisible	2024-07-24 23:59:39 +00:00
galister	a56ed68b44	mirrors: print pw errors	2024-07-24 21:06:37 +00:00
galister	7a6040bfee	feat: ui sprites + openxr skybox	2024-07-24 21:06:37 +00:00
galister	17addcde78	fix --show behavior	2024-07-23 19:09:34 +09:00
Torge Matthies	5a45d4dd2f	openxr: fix triple-click bindings on left hand reacting to the wrong hand	2024-07-22 23:27:36 +00:00
galister	9a928b1c0c	Monado: support new space offset API	2024-07-20 03:33:07 +09:00
galister	3764873209	docs: hyprland-specific mouse issue	2024-07-18 09:52:10 +00:00
galister	106028be67	reset click counter on pass	2024-07-17 14:22:06 +00:00
galister	d58268b8ec	downgrade freetype	2024-07-17 14:22:06 +00:00
galister	787a3851b3	openxr: add triple-click option	2024-07-17 14:22:06 +00:00
galister	2bfa78e9db	x11: fix upright screens	2024-07-13 17:27:47 +09:00
galister	71068a0215	docs: space-drag crash to known issues	2024-07-12 10:11:31 +00:00
galister	5575e4f49f	fix: openxr swapchain banding	2024-07-11 19:17:41 +09:00
galister	a991c6b84a	feat: toggle to show by default	2024-07-11 16:59:57 +09:00
galister	bdc500973c	feat: cubic filtering	2024-07-11 16:23:48 +09:00
galister	80bd65235d	add screenshot to readme	2024-06-27 11:04:06 +00:00
galister	39595faaad	update deps	2024-06-26 12:02:29 +09:00
galister	1fc6cb4a36	bump version	2024-06-23 09:57:29 +09:00
galister	10db0f690a	fix image_drm_format_modifier being a hard requirement	2024-06-22 20:58:30 +09:00
galister	072540fbb5	replace no-dmabuf feature with auto check	2024-06-22 20:55:55 +09:00
galister	d225250b77	feat: openxr space rotate	2024-06-17 15:15:16 +09:00
galister	c7aa88647c	feat: space drag multiplier	2024-06-17 14:36:21 +09:00
galister	abc132c553	cargo update	2024-06-17 10:07:00 +09:00
HavenOfTheRaven	371d3c2757	fixed error (#51 )	2024-06-17 00:04:44 +00:00
HavenOfTheRaven	c06ec6d974	Update Dependencies (#48 ) * updated dependencies * updated vulkano and ash with fixes	2024-06-16 14:49:45 +00:00
Ben Scholzen (DASPRiD)	b3ae583cb4	fix(hid): setup xkb extension before querying keyboard device ID	2024-06-16 01:27:33 +09:00
galister	8fb9ef4a05	openvr: fix autolaunch	2024-06-14 09:28:32 +09:00
galister	40383f2529	release v0.4.1	2024-06-09 10:08:02 +09:00
alexdenerqal	b2429bce7f	fix(openxr): correct default bindings for move_mouse	2024-06-09 09:57:57 +09:00
galister	59c0bc870c	keyboard: use fallback layout if failing to load	2024-06-09 09:53:46 +09:00
galister	4abfa3c3ac	fix double-click hold not working on OpenXR	2024-06-09 00:19:42 +09:00
galister	7037740d46	try harder to find libmonado	2024-06-09 00:14:17 +09:00
galister	8ae65083f9	update cargo lock	2024-06-08 10:13:48 +09:00
galister	0fd356f306	release v0.4.0	2024-06-08 09:00:46 +09:00
galister	52a56cfd90	more detailed screen prompt	2024-06-08 08:54:07 +09:00
galister	eefffccbdf	ci: add libxkbcommon-x11-dev	2024-06-08 08:09:54 +09:00
galister	344eaca3a8	sysinfo o longer optional	2024-06-08 07:49:30 +09:00
galister	7d42ee9721	fix: meta/altgr key not working	2024-06-07 12:22:20 +09:00
galister	bb88137533	keyboard debug logging	2024-06-07 12:15:20 +09:00
galister	8eb6df9644	warn if unable to write actions.json	2024-06-07 11:13:47 +09:00
galister	a0d93e821e	fix: keyboard interact element overflow	2024-06-06 16:53:39 +09:00
galister	8461dbe7ac	message phrasing	2024-06-06 13:59:57 +09:00
galister	d5f7181a05	feat: ensure single instance	2024-06-06 13:59:02 +09:00
galister	8bad2e1116	fix: anchor at wrong position	2024-06-06 13:27:42 +09:00
galister	d5610f6fe6	fix(openxr): haptics	2024-06-06 13:02:47 +09:00
galister	95855ccea8	fix(openxr): Z order	2024-06-06 13:02:47 +09:00
galisterandYuxuan Shui	415ef91a43	feat: PipeWire capture on X11 Co-authored-by: Yuxuan Shui <yshuiv7@gmail.com>	2024-06-06 01:08:20 +09:00
galister	7641a662dc	do not require ext_image_drm_format_modifier	2024-06-05 20:13:47 +09:00
galister	3a3cda7a45	feat: libxkbcommon layouts	2024-06-05 19:54:11 +09:00
galister	65d62d79fe	fix: openxr playspace mover behavior	2024-06-04 23:02:55 +09:00
galister	1eebde3944	feat: save active layout	2024-06-04 20:43:59 +09:00
galister	698c447e34	fix: mouse click when pointing at 2 screens	2024-06-04 20:42:27 +09:00
galister	a0a853825c	fix: settings spawn in wrong spot	2024-06-04 17:51:31 +09:00
galister	b8a0e3630d	feat: configurable openxr bindings	2024-06-04 17:13:44 +09:00
galister	773ff6885d	pipewire: better desktop compatibility (Niri)	2024-06-03 22:57:42 +09:00
galisterandRinLovesYou	4a45683650	feat(openxr): Monado playspace mover Co-authored-by: RinLovesYou <xxklintan123xx@gmail.com>	2024-06-03 11:04:45 +09:00
galister	009626704c	adjust scroll speed on analog sticks	2024-06-03 10:22:25 +09:00
nvkomata	84b08b99f7	new icon	2024-06-03 02:05:12 +02:00
galister	93a4a6702b	docs: working set explanation	2024-05-09 08:59:02 +00:00
galister	6ee0cb4fd1	fix: font load error panic	2024-05-04 00:50:53 +09:00
galister	9a693862ba	new logo, thanks @nvkomata	2024-05-04 00:27:43 +09:00
galister	c70833b86a	feat: persist layout between sessions	2024-04-25 02:13:18 +02:00
galister	5afb5ed4ab	refactor	2024-04-24 06:34:01 +02:00
galister	065ce8f136	fix: dont overload xr runtime with notify spam	2024-04-24 06:34:01 +02:00
galister	1fa842bb44	feat: anchor point for working set	2024-04-24 10:19:26 +09:00
galister	f6a9db5759	feat: dummy screens and battery states for uidev (#36 )	2024-04-17 12:34:55 +00:00
Garrett	42ab3a3199	Add CenteredLabel (#35 )	2024-04-17 05:40:04 +00:00
galister	1772e3aefd	fix: uidev dynamic update + flicker (#34 )	2024-04-17 04:26:28 +00:00
galister	f2a5ec0c37	feat: no-dmabuf feature (#33 )	2024-04-16 00:43:52 +00:00
galister	461657e4c3	fix: ui-dev on xorg (#30 ) * fix: ui-dev on xorg * recreate swapchain on resize * only request window size after canvas size change * only redraw after canvas changed * redraw if run_ref failed * redraw at 1s interval	2024-04-15 14:46:32 +00:00
galister	7ca6df6d3b	log panics	2024-04-15 22:25:26 +09:00
galister	be81c344d3	ci: dont run checks on pushes, only PRs	2024-04-14 18:58:48 +09:00
galister	42aef89822	feat: configurable primary_font	2024-04-14 18:16:26 +09:00
galister	7184a9f21f	feat: canvas alpha	2024-04-14 17:48:44 +09:00
galister	d99a58da9e	feat: improve screen alighment on show/hide	2024-04-14 17:17:20 +09:00
galister	8e799d1b8f	fix: request wlr-dmabuf frames in every case	2024-04-14 17:15:54 +09:00
galister	5db7524787	feat: ui dev window (#29 ) * feat: ui dev window * remove unneeded dep	2024-04-14 05:36:47 +00:00
galister	8f9c3f5e3a	pw token removal instuctions	2024-04-13 23:57:32 +00:00
Chris Dandhare_ware	031efb2d79	Add bindings for WMR controllers (#28 ) * Add bindings for WMR controllers * Add support for HP Mixed Reality Controllers --------- Co-authored-by: hare_ware <3469405-hare_ware@users.noreply.gitlab.com>	2024-04-12 09:55:43 +00:00
galister	0b087cb9a9	fix: only move mouse on depress, not release	2024-04-12 11:58:18 +09:00
Jarett Millard	5989d32075	fix: 12-hour format strings in watch.yaml (#27 )	2024-04-11 01:52:15 +00:00
galister	b19b0cb40d	feat: log to /tmp by default	2024-04-10 16:30:26 +09:00
galister	6e2c3fc523	fix: log to file	2024-04-10 14:57:23 +09:00
galister	399168fc38	fix: ci typo	2024-04-10 10:59:07 +09:00
galister	97aab43d09	chore: deps	2024-04-10 10:48:29 +09:00
galister	fc158ed6eb	fix: ci pipeline	2024-04-10 08:44:08 +09:00
galister	93fe2bfca2	chore: package updates	2024-04-10 08:42:58 +09:00
galister	944b7c1835	chore: clippy	2024-04-10 08:38:19 +09:00
galister	78b51179ee	fix: x11 builds	2024-04-10 08:33:27 +09:00
galister	0283916ffa	add ci builds for various configs	2024-04-10 08:07:25 +09:00
alexdenerqal	63e8cd59b2	fix: loading pipewire tokens (#24 )	2024-04-07 15:23:56 +00:00
alexdenerqal	1d1a4f01ae	feat: add focus follows the mouse mode (#23 )	2024-04-07 15:12:47 +00:00
HavenOfTheRaven	7e2f172b74	fixed compiling issue for when x11 is not included as a feature (#22 )	2024-04-06 04:46:00 +00:00
galister	17fb1211ee	openvr: print missing vulkan extensions	2024-04-06 06:57:03 +09:00
galister	1bee936db1	feat: persist screen visibility & curvature	2024-04-05 01:59:03 +09:00
galister	e3ae9a9890	rework config system	2024-04-04 22:46:39 +09:00
galister	2d0f733c67	feat(settings-panel): auto-realign toggle	2024-04-04 21:17:26 +09:00
galister	6cb683a86b	fix(openxr): move removed screens to delete_queue	2024-04-04 20:14:35 +09:00
galister	dc40d7e42b	docs: x11 doesn't support runtime screen changes	2024-04-04 11:10:19 +00:00
galister	c02edb7a43	feat: handle screen changes at runtime	2024-04-04 20:06:53 +09:00
galister	e845ac8d53	add curved screens to readme	2024-04-04 03:16:29 +00:00
alexdenerqal	aae649b1f2	feat: add option to disable realigning working set windows on show/hide (#21 )	2024-03-30 08:32:52 +00:00
galister	7eb5201c90	fix: only realign grabbable	2024-03-29 14:26:45 +01:00
galister	7d987f5cb8	fix: watch notifications	2024-03-29 14:09:39 +01:00
galister	106af7dd03	chore: clippy	2024-03-29 12:54:13 +01:00
alexdenerqal	ab0d91ea20	feat: allow disabling the sliding of screens back and forth (#20 ) fix: sliding screens with smooth trackpad scrolling knuckles smooth trackpad scrolling can return NaN	2024-03-29 11:49:45 +00:00
galister	7f6e8909e6	feat: highlight toggle buttons when on	2024-03-29 12:48:31 +01:00
galister	4843aeef5d	feat: toast topics	2024-03-29 12:21:12 +01:00
galister	810c0cac63	feat: ipd label	2024-03-28 11:51:15 +01:00
galister	1438d3e7eb	add known auto-start issue	2024-03-28 10:03:09 +00:00
galister	5ab506e192	Release v0.3.2	2024-03-23 21:55:09 +01:00
galister	7ab036024d	chore: more clippy	2024-03-23 16:05:42 +01:00
galister	e70aaa002e	chore: clippy	2024-03-23 15:41:54 +01:00
galister	a1d3b9684d	fix: end async work on soft-shutdown	2024-03-23 15:35:01 +01:00
galister	9fe9832a8d	openxr: separate release threshold for grab, click, altclick	2024-03-21 21:47:08 +01:00
galister	0b813aeb10	docs: wivrn love + update known issues	2024-03-21 21:10:23 +01:00
galister	155f653f32	omg: curved screens	2024-03-21 21:04:20 +01:00
galister	82374a60a0	Release v0.3.1	2024-03-19 18:19:32 +01:00
galister	0d41bf1a3e	openvr: correct size for portrait overlays	2024-03-19 18:16:23 +01:00
galister	3907e089de	openvr: re-upload line texs on show-hide to prevent disappearing lasers	2024-03-19 17:16:35 +01:00
Aleksander	72bac6465e	Fix ui_transform (#17 )	2024-03-19 16:14:56 +00:00
Stuart Irwin	271e037692	Save screen scaling changes (#16 )	2024-03-17 21:22:18 +00:00
galister	bc78450c6a	openxr: use squeeze/force for knuckles	2024-03-17 17:11:25 +01:00
galister	dce634edd1	openxr: click/grab/altclick sensitivity option	2024-03-17 16:41:32 +01:00
galister	69d14eebe5	fix when desktop origin other than (0,0)	2024-03-17 16:30:16 +01:00
galister	54dfb297ac	improve error handling	2024-03-17 16:11:05 +01:00
galister	1d1230b1e7	chore: update wlx-capture & other deps	2024-03-17 13:08:49 +01:00
galister	67b6b90158	fonts: dont panic on load error	2024-03-17 11:25:11 +01:00
galister	31ec035db7	pipewire: log screen capture start failures	2024-03-16 11:27:10 +01:00
galister	deb43f0d94	do not log toasts	2024-03-11 09:07:35 +01:00
Stuart Irwin	4434d82981	Add uptime timer module (#15 )	2024-03-11 07:51:43 +00:00
libjared	8ba5d68e5a	Update keyboard.yaml (#14 ) - update virtual key list URL - remove references to xmodmap - ensure layouts are consistent with length - remove alt_layout for now	2024-03-10 22:31:54 +00:00
galister	0c6e319fbe	Release v0.3.0	2024-03-10 21:40:14 +01:00
galister	4679961cb2	openvr: smoother rotate	2024-03-10 20:56:13 +01:00
galister	cb12357d68	openvr: dont overwrite bindings	2024-03-10 16:55:40 +01:00
galister	b401fb28fd	openvr: space rotate, recenter height adjust	2024-03-10 16:28:37 +01:00
galister	06478bbfc9	openvr: recenter rework	2024-03-10 14:40:50 +01:00
galister	b57b77b06a	openvr: reset offsets reloads from disk	2024-03-10 14:08:12 +01:00
galister	5a077e394c	openvr: reload playspace on scene app change	2024-03-10 13:23:00 +01:00
galister	a08c260898	openvr: chaperone movement fix	2024-03-10 13:19:08 +01:00
galister	45d08cd89b	x11: fix cursor size	2024-03-10 00:10:28 +01:00
galister	49b9cc361d	x11: fix screen gamma	2024-03-10 00:02:10 +01:00
galister	2f8dcaf110	use linked openxr	2024-03-09 21:21:48 +01:00
galister	473c6e2038	cleanup	2024-03-09 17:15:37 +01:00