Release 25.3

WayVR: Add DashboardShown and DashboardHidden events, add WlxInputState support (#167 )
Wlx: Fix various Clippy warnings
2026-10-28 14:02:26 +01:00 · 2025-03-02 21:52:50 +09:00 · 2025-02-28 21:05:27 +00:00 · 2025-02-28 01:07:55 +00:00 · 2025-02-20 06:26:35 +09:00 · 2025-02-20 06:26:35 +09:00
67 changed files with 7421 additions and 1147 deletions
@@ -4,6 +4,7 @@ on:
  push:
    branches:
      - 'main'
+      - 'staging'

 env:
  APPDIR: WlxOverlay-S.AppDir
@@ -23,7 +24,7 @@ jobs:
          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
+          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 libwayland-dev libegl-dev
          rustup update
          
          test -f linuxdeploy-x86_64.AppImage || wget -q "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage"
@@ -21,7 +21,7 @@ jobs:
        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
+        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 libwayland-dev libegl-dev
    - name: Build
      run: cargo build --verbose
    - name: Run tests
@@ -0,0 +1,28 @@
+name: Check Wayland+OpenXR+OpenVR+WayVR
+
+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 libwayland-dev libegl-dev
+    - name: Build
+      run: cargo build --verbose --no-default-features --features=wayland,openxr,openvr,wayvr
+    - name: Run tests
+      run: cargo test --verbose --no-default-features --features=wayland,openxr,openvr,wayvr
@@ -23,7 +23,7 @@ jobs:
          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
+          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 libwayland-dev libegl-dev
          rustup update
          
          test -f linuxdeploy-x86_64.AppImage || wget -q "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage"
@@ -4,26 +4,26 @@ debug = true

 [package]
 name = "wlx-overlay-s"
-version = "0.6.0"
+version = "25.3.0"
 edition = "2021"

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

 [dependencies]
-anyhow = "1.0.86"
+anyhow = "1.0.89"
 ash = "^0.37.2"
 chrono = "0.4.38"
-chrono-tz = "0.9.0"
+chrono-tz = "0.10.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.28.1"
+env_logger = "0.11.5"
 fontconfig-rs = "0.1.1"
 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"] }
+glam = { version = "0.29.2", features = ["approx", "mint", "serde"] }
 idmap = { version = "0.2.21", features = ["serde"] }
 idmap-derive = "0.1.2"
 input-linux = "0.7.0"
@@ -41,7 +41,7 @@ ovr_overlay = { features = [
  "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 = [
+rodio = { version = "0.20.1", default-features = false, features = [
  "wav",
  "hound",
 ] }
@@ -51,12 +51,12 @@ 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"
+sysinfo = { version = "0.32.0" }
+thiserror = "2.0.3"
 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", tag = "v0.3.13", default-features = false }
-libmonado-rs = { git = "https://github.com/technobaboo/libmonado-rs", rev = "a495f6d", optional = true }
+wlx-capture = { git = "https://github.com/galister/wlx-capture", tag = "v0.4.2", default-features = false }
+libmonado = { git = "https://github.com/technobaboo/libmonado-rs", rev = "256895b18c8f9368174fad8a6232ff07764eeacb", optional = true }
 winit = { version = "0.30.0", optional = true }
 xdg = "2.5.2"
 log-panics = { version = "2.1.0", features = ["with-backtrace"] }
@@ -70,17 +70,46 @@ image_dds = { version = "0.6.0", default-features = false, features = [
 ] }
 mint = "0.5.9"

+################################
+#WayVR-only deps
+################################
+khronos-egl = { version = "6.0.0", features = ["static"], optional = true }
+smithay = { git = "https://github.com/Smithay/smithay.git", default-features = false, features = [
+  "renderer_gl",
+  "backend_egl",
+  "backend_drm",
+  "xwayland",
+  "wayland_frontend",
+], optional = true }
+uuid = { version = "1.10.0", features = ["v4", "fast-rng"], optional = true }
+wayland-client = { version = "0.31.6", optional = true }
+wayland-egl = { version = "0.32.4", optional = true }
+interprocess = { version = "2.2.2", optional = true }
+bytes = { version = "1.9.0", optional = true }
+wayvr_ipc = { git = "https://github.com/olekolek1000/wayvr-ipc.git", rev = "a72587d23f3bb8624d9aeb1f13c0a21e65350f51", default-features = false, optional = true }
+################################
+
 [build-dependencies]
 regex = { version = "*" }

 [features]
-default = ["openvr", "openxr", "osc", "x11", "wayland"]
+default = ["openvr", "openxr", "osc", "x11", "wayland", "wayvr"]
 openvr = ["dep:ovr_overlay", "dep:json"]
-openxr = ["dep:openxr", "dep:libmonado-rs"]
+openxr = ["dep:openxr", "dep:libmonado"]
 osc = ["dep:rosc"]
 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"]
+wayvr = [
+  "dep:khronos-egl",
+  "dep:smithay",
+  "dep:uuid",
+  "dep:wayland-client",
+  "dep:wayland-egl",
+  "dep:interprocess",
+  "dep:bytes",
+  "dep:wayvr_ipc",
+]
 as-raw-xcb-connection = []
@@ -2,7 +2,7 @@

 A lightweight OpenXR/OpenVR overlay for Wayland and X11 desktops, inspired by XSOverlay.

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

 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.

@@ -19,11 +19,28 @@ Questions/issues specific to WlxOverlay-S will be handled in the `wlxoverlay` ch

 ## Setup

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

+**Note:** If you are using Monado or WiVRn, no additional setup steps are required for Flatpak Steam compatibility—most people use WlxOverlay-S seamlessly with Monado/WiVRn.
+
+### SteamVR via Steam Flatpak
+
+For users specifically running **SteamVR via Steam Flatpak**, follow these steps:
+
+1. Grab the latest AppImage from [Releases](https://github.com/galister/wlx-overlay-s/releases).
+1. `WlxOverlay-S-*.AppImage --appimage-extract`
+1. `chmod +x squashfs-root/AppRun`
+1. Move the newly created `squashfs-root` folder to a location accessible by the Steam Flatpak.
+1. `flatpak override com.valvesoftware.Steam --user --filesystem=xdg-run/pipewire-0/:rw`
+1. Restart Steam.
+1. Start SteamVR.
+1. `flatpak run --command='/path/to/squashfs-root/AppRun' com.valvesoftware.Steam`
+
 AUR package is [wlx-overlay-s-git](https://aur.archlinux.org/packages/wlx-overlay-s-git).

 You may also want to [build from source](https://github.com/galister/wlx-overlay-s/wiki/Building-from-Source).
@@ -32,13 +49,13 @@ You may also want to [build from source](https://github.com/galister/wlx-overlay

 **When the screen share pop-up appears, check the terminal and select the screens in the order it requests.**

-If you selected the screens in the wrong order:
+In case screens were selected 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.
+**SteamVR users**: WlxOverlay-S will register itself for auto-start, so there is no need to start it every time.

-**Envision users**: Set `wlx-overlay-s --openxr --show` as the _Autostart Command_ on your Envision profile! This will give you a home environment with a [customizable background](https://github.com/galister/wlx-overlay-s/wiki/OpenXR-Skybox)!
+**Envision users**: Set `wlx-overlay-s --openxr --show` as the _Autostart Command_ on your Envision profile! This will show a home environment with headset passthrough by default or a [customizable background](https://github.com/galister/wlx-overlay-s/wiki/OpenXR-Skybox)! If you are using the appimage instead, set the _Autostart Command_ to the location of tha appimage binary, e.g `/full/path/to/wlx-overlay-s.appimage --openxr --show`.

 **Please continue reading the guide below.**

@@ -46,18 +63,18 @@ If you selected the screens in the wrong order:

 ### Working Set

-Your working set consists of your currently selected overlays; screens, mirrors, keyboard, etc.
+The working set consists of all 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.
+The working set appears in front of the headset when shown, and can be re-centered by hiding and showing again.

-Show and hide your working set using:
+Show and hide the 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.)
+- Non-vive controller: double-tap B or Y on the left controller.
+- Vive controller: double-tap the menu button on the left controller (for SteamVR, the `showhide` binding must be bound)

 ### 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. \
+Much of the functionality in WlxOverlay-S depends on what color of laser is used to interact with a UI element. \
 Using the default settings, there are 3 modes:

 - Regular Mode: Blue laser
@@ -70,7 +87,7 @@ The guide here uses the colors for ease of getting started.

 ### The Watch

-Check your left wrist for the watch. The watch is your primary tool for controlling the app.
+Check your left wrist for the watch. The watch is the primary tool for controlling the app.

 ![Watch usage guide](https://github.com/galister/wlx-overlay-s/blob/guide/wlx-watch.png)

@@ -85,14 +102,14 @@ The click depends on the laser color:
 - Purple laser: Middle click
 - Stick up/down: Scroll wheel

-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.
+To **curve a screen**, grab it with one hand. Then, using the 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

 The keyboard is fully customizable via the [keyboard.yaml](https://raw.githubusercontent.com/galister/wlx-overlay-s/main/src/res/keyboard.yaml) file. \
-Download it into your `~/.config/wlxoverlay/` folder and edit it to your liking.
+Download it into the `~/.config/wlxoverlay/` folder and edit it to your liking.

 Typing

@@ -100,7 +117,7 @@ Typing
 - While using ORANGE laser, all keystrokes will have SHIFT applied.
 - Purple laser has no effect as of now.

-**Modifier Keys** are sticky. They will remain pressed until you press a non-modifier key, or toggle them off.
+**Modifier Keys** are sticky. They will remain pressed until a non-modifier key is pressed, the modifier gets toggled off, or the keyboard gets hidden.

 ### Default Bindings

@@ -115,6 +132,10 @@ We would like to work with you and include additional bindings.

 ## Troubleshooting

+When an error is detected, we often print tips for fixing into the log file.
+
+Logs will be at `/tmp/wlx.log` for most distros.
+
 Check [here](https://github.com/galister/wlx-overlay-s/wiki/Troubleshooting) for tips.

 ## Known Issues
@@ -125,7 +146,21 @@ Hyprland users: Hyprland v0.41.0 changed their absolute input implementation to

 Niri users: use on Niri 0.1.7 or later.

-Other desktops: You may have selected the screens in the wrong order, see [First Start](#first-start).
+X11 users might be dealing with a [Phantom Monitor](https://wiki.archlinux.org/title/Xrandr#Disabling_phantom_monitor).
+
+Other desktops: The screens may have been selected in the wrong order, see [First Start](#first-start).
+
+### Crashes, blank screens
+
+There are some driver-desktop combinations that don't play nice with DMA-buf capture. 
+
+Disabling DMA-buf capture is a good first step to try when encountering an app crash or gpu driver reset.
+
+```bash
+echo 'capture_method: pw_fallback' > ~/.config/wlxoverlay/conf.d/pw_fallback.yaml
+```
+
+Without DMA-buf capture, capturing screens takes CPU power, so let's try and not show too many screens at the same time.

 ### Space-drag crashes SteamVR

@@ -133,7 +168,7 @@ This has been idenfitied as an issue with SteamVR versions 2.5.5 and above (late

 ### 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.
+This is a rare issue that can make KDE Plasma not react to click or keys due to what seems to be a race condition with modifiers. Restarting the overlay fixes this.

 ### X11 limitations

@@ -0,0 +1,90 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/galister/wlx-overlay-s/refs/heads/guide/wayvr/logo.svg" height="120"/>
+</p>
+
+**WayVR acts as a bridge between Wayland applications and wlx-overlay-s panels, allowing you to display your applications within a VR environment. Internally, WayVR utilizes Smithay to run a Wayland compositor.**
+
+# >> Quick setup <<
+
+#### Configure your applications list
+
+Go to `src/res/wayvr.yaml` to configure your desired application list. This configuration file represents all currently available WayVR options. Feel free to adjust it to your liking.
+
+#### Add WayVR Launcher to your watch
+
+Copy `watch_wayvr_example.yaml` to `~/.config/wlxoverlay/watch.yaml`. This file contains pre-configured **WayVRLauncher** and **WayVRDisplayList** widget types. By default, the _default_catalog_ is used.
+
+That's it; you're all set!
+
+###### _Make sure you have `wayvr` feature enabled in Cargo.toml (enabled by default)_
+
+![alt text](https://raw.githubusercontent.com/galister/wlx-overlay-s/refs/heads/guide/wayvr/watch.jpg)
+
+# Overview
+
+### Features
+
+- Display Wayland applications without GPU overhead (zero-copy via dma-buf)
+- Mouse and keyboard input, with precision scrolling support
+- Tested on AMD and Nvidia
+
+### Supported software
+
+- Basically all Qt and GTK applications (they work out of the box)
+- Most XWayland applications via `cage`
+
+### XWayland
+
+WayVR does not have native XWayland support. You can run X11 applications (or these who require DISPLAY set) by wrapping them in a `cage` program, like so:
+
+```yaml
+- name: "Xeyes"
+  target_display: "Disp1"
+  exec: "cage"
+  args: "xeyes -- -fg blue"
+```
+
+instead of:
+
+```yaml
+- name: "Xeyes"
+  target_display: "Disp1"
+  exec: "xeyes"
+  args: "-fg blue"
+```
+
+in `wayvr.yaml` configuration file, in your desired catalog.
+
+### Launching external apps inside WayVR
+
+To launch your app externally:
+
+```sh
+DISPLAY= WAYLAND_DISPLAY=wayland-$(cat $XDG_RUNTIME_DIR/wayvr.disp) yourapp
+```
+
+or (in the most cases):
+
+```
+DISPLAY= WAYLAND_DISPLAY=wayland-20 yourapp
+```
+
+Setting `DISPLAY` to an empty string forces various apps to use Wayland instead of X11.
+
+# Troubleshooting
+
+### My application doesn't launch but others do!
+
+Even though some applications support Wayland, some still check for the `DISPLAY` environment variable and an available X11 server, throwing an error. This can also be fixed by running `cage` on top of them.
+
+### Image corruption
+
+dma-buf textures may display various graphical glitches due to unsupported dma-buf tiling modifiers between GLES<->Vulkan on Radeon RDNA3 graphics cards. Current situation: https://gitlab.freedesktop.org/mesa/mesa/-/issues/11629). Nvidia should work out of the box, without any isues. Alternatively, you can run wlx-overlay-s with `LIBGL_ALWAYS_SOFTWARE=1` to mitigate that (only the Smithay compositor will run in software renderer mode, wlx will still be accelerated).
+
+### Floating windows
+
+Context menus are not functional in most cases yet, including drag & drop support.
+
+### Forced window shadows in GTK
+
+GNOME still insists on rendering client-side decorations instead of server-side ones. This results in all GTK applications looking odd due to additional window shadows. [Fix here, "Client-side decorations"](https://wiki.archlinux.org/title/GTK)
@@ -0,0 +1,207 @@
+# looking to make changes?
+# drop me in ~/.config/wlxoverlay/watch.yaml
+#
+
+width: 0.115
+
+size: [400, 272]
+
+elements:
+  # background panel
+  - type: Panel
+    rect: [0, 30, 400, 130]
+    corner_radius: 20
+    bg_color: "#24273a"
+
+  - type: Button
+    rect: [2, 162, 26, 36]
+    corner_radius: 4
+    font_size: 15
+    bg_color: "#c6a0f6"
+    fg_color: "#24273a"
+    text: "C"
+    click_up: # destroy if exists, otherwise create
+      - type: Window
+        target: settings
+        action: ShowUi # only triggers if not exists
+      - type: Window
+        target: settings
+        action: Destroy # only triggers if exists since before current frame
+
+  # Dashboard toggle button
+  - type: Button
+    rect: [32, 162, 48, 36]
+    corner_radius: 4
+    font_size: 15
+    bg_color: "#2288FF"
+    fg_color: "#24273a"
+    text: "Dash"
+    click_up:
+      - type: WayVR
+        action: ToggleDashboard
+
+  # Keyboard button
+  - type: Button
+    rect: [84, 162, 48, 36]
+    corner_radius: 4
+    font_size: 15
+    fg_color: "#24273a"
+    bg_color: "#a6da95"
+    text: Kbd
+    click_up:
+      - type: Overlay
+        target: "kbd"
+        action: ToggleVisible
+    long_click_up:
+      - type: Overlay
+        target: "kbd"
+        action: Reset
+    right_up:
+      - type: Overlay
+        target: "kbd"
+        action: ToggleImmovable
+    middle_up:
+      - type: Overlay
+        target: "kbd"
+        action: ToggleInteraction
+    scroll_up:
+      - type: Overlay
+        target: "kbd"
+        action:
+          Opacity: { delta: 0.025 }
+    scroll_down:
+      - type: Overlay
+        target: "kbd"
+        action:
+          Opacity: { delta: -0.025 }
+
+  # bottom row, of keyboard + overlays
+  - type: OverlayList
+    rect: [134, 160, 266, 40]
+    corner_radius: 4
+    font_size: 15
+    fg_color: "#cad3f5"
+    bg_color: "#1e2030"
+    layout: Horizontal
+    click_up: ToggleVisible
+    long_click_up: Reset
+    right_up: ToggleImmovable
+    middle_up: ToggleInteraction
+    scroll_up:
+      Opacity: { delta: 0.025 }
+    scroll_down:
+      Opacity: { delta: -0.025 }
+
+  - type: WayVRLauncher
+    rect: [0, 200, 400, 36]
+    corner_radius: 4
+    font_size: 15
+    fg_color: "#24273a"
+    bg_color: "#e590c4"
+    catalog_name: "default_catalog"
+
+  - type: WayVRDisplayList
+    rect: [0, 236, 400, 36]
+    corner_radius: 4
+    font_size: 15
+    fg_color: "#24273a"
+    bg_color: "#ca68a4"
+
+  # local clock
+  - type: Label
+    rect: [19, 90, 200, 50]
+    corner_radius: 4
+    font_size: 46 # Use 32 for 12-hour time
+    fg_color: "#cad3f5"
+    source: Clock
+    format: "%H:%M" # 23:59
+    #format: "%I:%M %p" # 11:59 PM
+
+  # local date
+  - type: Label
+    rect: [20, 117, 200, 20]
+    corner_radius: 4
+    font_size: 14
+    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: "#cad3f5"
+    source: Clock
+    format: "%A" # Tuesday
+    #format: "%a" # Tue
+
+  # alt clock 1
+  - type: Label
+    rect: [210, 90, 200, 50]
+    corner_radius: 4
+    font_size: 24 # Use 18 for 12-hour time
+    fg_color: "#8bd5ca"
+    source: Clock
+    timezone: 0 # change TZ1 here
+    format: "%H:%M" # 23:59
+    #format: "%I:%M %p" # 11:59 PM
+  - type: Label
+    rect: [210, 60, 200, 50]
+    corner_radius: 4
+    font_size: 14
+    fg_color: "#8bd5ca"
+    source: Timezone
+    timezone: 0 # change TZ1 label here
+
+  # alt clock 2
+  - type: Label
+    rect: [210, 150, 200, 50]
+    corner_radius: 4
+    font_size: 24 # Use 18 for 12-hour time
+    fg_color: "#b7bdf8"
+    source: Clock
+    timezone: 1 # change TZ2 here
+    format: "%H:%M" # 23:59
+    #format: "%I:%M %p" # 11:59 PM
+  - type: Label
+    rect: [210, 120, 200, 50]
+    corner_radius: 4
+    font_size: 14
+    fg_color: "#b7bdf8"
+    source: Timezone
+    timezone: 1 # change TZ2 label here
+
+  # batteries
+  - type: BatteryList
+    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: 33
+
+  # volume buttons
+  - type: Button
+    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: [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%"]
@@ -0,0 +1,12 @@
+[Unit]
+Description=wlx-overlay-s - Lightweight OpenXR/OpenVR overlay for Wayland and X11 desktops
+After=monado.service
+BindsTo=monado.service
+Requires=monado.socket
+Requires=graphical-session.target
+
+[Service]
+ExecStart=@prefix@/bin/wlx-overlay-s
+
+[Install]
+WantedBy=monado.service
@@ -14,14 +14,14 @@ use crate::{
    hid::{get_keymap_wl, get_keymap_x11},
    overlays::{
        anchor::create_anchor,
-        keyboard::create_keyboard,
+        keyboard::{create_keyboard, KEYBOARD_NAME},
        screen::WlxClientAlias,
        watch::{create_watch, WATCH_NAME},
    },
    state::AppState,
 };

-use super::overlay::OverlayData;
+use super::overlay::{OverlayData, OverlayID};

 #[derive(Error, Debug)]
 pub enum BackendError {
@@ -97,7 +97,7 @@ where
                state.show_hide = true;
            }
            overlays.insert(
-                state.id,
+                state.id.0,
                OverlayData::<T> {
                    state,
                    backend,
@@ -108,16 +108,16 @@ where
        }

        let anchor = create_anchor(app)?;
-        overlays.insert(anchor.state.id, anchor);
+        overlays.insert(anchor.state.id.0, anchor);

        let mut watch = create_watch::<T>(app)?;
        watch.state.want_visible = true;
-        overlays.insert(watch.state.id, watch);
+        overlays.insert(watch.state.id.0, watch);

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

        Ok(Self { overlays, wl })
    }
@@ -158,7 +158,7 @@ where
                    create_ran = true;
                    for (meta, state, backend) in data.screens {
                        self.overlays.insert(
-                            state.id,
+                            state.id.0,
                            OverlayData::<T> {
                                state,
                                backend,
@@ -175,7 +175,7 @@ where
                    };

                    let meta = &app.screens[idx];
-                    let removed = self.overlays.remove(meta.id).unwrap();
+                    let removed = self.overlays.remove(meta.id.0).unwrap();
                    removed_overlays.push(removed);
                    log::info!("{}: Destroyed", meta.name);
                    app.screens.remove(idx);
@@ -187,7 +187,7 @@ where
                        continue;
                    };
                    let output = wl.outputs.get(id).unwrap();
-                    let Some(overlay) = self.overlays.get_mut(meta.id) else {
+                    let Some(overlay) = self.overlays.get_mut(meta.id.0) else {
                        continue;
                    };
                    let logical_pos =
@@ -209,7 +209,7 @@ where
                        continue;
                    };
                    let output = wl.outputs.get(id).unwrap();
-                    let Some(overlay) = self.overlays.get_mut(meta.id) else {
+                    let Some(overlay) = self.overlays.get_mut(meta.id.0) else {
                        continue;
                    };

@@ -270,7 +270,7 @@ where

    pub fn remove_by_selector(&mut self, selector: &OverlaySelector) -> Option<OverlayData<T>> {
        match selector {
-            OverlaySelector::Id(id) => self.overlays.remove(id),
+            OverlaySelector::Id(id) => self.overlays.remove(id.0),
            OverlaySelector::Name(name) => {
                let id = self
                    .overlays
@@ -282,12 +282,12 @@ where
        }
    }

-    pub fn get_by_id(&mut self, id: usize) -> Option<&OverlayData<T>> {
-        self.overlays.get(id)
+    pub fn get_by_id(&mut self, id: OverlayID) -> Option<&OverlayData<T>> {
+        self.overlays.get(id.0)
    }

-    pub fn mut_by_id(&mut self, id: usize) -> Option<&mut OverlayData<T>> {
-        self.overlays.get_mut(id)
+    pub fn mut_by_id(&mut self, id: OverlayID) -> Option<&mut OverlayData<T>> {
+        self.overlays.get_mut(id.0)
    }

    pub fn get_by_name<'a>(&'a mut self, name: &str) -> Option<&'a OverlayData<T>> {
@@ -307,7 +307,7 @@ where
    }

    pub fn add(&mut self, overlay: OverlayData<T>) {
-        self.overlays.insert(overlay.state.id, overlay);
+        self.overlays.insert(overlay.state.id.0, overlay);
    }

    pub fn show_hide(&mut self, app: &mut AppState) {
@@ -344,7 +344,7 @@ where
 #[derive(Clone, Deserialize, Debug)]
 #[serde(untagged)]
 pub enum OverlaySelector {
-    Id(usize),
+    Id(OverlayID),
    Name(Arc<str>),
 }

@@ -1,4 +1,5 @@
 use std::f32::consts::PI;
+use std::process::{Child, Command};
 use std::{collections::VecDeque, time::Instant};

 use glam::{Affine3A, Vec2, Vec3, Vec3A, Vec3Swizzles};
@@ -8,8 +9,9 @@ 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 crate::state::{AppSession, AppState, KeyboardFocus};

+use super::overlay::{OverlayID, OverlayState};
 use super::task::{TaskContainer, TaskType};
 use super::{common::OverlayContainer, overlay::OverlayData};

@@ -34,6 +36,7 @@ pub struct InputState {
    pub ipd: f32,
    pub pointers: [Pointer; 2],
    pub devices: Vec<TrackedDevice>,
+    processes: Vec<Child>,
 }

 impl InputState {
@@ -43,6 +46,7 @@ impl InputState {
            ipd: 0.0,
            pointers: [Pointer::new(0), Pointer::new(1)],
            devices: Vec::new(),
+            processes: Vec::new(),
        }
    }

@@ -51,7 +55,7 @@ impl InputState {
        self.pointers[1].before = self.pointers[1].now;
    }

-    pub fn post_update(&mut self) {
+    pub fn post_update(&mut self, session: &AppSession) {
        for hand in &mut self.pointers {
            #[cfg(debug_assertions)]
            {
@@ -67,6 +71,13 @@ impl InputState {
                if hand.now.show_hide != hand.before.show_hide {
                    log::debug!("Hand {}: show_hide {}", hand.idx, hand.now.show_hide);
                }
+                if hand.now.toggle_dashboard != hand.before.toggle_dashboard {
+                    log::debug!(
+                        "Hand {}: toggle_dashboard {}",
+                        hand.idx,
+                        hand.now.toggle_dashboard
+                    );
+                }
                if hand.now.space_drag != hand.before.space_drag {
                    log::debug!("Hand {}: space_drag {}", hand.idx, hand.now.space_drag);
                }
@@ -133,6 +144,24 @@ impl InputState {
                }
                _ => {}
            };
+
+            if hand.now.alt_click != hand.before.alt_click {
+                // Reap previous processes
+                self.processes
+                    .retain_mut(|child| !matches!(child.try_wait(), Ok(Some(_))));
+
+                let mut args = if hand.now.alt_click {
+                    session.config.alt_click_down.iter()
+                } else {
+                    session.config.alt_click_up.iter()
+                };
+
+                if let Some(program) = args.next() {
+                    if let Ok(child) = Command::new(program).args(args).spawn() {
+                        self.processes.push(child);
+                    }
+                }
+            }
        }
    }
 }
@@ -140,8 +169,8 @@ impl InputState {
 pub struct InteractionState {
    pub mode: PointerMode,
    pub grabbed: Option<GrabData>,
-    pub clicked_id: Option<usize>,
-    pub hovered_id: Option<usize>,
+    pub clicked_id: Option<OverlayID>,
+    pub hovered_id: Option<OverlayID>,
    pub release_actions: VecDeque<Box<dyn Fn()>>,
    pub next_push: Instant,
    pub haptics: Option<f32>,
@@ -193,6 +222,7 @@ pub struct PointerState {
    pub grab: bool,
    pub alt_click: bool,
    pub show_hide: bool,
+    pub toggle_dashboard: bool,
    pub space_drag: bool,
    pub space_rotate: bool,
    pub space_reset: bool,
@@ -204,13 +234,14 @@ pub struct PointerState {
 #[derive(Debug, Clone, Copy, Default)]
 pub struct PointerHit {
    pub pointer: usize,
-    pub overlay: usize,
+    pub overlay: OverlayID,
    pub mode: PointerMode,
    pub primary: bool,
    pub uv: Vec2,
    pub dist: f32,
 }

+#[derive(Clone)]
 pub struct Haptics {
    pub intensity: f32,
    pub duration: f32,
@@ -237,7 +268,7 @@ impl InteractionHandler for DummyInteractionHandler {

 #[derive(Debug, Clone, Copy, Default)]
 struct RayHit {
-    overlay: usize,
+    overlay: OverlayID,
    global_pos: Vec3A,
    local_pos: Vec2,
    dist: f32,
@@ -246,7 +277,7 @@ struct RayHit {
 #[derive(Debug, Clone, Copy, Default)]
 pub struct GrabData {
    pub offset: Vec3A,
-    pub grabbed_id: usize,
+    pub grabbed_id: OverlayID,
    pub old_curvature: Option<f32>,
    pub grab_all: bool,
 }
@@ -261,6 +292,15 @@ pub enum PointerMode {
    Special,
 }

+fn update_focus(focus: &mut KeyboardFocus, state: &OverlayState) {
+    if let Some(f) = &state.keyboard_focus {
+        if *focus != *f {
+            log::info!("Setting keyboard focus to {:?}", *f);
+            *focus = *f;
+        }
+    }
+}
+
 pub fn interact<O>(
    overlays: &mut OverlayContainer<O>,
    app: &mut AppState,
@@ -299,7 +339,7 @@ where
                &mut app.session.config,
            );
        } else {
-            log::warn!("Grabbed overlay {} does not exist", grab_data.grabbed_id);
+            log::warn!("Grabbed overlay {} does not exist", grab_data.grabbed_id.0);
            pointer.interaction.grabbed = None;
        }
        return (0.1, None);
@@ -341,7 +381,7 @@ where
        }
    }
    let Some(hovered) = overlays.mut_by_id(hit.overlay) else {
-        log::warn!("Hit overlay {} does not exist", hit.overlay);
+        log::warn!("Hit overlay {} does not exist", hit.overlay.0);
        return (0.0, None); // no hit
    };

@@ -361,6 +401,7 @@ where
    log::trace!("Hit: {} {:?}", hovered.state.name, hit);

    if pointer.now.grab && !pointer.before.grab && hovered.state.grabbable {
+        update_focus(&mut app.keyboard_focus, &hovered.state);
        pointer.start_grab(hovered, &mut app.tasks);
        return (
            hit.dist,
@@ -385,11 +426,13 @@ where
            .grabbed
            .is_some_and(|x| x.grabbed_id == hit.overlay)
        {
-            let can_curve = hovered.extent().is_some_and(|e| e[0] >= e[1]);
+            let can_curve = hovered
+                .frame_transform()
+                .is_some_and(|e| e.extent[0] >= e.extent[1]);

            if can_curve {
                let cur = hovered.state.curvature.unwrap_or(0.0);
-                let new = (cur - scroll * 0.01).min(0.35);
+                let new = (cur - scroll * 0.01).min(0.5);
                if new <= f32::EPSILON {
                    hovered.state.curvature = None;
                } else {
@@ -406,6 +449,7 @@ where

    if pointer.now.click && !pointer.before.click {
        pointer.interaction.clicked_id = Some(hit.overlay);
+        update_focus(&mut app.keyboard_focus, &hovered.state);
        hovered.backend.on_pointer(app, &hit, true);
    } else if !pointer.now.click && pointer.before.click {
        if let Some(clicked_id) = pointer.interaction.clicked_id.take() {
@@ -535,7 +579,7 @@ impl Pointer {
                overlay.state.realign(hmd);
                overlay.state.dirty = true;
            } else {
-                log::error!("Grabbed overlay {} does not exist", overlay.state.id);
+                log::error!("Grabbed overlay {} does not exist", overlay.state.id.0);
                self.interaction.grabbed = None;
            }
        } else {
@@ -572,7 +616,7 @@ impl Pointer {

    fn ray_test(
        &self,
-        overlay: usize,
+        overlay: OverlayID,
        transform: &Affine3A,
        curvature: &Option<f32>,
    ) -> Option<RayHit> {
@@ -17,6 +17,9 @@ pub mod uidev;
 #[cfg(feature = "osc")]
 pub mod osc;

+#[cfg(feature = "wayvr")]
+pub mod wayvr;
+
 pub mod overlay;

 pub mod task;
@@ -13,7 +13,7 @@ use ovr_overlay::{

 use crate::{
    backend::input::{Haptics, TrackedDevice, TrackedDeviceRole},
-    config_io::CONFIG_ROOT_PATH,
+    config_io,
    state::AppState,
 };

@@ -30,16 +30,17 @@ const PATH_HAPTICS: [&str; 2] = [
    "/actions/default/out/HapticsRight",
 ];

+const PATH_ALT_CLICK: &str = "/actions/default/in/AltClick";
+const PATH_CLICK_MODIFIER_MIDDLE: &str = "/actions/default/in/ClickModifierMiddle";
+const PATH_CLICK_MODIFIER_RIGHT: &str = "/actions/default/in/ClickModifierRight";
 const PATH_CLICK: &str = "/actions/default/in/Click";
 const PATH_GRAB: &str = "/actions/default/in/Grab";
+const PATH_MOVE_MOUSE: &str = "/actions/default/in/MoveMouse";
 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 PATH_TOGGLE_DASHBOARD: &str = "/actions/default/in/ToggleDashboard";

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

@@ -51,6 +52,7 @@ pub(super) struct OpenVrInputSource {
    scroll_hnd: ActionHandle,
    alt_click_hnd: ActionHandle,
    show_hide_hnd: ActionHandle,
+    toggle_dashboard_hnd: ActionHandle,
    space_drag_hnd: ActionHandle,
    space_rotate_hnd: ActionHandle,
    click_modifier_right_hnd: ActionHandle,
@@ -75,6 +77,7 @@ impl OpenVrInputSource {
        let scroll_hnd = input.get_action_handle(PATH_SCROLL)?;
        let alt_click_hnd = input.get_action_handle(PATH_ALT_CLICK)?;
        let show_hide_hnd = input.get_action_handle(PATH_SHOW_HIDE)?;
+        let toggle_dashboard_hnd = input.get_action_handle(PATH_TOGGLE_DASHBOARD)?;
        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)?;
@@ -111,6 +114,7 @@ impl OpenVrInputSource {
            scroll_hnd,
            alt_click_hnd,
            show_hide_hnd,
+            toggle_dashboard_hnd,
            space_drag_hnd,
            space_rotate_hnd,
            click_modifier_right_hnd,
@@ -196,6 +200,11 @@ impl OpenVrInputSource {
                .map(|x| x.0.bState)
                .unwrap_or(false);

+            app_hand.now.toggle_dashboard = input
+                .get_digital_action_data(self.toggle_dashboard_hnd, hand.input_hnd)
+                .map(|x| x.0.bState)
+                .unwrap_or(false);
+
            app_hand.now.space_drag = input
                .get_digital_action_data(self.space_drag_hnd, hand.input_hnd)
                .map(|x| x.0.bState)
@@ -316,7 +325,7 @@ fn get_tracked_device(
 }

 pub fn set_action_manifest(input: &mut InputManager) -> anyhow::Result<()> {
-    let action_path = CONFIG_ROOT_PATH.join("actions.json");
+    let action_path = config_io::get_config_root().join("actions.json");

    if let Err(e) = File::create(&action_path)
        .and_then(|mut f| f.write_all(include_bytes!("../../res/actions.json")))
@@ -324,19 +333,19 @@ pub fn set_action_manifest(input: &mut InputManager) -> anyhow::Result<()> {
        log::warn!("Could not write action manifest: {}", e);
    }

-    let binding_path = CONFIG_ROOT_PATH.join("actions_binding_knuckles.json");
+    let binding_path = config_io::get_config_root().join("actions_binding_knuckles.json");
    if !binding_path.is_file() {
        File::create(&binding_path)?
            .write_all(include_bytes!("../../res/actions_binding_knuckles.json"))?;
    }

-    let binding_path = CONFIG_ROOT_PATH.join("actions_binding_vive.json");
+    let binding_path = config_io::get_config_root().join("actions_binding_vive.json");
    if !binding_path.is_file() {
        File::create(&binding_path)?
            .write_all(include_bytes!("../../res/actions_binding_vive.json"))?;
    }

-    let binding_path = CONFIG_ROOT_PATH.join("actions_binding_oculus.json");
+    let binding_path = config_io::get_config_root().join("actions_binding_oculus.json");
    if !binding_path.is_file() {
        File::create(&binding_path)?
            .write_all(include_bytes!("../../res/actions_binding_oculus.json"))?;
@@ -11,13 +11,15 @@ use vulkano::format::Format;
 use vulkano::image::view::ImageView;
 use vulkano::image::ImageLayout;

-use crate::backend::overlay::{OverlayData, OverlayRenderer, OverlayState, SplitOverlayBackend};
+use crate::backend::overlay::{
+    FrameTransform, OverlayData, OverlayRenderer, OverlayState, SplitOverlayBackend, Z_ORDER_LINES,
+};
 use crate::graphics::WlxGraphics;
 use crate::state::AppState;

 use super::overlay::OpenVrOverlayData;

-static AUTO_INCREMENT: AtomicUsize = AtomicUsize::new(1);
+static LINE_AUTO_INCREMENT: AtomicUsize = AtomicUsize::new(1);

 pub(super) struct LinePool {
    lines: IdMap<usize, OverlayData<OpenVrOverlayData>>,
@@ -59,7 +61,7 @@ impl LinePool {
    }

    pub fn allocate(&mut self) -> usize {
-        let id = AUTO_INCREMENT.fetch_add(1, Ordering::Relaxed);
+        let id = LINE_AUTO_INCREMENT.fetch_add(1, Ordering::Relaxed);

        let mut data = OverlayData::<OpenVrOverlayData> {
            state: OverlayState {
@@ -80,7 +82,7 @@ impl LinePool {
            },
            ..Default::default()
        };
-        data.state.z_order = 69;
+        data.state.z_order = Z_ORDER_LINES;
        data.state.dirty = true;

        self.lines.insert(id, data);
@@ -189,7 +191,10 @@ 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())
+    fn frame_transform(&mut self) -> Option<FrameTransform> {
+        Some(FrameTransform {
+            extent: self.view.image().extent(),
+            ..Default::default()
+        })
    }
 }
@@ -4,12 +4,12 @@ use anyhow::bail;
 use json::{array, object};
 use ovr_overlay::applications::ApplicationsManager;

-use crate::config_io::CONFIG_ROOT_PATH;
+use crate::config_io;

 const APP_KEY: &str = "galister.wlxoverlay-s";

 pub(super) fn install_manifest(app_mgr: &mut ApplicationsManager) -> anyhow::Result<()> {
-    let manifest_path = CONFIG_ROOT_PATH.join("wlx-overlay-s.vrmanifest");
+    let manifest_path = config_io::get_config_root().join("wlx-overlay-s.vrmanifest");

    let appimage_path = std::env::var("APPIMAGE");
    let executable_pathbuf = std::env::current_exe()?;
@@ -76,7 +76,7 @@ pub(super) fn install_manifest(app_mgr: &mut ApplicationsManager) -> anyhow::Res
 }

 pub(super) fn uninstall_manifest(app_mgr: &mut ApplicationsManager) -> anyhow::Result<()> {
-    let manifest_path = CONFIG_ROOT_PATH.join("wlx-overlay-s.vrmanifest");
+    let manifest_path = config_io::get_config_root().join("wlx-overlay-s.vrmanifest");

    if let Ok(true) = app_mgr.is_application_installed(APP_KEY) {
        if let Err(e) = app_mgr.remove_application_manifest(&manifest_path) {
@@ -42,6 +42,9 @@ use crate::{
    state::AppState,
 };

+#[cfg(feature = "wayvr")]
+use crate::{gui::modular::button::WayVRAction, overlays::wayvr::wayvr_action};
+
 pub mod helpers;
 pub mod input;
 pub mod lines;
@@ -121,10 +124,6 @@ pub fn openvr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
    let mut playspace = playspace::PlayspaceMover::new();
    playspace.playspace_changed(&mut compositor_mgr, &mut chaperone_mgr);

-    #[cfg(feature = "osc")]
-    let mut osc_sender =
-        crate::backend::osc::OscSender::new(state.session.config.osc_out_port).ok();
-
    set_action_manifest(&mut input_mgr)?;

    let mut input_source = OpenVrInputSource::new(&mut input_mgr)?;
@@ -262,6 +261,10 @@ pub fn openvr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
                        overlays.show_hide(&mut state);
                    }
                },
+                #[cfg(feature = "wayvr")]
+                TaskType::WayVR(action) => {
+                    wayvr_action(&mut state, &mut overlays, &action);
+                }
            }
        }

@@ -274,7 +277,7 @@ pub fn openvr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
            &mut system_mgr,
            &mut state,
        );
-        state.input_state.post_update();
+        state.input_state.post_update(&state.session);

        if state
            .input_state
@@ -286,6 +289,16 @@ pub fn openvr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
            overlays.show_hide(&mut state);
        }

+        #[cfg(feature = "wayvr")]
+        if state
+            .input_state
+            .pointers
+            .iter()
+            .any(|p| p.now.toggle_dashboard && !p.before.toggle_dashboard)
+        {
+            wayvr_action(&mut state, &mut overlays, &WayVRAction::ToggleDashboard);
+        }
+
        overlays
            .iter_mut()
            .for_each(|o| o.state.auto_movement(&mut state));
@@ -316,10 +329,17 @@ pub fn openvr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
        }

        #[cfg(feature = "osc")]
-        if let Some(ref mut sender) = osc_sender {
-            let _ = sender.send_params(&overlays);
+        if let Some(ref mut sender) = state.osc_sender {
+            let _ = sender.send_params(&overlays, &state.input_state.devices);
        };

+        #[cfg(feature = "wayvr")]
+        if let Err(e) =
+            crate::overlays::wayvr::tick_events::<OpenVrOverlayData>(&mut state, &mut overlays)
+        {
+            log::error!("WayVR tick_events failed: {:?}", e);
+        }
+
        log::trace!("Rendering frame");

        for o in overlays.iter_mut() {
@@ -334,6 +354,11 @@ pub fn openvr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
            .iter_mut()
            .for_each(|o| o.after_render(universe.clone(), &mut overlay_mgr, &state.graphics));

+        #[cfg(feature = "wayvr")]
+        if let Some(wayvr) = &state.wayvr {
+            wayvr.borrow_mut().data.tick_finish()?;
+        }
+
        // chaperone

        // close font handles?
@@ -188,7 +188,7 @@ impl OverlayData<OpenVrOverlayData> {
    }

    pub(super) fn upload_transform(
-        &self,
+        &mut self,
        universe: ETrackingUniverseOrigin,
        overlay: &mut OverlayManager,
    ) {
@@ -197,7 +197,14 @@ impl OverlayData<OpenVrOverlayData> {
            return;
        };

-        let transform = Matrix3x4::from_affine(&self.state.transform);
+        let effective = self.state.transform
+            * self
+                .backend
+                .frame_transform()
+                .map(|f| f.transform)
+                .unwrap_or_default();
+
+        let transform = Matrix3x4::from_affine(&effective);

        if let Err(e) = overlay.set_transform_absolute(handle, universe, &transform) {
            log::error!(
@@ -5,7 +5,7 @@ use std::{
 };

 use glam::{bool, Affine3A, Quat, Vec3};
-use libmonado_rs::{Device, Monado};
+use libmonado as mnd;
 use openxr::{self as xr, Quaternionf, Vector3f};
 use serde::{Deserialize, Serialize};

@@ -154,6 +154,7 @@ pub(super) struct OpenXrHandSource {
    action_grab: CustomClickAction,
    action_alt_click: CustomClickAction,
    action_show_hide: CustomClickAction,
+    action_toggle_dashboard: CustomClickAction,
    action_space_drag: CustomClickAction,
    action_space_rotate: CustomClickAction,
    action_space_reset: CustomClickAction,
@@ -228,7 +229,7 @@ impl OpenXrInputSource {
    }

    fn update_device_battery_status(
-        device: &mut Device,
+        device: &mut mnd::Device,
        role: TrackedDeviceRole,
        app: &mut AppState,
    ) {
@@ -250,17 +251,23 @@ impl OpenXrInputSource {
        }
    }

-    pub fn update_devices(&mut self, app: &mut AppState, monado: &mut Monado) {
+    pub fn update_devices(&mut self, app: &mut AppState, monado: &mut mnd::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),
+            (mnd::DeviceRole::Head, TrackedDeviceRole::Hmd),
+            (mnd::DeviceRole::Eyes, TrackedDeviceRole::None),
+            (mnd::DeviceRole::Left, TrackedDeviceRole::LeftHand),
+            (mnd::DeviceRole::Right, TrackedDeviceRole::RightHand),
+            (mnd::DeviceRole::Gamepad, TrackedDeviceRole::None),
+            (
+                mnd::DeviceRole::HandTrackingLeft,
+                TrackedDeviceRole::LeftHand,
+            ),
+            (
+                mnd::DeviceRole::HandTrackingRight,
+                TrackedDeviceRole::RightHand,
+            ),
        ];
        let mut seen = Vec::<u32>::with_capacity(32);
        for (mnd_role, wlx_role) in roles {
@@ -275,7 +282,7 @@ impl OpenXrInputSource {
        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 {
+                    let role = if device.name_id >= 4 && device.name_id <= 8 {
                        TrackedDeviceRole::Tracker
                    } else {
                        TrackedDeviceRole::None
@@ -365,6 +372,12 @@ impl OpenXrHand {
            session,
        )?;

+        pointer.now.toggle_dashboard = self.source.action_toggle_dashboard.state(
+            pointer.before.toggle_dashboard,
+            xr,
+            session,
+        )?;
+
        pointer.now.click_modifier_middle = self.source.action_modifier_middle.state(
            pointer.before.click_modifier_middle,
            xr,
@@ -422,6 +435,7 @@ impl OpenXrHandSource {
            action_scroll,
            action_alt_click: CustomClickAction::new(action_set, "alt_click", side)?,
            action_show_hide: CustomClickAction::new(action_set, "show_hide", side)?,
+            action_toggle_dashboard: CustomClickAction::new(action_set, "toggle_dashboard", 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)?,
@@ -578,6 +592,14 @@ fn suggest_bindings(instance: &xr::Instance, hands: &[&OpenXrHandSource; 2]) ->
            instance
        );

+        add_custom!(
+            profile.toggle_dashboard,
+            &hands[0].action_toggle_dashboard,
+            &hands[1].action_toggle_dashboard,
+            bindings,
+            instance
+        );
+
        add_custom!(
            profile.space_drag,
            &hands[0].action_space_drag,
@@ -655,6 +677,7 @@ struct OpenXrActionConfProfile {
    grab: Option<OpenXrActionConfAction>,
    alt_click: Option<OpenXrActionConfAction>,
    show_hide: Option<OpenXrActionConfAction>,
+    toggle_dashboard: Option<OpenXrActionConfAction>,
    space_drag: Option<OpenXrActionConfAction>,
    space_rotate: Option<OpenXrActionConfAction>,
    space_reset: Option<OpenXrActionConfAction>,
@@ -21,7 +21,7 @@ use super::{
    CompositionLayer, XrState,
 };

-static AUTO_INCREMENT: AtomicUsize = AtomicUsize::new(1);
+static LINE_AUTO_INCREMENT: AtomicUsize = AtomicUsize::new(1);
 pub(super) const LINE_WIDTH: f32 = 0.002;

 pub(super) struct LinePool {
@@ -66,7 +66,7 @@ impl LinePool {
        xr: &XrState,
        graphics: Arc<WlxGraphics>,
    ) -> anyhow::Result<usize> {
-        let id = AUTO_INCREMENT.fetch_add(1, Ordering::Relaxed);
+        let id = LINE_AUTO_INCREMENT.fetch_add(1, Ordering::Relaxed);

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

        for line in self.lines.values_mut() {
@@ -9,7 +9,7 @@ use std::{
 };

 use glam::{Affine3A, Vec3};
-use libmonado_rs::Monado;
+use libmonado::Monado;
 use openxr as xr;
 use skybox::create_skybox;
 use vulkano::{command_buffer::CommandBufferUsage, Handle, VulkanObject};
@@ -31,6 +31,9 @@ use crate::{
    state::AppState,
 };

+#[cfg(feature = "wayvr")]
+use crate::{gui::modular::button::WayVRAction, overlays::wayvr::wayvr_action};
+
 mod helpers;
 mod input;
 mod lines;
@@ -63,15 +66,23 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
        }
    };

-    let environment_blend_mode =
-        xr_instance.enumerate_environment_blend_modes(system, VIEW_TYPE)?[0];
-    log::info!("Using environment blend mode: {:?}", environment_blend_mode);
-
    let mut app_state = {
        let graphics = WlxGraphics::new_openxr(xr_instance.clone(), system)?;
        AppState::from_graphics(graphics)?
    };

+    let environment_blend_mode = {
+        let modes = xr_instance.enumerate_environment_blend_modes(system, VIEW_TYPE)?;
+        if modes.contains(&xr::EnvironmentBlendMode::ALPHA_BLEND)
+            && app_state.session.config.use_passthrough
+        {
+            xr::EnvironmentBlendMode::ALPHA_BLEND
+        } else {
+            modes[0]
+        }
+    };
+    log::info!("Using environment blend mode: {:?}", environment_blend_mode);
+
    if show_by_default {
        app_state.tasks.enqueue_at(
            TaskType::System(SystemTask::ShowHide),
@@ -98,10 +109,6 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
            .ok()
    });

-    #[cfg(feature = "osc")]
-    let mut osc_sender =
-        crate::backend::osc::OscSender::new(app_state.session.config.osc_out_port).ok();
-
    let (session, mut frame_wait, mut frame_stream) = unsafe {
        let raw_session = helpers::create_overlay_session(
            &xr_instance,
@@ -138,7 +145,11 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
        stage_offset: Affine3A::IDENTITY,
    };

-    let mut skybox = create_skybox(&xr_state, &app_state);
+    let mut skybox = if environment_blend_mode == xr::EnvironmentBlendMode::OPAQUE {
+        create_skybox(&xr_state, &app_state)
+    } else {
+        None
+    };

    let pointer_lines = [
        lines.allocate(&xr_state, app_state.graphics.clone())?,
@@ -209,7 +220,7 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
                        if main_session_visible {
                            log::debug!("Destroying skybox.");
                            skybox = None;
-                        } else {
+                        } else if environment_blend_mode == xr::EnvironmentBlendMode::OPAQUE {
                            log::debug!("Allocating skybox.");
                            skybox = create_skybox(&xr_state, &app_state);
                        }
@@ -265,7 +276,7 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),

        app_state.input_state.pre_update();
        input_source.update(&xr_state, &mut app_state)?;
-        app_state.input_state.post_update();
+        app_state.input_state.post_update(&app_state.session);

        if app_state
            .input_state
@@ -276,6 +287,16 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
            overlays.show_hide(&mut app_state);
        }

+        #[cfg(feature = "wayvr")]
+        if app_state
+            .input_state
+            .pointers
+            .iter()
+            .any(|p| p.now.toggle_dashboard && !p.before.toggle_dashboard)
+        {
+            wayvr_action(&mut app_state, &mut overlays, &WayVRAction::ToggleDashboard);
+        }
+
        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(
@@ -290,8 +311,8 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
        }

        #[cfg(feature = "osc")]
-        if let Some(ref mut sender) = osc_sender {
-            let _ = sender.send_params(&overlays);
+        if let Some(ref mut sender) = app_state.osc_sender {
+            let _ = sender.send_params(&overlays, &app_state.input_state.devices);
        };

        let (_, views) = xr_state.session.locate_views(
@@ -360,6 +381,13 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
            }
        }

+        #[cfg(feature = "wayvr")]
+        if let Err(e) =
+            crate::overlays::wayvr::tick_events::<OpenXrOverlayData>(&mut app_state, &mut overlays)
+        {
+            log::error!("WayVR tick_events failed: {:?}", e);
+        }
+
        for o in overlays.iter_mut() {
            if !o.state.want_visible {
                continue;
@@ -394,6 +422,11 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
            layers.push((0.0, maybe_layer));
        }

+        #[cfg(feature = "wayvr")]
+        if let Some(wayvr) = &app_state.wayvr {
+            wayvr.borrow_mut().data.tick_finish()?;
+        }
+
        command_buffer.build_and_execute_now()?;

        layers.sort_by(|a, b| b.0.total_cmp(&a.0));
@@ -451,6 +484,7 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
                TaskType::DropOverlay(sel) => {
                    if let Some(o) = overlays.mut_by_selector(&sel) {
                        if o.state.birthframe < cur_frame {
+                            log::debug!("{}: destroy", o.state.name);
                            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));
@@ -477,6 +511,10 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
                    }
                    _ => {}
                },
+                #[cfg(feature = "wayvr")]
+                TaskType::WayVR(action) => {
+                    wayvr_action(&mut app_state, &mut overlays, &action);
+                }
            }
        }

@@ -12,6 +12,9 @@
 // -- space_drag --
 // move your stage (playspace drag)
 //
+// -- toggle_dashboard --
+// run or toggle visibility of a previously configured WayVR-compatible dashboard
+//
 // -- space_rotate --
 // rotate your stage (playspace rotate, WIP)
 //
@@ -127,6 +130,10 @@
      left: "/user/hand/left/input/thumbstick/y",
      right: "/user/hand/right/input/thumbstick/y"
    },
+		toggle_dashboard: {
+			double_click: false,
+			right: "/user/hand/right/input/system/click",
+		},
    show_hide: {
      double_click: true,
      left: "/user/hand/left/input/b/click",
@@ -27,7 +27,7 @@ impl OverlayData<OpenXrOverlayData> {
        &'a mut self,
        xr: &'a XrState,
        command_buffer: &mut WlxCommandBuffer,
-    ) -> anyhow::Result<CompositionLayer> {
+    ) -> anyhow::Result<CompositionLayer<'a>> {
        if let Some(new_view) = self.view() {
            self.data.last_view = Some(new_view);
        }
@@ -39,7 +39,8 @@ impl OverlayData<OpenXrOverlayData> {
            return Ok(CompositionLayer::None);
        };

-        let extent = self.extent().unwrap(); // want panic
+        let frame_transform = self.frame_transform().unwrap(); // want panic
+        let extent = frame_transform.extent;

        let data = match self.data.swapchain {
            Some(ref mut data) => data,
@@ -65,19 +66,21 @@ impl OverlayData<OpenXrOverlayData> {

        let sub_image = data.acquire_present_release(command_buffer, my_view, self.state.alpha)?;

+        let transform = self.state.transform * frame_transform.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();
+            let major = transform.matrix3.col(0).length();
            (major, major * aspect_ratio)
        } else {
-            let major = self.state.transform.matrix3.col(1).length();
+            let major = transform.matrix3.col(1).length();
            (major / aspect_ratio, major)
        };

        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 quat = helpers::transform_to_norm_quat(&transform);
+            let center_point = 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));
@@ -93,7 +96,7 @@ impl OverlayData<OpenXrOverlayData> {
                .aspect_ratio(aspect_ratio);
            Ok(CompositionLayer::Cylinder(cylinder))
        } else {
-            let posef = helpers::transform_to_posef(&self.state.transform);
+            let posef = helpers::transform_to_posef(&transform);
            let quad = xr::CompositionLayerQuad::new()
                .layer_flags(CompositionLayerFlags::BLEND_TEXTURE_SOURCE_ALPHA)
                .pose(posef)
@@ -1,5 +1,5 @@
 use glam::{Affine3A, Quat, Vec3A};
-use libmonado_rs::{Monado, Pose, ReferenceSpaceType};
+use libmonado::{Monado, Pose, ReferenceSpaceType};

 use crate::{
    backend::{common::OverlayContainer, input::InputState},
@@ -7,7 +7,7 @@ use vulkano::{command_buffer::CommandBufferUsage, image::view::ImageView};

 use crate::{
    backend::openxr::{helpers::translation_rotation_to_posef, swapchain::SwapchainOpts},
-    config_io::CONFIG_ROOT_PATH,
+    config_io,
    graphics::{dds::WlxCommandBufferDds, format_is_srgb, WlxCommandBuffer},
    state::AppState,
 };
@@ -35,7 +35,7 @@ impl Skybox {
                break 'custom_tex;
            }

-            let real_path = CONFIG_ROOT_PATH.join(&*app.session.config.skybox_texture);
+            let real_path = config_io::get_config_root().join(&*app.session.config.skybox_texture);
            let Ok(f) = File::open(real_path) else {
                log::warn!(
                    "Could not open custom skybox texture at: {}",
@@ -74,7 +74,7 @@ impl Skybox {
        xr: &'a XrState,
        hmd: Affine3A,
        command_buffer: &mut WlxCommandBuffer,
-    ) -> anyhow::Result<Vec<CompositionLayer>> {
+    ) -> anyhow::Result<Vec<CompositionLayer<'a>>> {
        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 {
@@ -8,10 +8,13 @@ use rosc::{OscMessage, OscPacket, OscType};

 use crate::overlays::{keyboard::KEYBOARD_NAME, watch::WATCH_NAME};

-use super::common::OverlayContainer;
+use crate::backend::input::TrackedDeviceRole;
+
+use super::{common::OverlayContainer, input::TrackedDevice};

 pub struct OscSender {
-    last_sent: Instant,
+    last_sent_overlay: Instant,
+    last_sent_battery: Instant,
    upstream: UdpSocket,
 }

@@ -29,7 +32,8 @@ impl OscSender {

        Ok(Self {
            upstream,
-            last_sent: Instant::now(),
+            last_sent_overlay: Instant::now(),
+            last_sent_battery: Instant::now(),
        })
    }

@@ -46,49 +50,133 @@ impl OscSender {
        Ok(())
    }

-    pub fn send_params<D>(&mut self, overlays: &OverlayContainer<D>) -> anyhow::Result<()>
+    pub fn send_params<D>(
+        &mut self,
+        overlays: &OverlayContainer<D>,
+        devices: &Vec<TrackedDevice>,
+    ) -> anyhow::Result<()>
    where
        D: Default,
    {
-        if self.last_sent.elapsed().as_millis() < 100 {
-            return Ok(());
-        }
+        // send overlay data every 0.1 seconds
+        if self.last_sent_overlay.elapsed().as_millis() >= 100 {
+            self.last_sent_overlay = Instant::now();

-        let mut num_overlays = 0;
-        let mut has_keyboard = false;
-        let mut has_wrist = false;
+            let mut num_overlays = 0;
+            let mut has_keyboard = false;
+            let mut has_wrist = false;

-        for o in overlays.iter() {
-            if !o.state.want_visible {
-                continue;
-            }
-            match o.state.name.as_ref() {
-                WATCH_NAME => has_wrist = true,
-                KEYBOARD_NAME => has_keyboard = true,
-                _ => {
-                    if o.state.interactable {
-                        num_overlays += 1
+            for o in overlays.iter() {
+                if !o.state.want_visible {
+                    continue;
+                }
+                match o.state.name.as_ref() {
+                    WATCH_NAME => has_wrist = true,
+                    KEYBOARD_NAME => has_keyboard = true,
+                    _ => {
+                        if o.state.interactable {
+                            num_overlays += 1
+                        }
                    }
                }
            }
+
+            self.send_message(
+                "/avatar/parameters/isOverlayOpen".into(),
+                vec![OscType::Bool(num_overlays > 0)],
+            )?;
+            self.send_message(
+                "/avatar/parameters/isKeyboardOpen".into(),
+                vec![OscType::Bool(has_keyboard)],
+            )?;
+            self.send_message(
+                "/avatar/parameters/isWristVisible".into(),
+                vec![OscType::Bool(has_wrist)],
+            )?;
+            self.send_message(
+                "/avatar/parameters/openOverlayCount".into(),
+                vec![OscType::Int(num_overlays)],
+            )?;
        }

-        self.send_message(
-            "/avatar/parameters/isOverlayOpen".into(),
-            vec![OscType::Bool(num_overlays > 0)],
-        )?;
-        self.send_message(
-            "/avatar/parameters/isKeyboardOpen".into(),
-            vec![OscType::Bool(has_keyboard)],
-        )?;
-        self.send_message(
-            "/avatar/parameters/isWristVisible".into(),
-            vec![OscType::Bool(has_wrist)],
-        )?;
-        self.send_message(
-            "/avatar/parameters/openOverlayCount".into(),
-            vec![OscType::Int(num_overlays)],
-        )?;
+        // send battery levels every 10 seconds
+        if self.last_sent_battery.elapsed().as_millis() >= 10000 {
+            self.last_sent_battery = Instant::now();
+
+            let mut tracker_count: i8 = 0;
+            let mut controller_count: i8 = 0;
+            let mut tracker_total_bat = 0.0;
+            let mut controller_total_bat = 0.0;
+
+            for device in devices {
+                let tracker_param;
+
+                // soc is the battery level (set to device status.charge)
+                let level = device.soc.unwrap_or(-1.0);
+                let parameter = match device.role {
+                    TrackedDeviceRole::None => continue,
+                    TrackedDeviceRole::Hmd => {
+                        // legacy OVR Toolkit style (int)
+                        // as of 20 Nov 2024 OVR Toolkit uses int 0-100, but this may change in a future update.
+                        //TODO: update this once their implementation matches their docs
+                        self.send_message(
+                            "/avatar/parameters/hmdBattery".into(),
+                            vec![OscType::Int((level * 100.0f32).round() as i32)],
+                        )?;
+
+                        "headset"
+                    }
+                    TrackedDeviceRole::LeftHand => {
+                        controller_count += 1;
+                        controller_total_bat += level;
+                        "leftController"
+                    }
+                    TrackedDeviceRole::RightHand => {
+                        controller_count += 1;
+                        controller_total_bat += level;
+                        "rightController"
+                    }
+                    TrackedDeviceRole::Tracker => {
+                        tracker_count += 1;
+                        tracker_total_bat += level;
+                        tracker_param = format!("tracker{tracker_count}");
+                        tracker_param.as_str()
+                    }
+                };
+
+                // send device battery parameters
+                self.send_message(
+                    format!("/avatar/parameters/{parameter}Battery"),
+                    vec![OscType::Float(level)],
+                )?;
+                self.send_message(
+                    format!("/avatar/parameters/{parameter}Charging"),
+                    vec![OscType::Bool(device.charging)],
+                )?;
+            }
+
+            // send average controller and tracker battery parameters
+            self.send_message(
+                String::from("/avatar/parameters/averageControllerBattery"),
+                vec![OscType::Float(
+                    controller_total_bat / controller_count as f32,
+                )],
+            )?;
+            self.send_message(
+                String::from("/avatar/parameters/averageTrackerBattery"),
+                vec![OscType::Float(tracker_total_bat / tracker_count as f32)],
+            )?;
+        }
+
+        Ok(())
+    }
+
+    pub fn send_single_param(
+        &mut self,
+        parameter: String,
+        values: Vec<OscType>,
+    ) -> anyhow::Result<()> {
+        self.send_message(parameter, values)?;

        Ok(())
    }
@@ -8,21 +8,35 @@ use std::{

 use anyhow::Ok;
 use glam::{Affine2, Affine3A, Mat3A, Quat, Vec2, Vec3, Vec3A};
+use serde::Deserialize;
 use vulkano::image::view::ImageView;

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

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

-static AUTO_INCREMENT: AtomicUsize = AtomicUsize::new(0);
+static OVERLAY_AUTO_INCREMENT: AtomicUsize = AtomicUsize::new(0);

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

+#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Default)]
+pub struct OverlayID(pub usize);
+
+pub const Z_ORDER_TOAST: u32 = 70;
+pub const Z_ORDER_LINES: u32 = 69;
+pub const Z_ORDER_WATCH: u32 = 68;
+pub const Z_ORDER_ANCHOR: u32 = 67;
+pub const Z_ORDER_DEFAULT: u32 = 0;
+pub const Z_ORDER_DASHBOARD: u32 = Z_ORDER_DEFAULT;
+
 pub struct OverlayState {
-    pub id: usize,
+    pub id: OverlayID,
    pub name: Arc<str>,
    pub want_visible: bool,
    pub show_hide: bool,
@@ -30,6 +44,7 @@ pub struct OverlayState {
    pub interactable: bool,
    pub recenter: bool,
    pub anchored: bool,
+    pub keyboard_focus: Option<KeyboardFocus>,
    pub dirty: bool,
    pub alpha: f32,
    pub z_order: u32,
@@ -48,7 +63,7 @@ pub struct OverlayState {
 impl Default for OverlayState {
    fn default() -> Self {
        OverlayState {
-            id: AUTO_INCREMENT.fetch_add(1, Ordering::Relaxed),
+            id: OverlayID(OVERLAY_AUTO_INCREMENT.fetch_add(1, Ordering::Relaxed)),
            name: Arc::from(""),
            want_visible: false,
            show_hide: false,
@@ -56,9 +71,10 @@ impl Default for OverlayState {
            recenter: false,
            interactable: false,
            anchored: false,
+            keyboard_focus: None,
            dirty: true,
            alpha: 1.0,
-            z_order: 0,
+            z_order: Z_ORDER_DEFAULT,
            relative_to: RelativeTo::None,
            curvature: None,
            spawn_scale: 1.0,
@@ -224,8 +240,8 @@ 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 frame_transform(&mut self) -> Option<FrameTransform> {
+        self.backend.frame_transform()
    }
    pub fn set_visible(&mut self, app: &mut AppState, visible: bool) -> anyhow::Result<()> {
        let old_visible = self.state.want_visible;
@@ -241,6 +257,12 @@ where
    }
 }

+#[derive(Default)]
+pub struct FrameTransform {
+    pub extent: [u32; 3],
+    pub transform: Affine3A,
+}
+
 pub trait OverlayRenderer {
    /// Called once, before the first frame is rendered
    fn init(&mut self, app: &mut AppState) -> anyhow::Result<()>;
@@ -254,7 +276,7 @@ pub trait OverlayRenderer {
    /// Used for creating swapchains.
    ///
    /// Muse not be None if view() is also not None
-    fn extent(&mut self) -> Option<[u32; 3]>;
+    fn frame_transform(&mut self) -> Option<FrameTransform>;
 }

 pub struct FallbackRenderer;
@@ -275,7 +297,7 @@ impl OverlayRenderer for FallbackRenderer {
    fn view(&mut self) -> Option<Arc<ImageView>> {
        None
    }
-    fn extent(&mut self) -> Option<[u32; 3]> {
+    fn frame_transform(&mut self) -> Option<FrameTransform> {
        None
    }
 }
@@ -332,8 +354,8 @@ impl OverlayRenderer for SplitOverlayBackend {
    fn view(&mut self) -> Option<Arc<ImageView>> {
        self.renderer.view()
    }
-    fn extent(&mut self) -> Option<[u32; 3]> {
-        self.renderer.extent()
+    fn frame_transform(&mut self) -> Option<FrameTransform> {
+        self.renderer.frame_transform()
    }
 }
 impl InteractionHandler for SplitOverlayBackend {
@@ -9,6 +9,9 @@ use serde::Deserialize;

 use crate::state::AppState;

+#[cfg(feature = "wayvr")]
+use crate::gui::modular::button::WayVRAction;
+
 use super::{
    common::OverlaySelector,
    overlay::{OverlayBackend, OverlayState},
@@ -59,6 +62,8 @@ pub enum TaskType {
    CreateOverlay(OverlaySelector, Box<CreateOverlayTask>),
    DropOverlay(OverlaySelector),
    System(SystemTask),
+    #[cfg(feature = "wayvr")]
+    WayVR(WayVRAction),
 }

 #[derive(Deserialize, Clone, Copy)]
@@ -30,7 +30,7 @@ use crate::{

 use super::{
    input::{TrackedDevice, TrackedDeviceRole},
-    overlay::OverlayRenderer,
+    overlay::{OverlayID, OverlayRenderer},
 };

 static LAST_SIZE: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
@@ -127,7 +127,7 @@ pub fn uidev_run(panel_name: &str) -> anyhow::Result<()> {
        panel_name,
    )?);

-    let watch_path = config_io::CONFIG_ROOT_PATH.join(format!("{}.yaml", panel_name));
+    let watch_path = config_io::get_config_root().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();
@@ -301,17 +301,17 @@ fn add_dummy_devices(app: &mut AppState) {
 fn add_dummy_screens(app: &mut AppState) {
    app.screens.push(ScreenMeta {
        name: "HDMI-A-1".into(),
-        id: 0,
+        id: OverlayID(0),
        native_handle: 0,
    });
    app.screens.push(ScreenMeta {
        name: "DP-2".into(),
-        id: 0,
+        id: OverlayID(0),
        native_handle: 0,
    });
    app.screens.push(ScreenMeta {
        name: "DP-3".into(),
-        id: 0,
+        id: OverlayID(0),
        native_handle: 0,
    });
 }
@@ -0,0 +1,255 @@
+use std::{io::Read, os::unix::net::UnixStream, path::PathBuf, sync::Arc};
+
+use smithay::{
+    backend::input::Keycode,
+    input::{keyboard::KeyboardHandle, pointer::PointerHandle},
+    reexports::wayland_server,
+    utils::SerialCounter,
+};
+
+use crate::backend::wayvr::{ExternalProcessRequest, WayVRTask};
+
+use super::{
+    comp::{self, ClientState},
+    display, process, ProcessWayVREnv,
+};
+
+pub struct WayVRClient {
+    pub client: wayland_server::Client,
+    pub display_handle: display::DisplayHandle,
+    pub pid: u32,
+}
+
+pub struct WayVRCompositor {
+    pub state: comp::Application,
+    pub seat_keyboard: KeyboardHandle<comp::Application>,
+    pub seat_pointer: PointerHandle<comp::Application>,
+    pub serial_counter: SerialCounter,
+    pub wayland_env: super::WaylandEnv,
+
+    display: wayland_server::Display<comp::Application>,
+    listener: wayland_server::ListeningSocket,
+
+    toplevel_surf_count: u32, // for logging purposes
+
+    pub clients: Vec<WayVRClient>,
+}
+
+fn get_wayvr_env_from_pid(pid: i32) -> anyhow::Result<ProcessWayVREnv> {
+    let path = format!("/proc/{}/environ", pid);
+    let mut env_data = String::new();
+    std::fs::File::open(path)?.read_to_string(&mut env_data)?;
+
+    let lines: Vec<&str> = env_data.split('\0').filter(|s| !s.is_empty()).collect();
+
+    let mut env = ProcessWayVREnv {
+        display_auth: None,
+        display_name: None,
+    };
+
+    for line in lines {
+        if let Some((key, value)) = line.split_once('=') {
+            if key == "WAYVR_DISPLAY_AUTH" {
+                env.display_auth = Some(String::from(value));
+            } else if key == "WAYVR_DISPLAY_NAME" {
+                env.display_name = Some(String::from(value));
+            }
+        }
+    }
+
+    Ok(env)
+}
+
+impl WayVRCompositor {
+    pub fn new(
+        state: comp::Application,
+        display: wayland_server::Display<comp::Application>,
+        seat_keyboard: KeyboardHandle<comp::Application>,
+        seat_pointer: PointerHandle<comp::Application>,
+    ) -> anyhow::Result<Self> {
+        let (wayland_env, listener) = create_wayland_listener()?;
+
+        Ok(Self {
+            state,
+            display,
+            seat_keyboard,
+            seat_pointer,
+            listener,
+            wayland_env,
+            serial_counter: SerialCounter::new(),
+            clients: Vec::new(),
+            toplevel_surf_count: 0,
+        })
+    }
+
+    pub fn add_client(&mut self, client: WayVRClient) {
+        self.clients.push(client);
+    }
+
+    pub fn cleanup_clients(&mut self) {
+        self.clients.retain(|client| {
+            let Some(data) = client.client.get_data::<ClientState>() else {
+                return false;
+            };
+
+            if *data.disconnected.lock().unwrap() {
+                return false;
+            }
+
+            true
+        });
+    }
+
+    fn accept_connection(
+        &mut self,
+        stream: UnixStream,
+        displays: &mut display::DisplayVec,
+        processes: &mut process::ProcessVec,
+    ) -> anyhow::Result<()> {
+        let client = self
+            .display
+            .handle()
+            .insert_client(stream, Arc::new(comp::ClientState::default()))
+            .unwrap();
+
+        let creds = client.get_credentials(&self.display.handle())?;
+
+        let process_env = get_wayvr_env_from_pid(creds.pid)?;
+
+        // Find suitable auth key from the process list
+        for p in processes.vec.iter().flatten() {
+            if let process::Process::Managed(process) = &p.obj {
+                if let Some(auth_key) = &process_env.display_auth {
+                    // Find process with matching auth key
+                    if process.auth_key.as_str() == auth_key {
+                        // Check if display handle is valid
+                        if displays.get(&process.display_handle).is_some() {
+                            // Add client
+                            self.add_client(WayVRClient {
+                                client,
+                                display_handle: process.display_handle,
+                                pid: creds.pid as u32,
+                            });
+                            return Ok(());
+                        }
+                    }
+                }
+            }
+        }
+
+        // This is a new process which we didn't met before.
+        // Treat external processes exclusively (spawned by the user or external program)
+        log::warn!(
+            "External process ID {} connected to this Wayland server",
+            creds.pid
+        );
+
+        self.state
+            .wayvr_tasks
+            .send(WayVRTask::NewExternalProcess(ExternalProcessRequest {
+                env: process_env,
+                client,
+                pid: creds.pid as u32,
+            }));
+
+        Ok(())
+    }
+
+    fn accept_connections(
+        &mut self,
+        displays: &mut display::DisplayVec,
+        processes: &mut process::ProcessVec,
+    ) -> anyhow::Result<()> {
+        if let Some(stream) = self.listener.accept()? {
+            if let Err(e) = self.accept_connection(stream, displays, processes) {
+                log::error!("Failed to accept connection: {}", e);
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn tick_wayland(
+        &mut self,
+        displays: &mut display::DisplayVec,
+        processes: &mut process::ProcessVec,
+    ) -> anyhow::Result<()> {
+        if let Err(e) = self.accept_connections(displays, processes) {
+            log::error!("accept_connections failed: {}", e);
+        }
+
+        self.display.dispatch_clients(&mut self.state)?;
+        self.display.flush_clients()?;
+
+        let surf_count = self.state.xdg_shell.toplevel_surfaces().len() as u32;
+        if surf_count != self.toplevel_surf_count {
+            self.toplevel_surf_count = surf_count;
+            log::info!("Toplevel surface count changed: {}", surf_count);
+        }
+
+        Ok(())
+    }
+
+    pub fn send_key(&mut self, virtual_key: u32, down: bool) {
+        let state = if down {
+            smithay::backend::input::KeyState::Pressed
+        } else {
+            smithay::backend::input::KeyState::Released
+        };
+
+        self.seat_keyboard.input::<(), _>(
+            &mut self.state,
+            Keycode::new(virtual_key),
+            state,
+            self.serial_counter.next_serial(),
+            0,
+            |_, _, _| smithay::input::keyboard::FilterResult::Forward,
+        );
+    }
+}
+
+const STARTING_WAYLAND_ADDR_IDX: u32 = 20;
+
+fn export_display_number(display_num: u32) -> anyhow::Result<()> {
+    let mut path = std::env::var("XDG_RUNTIME_DIR")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| PathBuf::from("/tmp"));
+    path.push("wayvr.disp");
+    std::fs::write(path, format!("{}\n", display_num))?;
+    Ok(())
+}
+
+fn create_wayland_listener() -> anyhow::Result<(super::WaylandEnv, wayland_server::ListeningSocket)>
+{
+    let mut env = super::WaylandEnv {
+        display_num: STARTING_WAYLAND_ADDR_IDX,
+    };
+
+    let listener = loop {
+        let display_str = env.display_num_string();
+        log::debug!("Trying to open socket \"{}\"", display_str);
+        match wayland_server::ListeningSocket::bind(display_str.as_str()) {
+            Ok(listener) => {
+                log::debug!("Listening to {}", display_str);
+                break listener;
+            }
+            Err(e) => {
+                log::debug!(
+                    "Failed to open socket \"{}\" (reason: {}), trying next...",
+                    display_str,
+                    e
+                );
+
+                env.display_num += 1;
+                if env.display_num > STARTING_WAYLAND_ADDR_IDX + 20 {
+                    // Highly unlikely for the user to have 20 Wayland displays enabled at once. Return error instead.
+                    anyhow::bail!("Failed to create wayland-server socket")
+                }
+            }
+        }
+    };
+
+    let _ = export_display_number(env.display_num);
+
+    Ok((env, listener))
+}
@@ -0,0 +1,233 @@
+use smithay::backend::allocator::dmabuf::Dmabuf;
+use smithay::backend::renderer::gles::GlesRenderer;
+use smithay::backend::renderer::utils::on_commit_buffer_handler;
+use smithay::backend::renderer::ImportDma;
+use smithay::input::{Seat, SeatHandler, SeatState};
+use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel;
+use smithay::reexports::wayland_server;
+use smithay::reexports::wayland_server::protocol::{wl_buffer, wl_seat, wl_surface};
+use smithay::reexports::wayland_server::Resource;
+use smithay::wayland::buffer::BufferHandler;
+use smithay::wayland::dmabuf::{
+    DmabufFeedback, DmabufGlobal, DmabufHandler, DmabufState, ImportNotifier,
+};
+use smithay::wayland::output::OutputHandler;
+use smithay::wayland::shm::{ShmHandler, ShmState};
+use smithay::{
+    delegate_compositor, delegate_data_device, delegate_dmabuf, delegate_output, delegate_seat,
+    delegate_shm, delegate_xdg_shell,
+};
+use std::collections::HashSet;
+use std::os::fd::OwnedFd;
+use std::sync::{Arc, Mutex};
+
+use smithay::utils::Serial;
+use smithay::wayland::compositor::{
+    self, with_surface_tree_downward, SurfaceAttributes, TraversalAction,
+};
+
+use smithay::wayland::selection::data_device::{
+    ClientDndGrabHandler, DataDeviceHandler, DataDeviceState, ServerDndGrabHandler,
+};
+use smithay::wayland::selection::SelectionHandler;
+use smithay::wayland::shell::xdg::{
+    PopupSurface, PositionerState, ToplevelSurface, XdgShellHandler, XdgShellState,
+};
+use wayland_server::backend::{ClientData, ClientId, DisconnectReason};
+use wayland_server::protocol::wl_surface::WlSurface;
+use wayland_server::Client;
+
+use super::event_queue::SyncEventQueue;
+use super::WayVRTask;
+
+pub struct Application {
+    pub gles_renderer: GlesRenderer,
+    pub dmabuf_state: (DmabufState, DmabufGlobal, Option<DmabufFeedback>),
+    pub compositor: compositor::CompositorState,
+    pub xdg_shell: XdgShellState,
+    pub seat_state: SeatState<Application>,
+    pub shm: ShmState,
+    pub data_device: DataDeviceState,
+    pub wayvr_tasks: SyncEventQueue<WayVRTask>,
+    pub redraw_requests: HashSet<wayland_server::backend::ObjectId>,
+}
+
+impl Application {
+    pub fn check_redraw(&mut self, surface: &WlSurface) -> bool {
+        self.redraw_requests.remove(&surface.id())
+    }
+}
+
+impl compositor::CompositorHandler for Application {
+    fn compositor_state(&mut self) -> &mut compositor::CompositorState {
+        &mut self.compositor
+    }
+
+    fn client_compositor_state<'a>(
+        &self,
+        client: &'a Client,
+    ) -> &'a compositor::CompositorClientState {
+        &client.get_data::<ClientState>().unwrap().compositor_state
+    }
+
+    fn commit(&mut self, surface: &WlSurface) {
+        on_commit_buffer_handler::<Self>(surface);
+        self.redraw_requests.insert(surface.id());
+    }
+}
+
+impl SeatHandler for Application {
+    type KeyboardFocus = WlSurface;
+    type PointerFocus = WlSurface;
+    type TouchFocus = WlSurface;
+
+    fn seat_state(&mut self) -> &mut SeatState<Self> {
+        &mut self.seat_state
+    }
+
+    fn focus_changed(&mut self, _seat: &Seat<Self>, _focused: Option<&WlSurface>) {}
+    fn cursor_image(
+        &mut self,
+        _seat: &Seat<Self>,
+        _image: smithay::input::pointer::CursorImageStatus,
+    ) {
+    }
+}
+
+impl BufferHandler for Application {
+    fn buffer_destroyed(&mut self, _buffer: &wl_buffer::WlBuffer) {}
+}
+
+impl ClientDndGrabHandler for Application {}
+
+impl ServerDndGrabHandler for Application {
+    fn send(&mut self, _mime_type: String, _fd: OwnedFd, _seat: Seat<Self>) {}
+}
+
+impl DataDeviceHandler for Application {
+    fn data_device_state(&self) -> &DataDeviceState {
+        &self.data_device
+    }
+}
+
+impl SelectionHandler for Application {
+    type SelectionUserData = ();
+}
+
+#[derive(Default)]
+pub struct ClientState {
+    compositor_state: compositor::CompositorClientState,
+    pub disconnected: Arc<Mutex<bool>>,
+}
+
+impl ClientData for ClientState {
+    fn initialized(&self, client_id: ClientId) {
+        log::debug!("Client ID {:?} connected", client_id);
+    }
+
+    fn disconnected(&self, client_id: ClientId, reason: DisconnectReason) {
+        *self.disconnected.lock().unwrap() = true;
+        log::debug!(
+            "Client ID {:?} disconnected. Reason: {:?}",
+            client_id,
+            reason
+        );
+    }
+}
+
+impl AsMut<compositor::CompositorState> for Application {
+    fn as_mut(&mut self) -> &mut compositor::CompositorState {
+        &mut self.compositor
+    }
+}
+
+impl XdgShellHandler for Application {
+    fn xdg_shell_state(&mut self) -> &mut XdgShellState {
+        &mut self.xdg_shell
+    }
+
+    fn new_toplevel(&mut self, surface: ToplevelSurface) {
+        if let Some(client) = surface.wl_surface().client() {
+            self.wayvr_tasks
+                .send(WayVRTask::NewToplevel(client.id(), surface.clone()));
+        }
+        surface.with_pending_state(|state| {
+            state.states.set(xdg_toplevel::State::Activated);
+        });
+        surface.send_configure();
+    }
+
+    fn new_popup(&mut self, _surface: PopupSurface, _positioner: PositionerState) {
+        // Handle popup creation here
+    }
+
+    fn grab(&mut self, _surface: PopupSurface, _seat: wl_seat::WlSeat, _serial: Serial) {
+        // Handle popup grab here
+    }
+
+    fn reposition_request(
+        &mut self,
+        _surface: PopupSurface,
+        _positioner: PositionerState,
+        _token: u32,
+    ) {
+        // Handle popup reposition here
+    }
+}
+
+impl ShmHandler for Application {
+    fn shm_state(&self) -> &ShmState {
+        &self.shm
+    }
+}
+
+impl OutputHandler for Application {}
+
+impl DmabufHandler for Application {
+    fn dmabuf_state(&mut self) -> &mut DmabufState {
+        &mut self.dmabuf_state.0
+    }
+
+    fn dmabuf_imported(
+        &mut self,
+        _global: &DmabufGlobal,
+        dmabuf: Dmabuf,
+        notifier: ImportNotifier,
+    ) {
+        if self.gles_renderer.import_dmabuf(&dmabuf, None).is_ok() {
+            let _ = notifier.successful::<Application>();
+        } else {
+            notifier.failed();
+        }
+    }
+}
+
+delegate_dmabuf!(Application);
+delegate_xdg_shell!(Application);
+delegate_compositor!(Application);
+delegate_shm!(Application);
+delegate_seat!(Application);
+delegate_data_device!(Application);
+delegate_output!(Application);
+
+pub fn send_frames_surface_tree(surface: &wl_surface::WlSurface, time: u32) {
+    with_surface_tree_downward(
+        surface,
+        (),
+        |_, _, &()| TraversalAction::DoChildren(()),
+        |_surf, states, &()| {
+            // the surface may not have any user_data if it is a subsurface and has not
+            // yet been commited
+            for callback in states
+                .cached_state
+                .get::<SurfaceAttributes>()
+                .current()
+                .frame_callbacks
+                .drain(..)
+            {
+                callback.done(time);
+            }
+        },
+        |_, _, &()| true,
+    );
+}
@@ -0,0 +1,553 @@
+use std::{cell::RefCell, rc::Rc};
+
+use smithay::{
+    backend::renderer::{
+        element::{
+            surface::{render_elements_from_surface_tree, WaylandSurfaceRenderElement},
+            Kind,
+        },
+        gles::{ffi, GlesRenderer, GlesTexture},
+        utils::draw_render_elements,
+        Bind, Color32F, Frame, Renderer,
+    },
+    input,
+    utils::{Logical, Point, Rectangle, Size, Transform},
+    wayland::shell::xdg::ToplevelSurface,
+};
+use wayvr_ipc::packet_server;
+
+use crate::{
+    backend::{overlay::OverlayID, wayvr::time::get_millis},
+    gen_id,
+};
+
+use super::{
+    client::WayVRCompositor, comp::send_frames_surface_tree, egl_data, event_queue::SyncEventQueue,
+    process, smithay_wrapper, time, window, WayVRSignal,
+};
+
+fn generate_auth_key() -> String {
+    let uuid = uuid::Uuid::new_v4();
+    uuid.to_string()
+}
+
+#[derive(Debug)]
+pub struct DisplayWindow {
+    pub window_handle: window::WindowHandle,
+    pub toplevel: ToplevelSurface,
+    pub process_handle: process::ProcessHandle,
+}
+
+pub struct SpawnProcessResult {
+    pub auth_key: String,
+    pub child: std::process::Child,
+}
+
+#[derive(Debug)]
+pub enum DisplayTask {
+    ProcessCleanup(process::ProcessHandle),
+}
+
+const MAX_DISPLAY_SIZE: u16 = 8192;
+
+#[derive(Debug)]
+pub struct Display {
+    // Display info stuff
+    pub width: u16,
+    pub height: u16,
+    pub name: String,
+    pub visible: bool,
+    pub layout: packet_server::WvrDisplayWindowLayout,
+    pub overlay_id: Option<OverlayID>,
+    pub wants_redraw: bool,
+    pub primary: bool,
+    pub wm: Rc<RefCell<window::WindowManager>>,
+    pub displayed_windows: Vec<DisplayWindow>,
+    wayland_env: super::WaylandEnv,
+    last_pressed_time_ms: u64,
+    pub no_windows_since: Option<u64>,
+
+    // Render data stuff
+    gles_texture: GlesTexture, // TODO: drop texture
+    egl_image: khronos_egl::Image,
+    egl_data: Rc<egl_data::EGLData>,
+    pub dmabuf_data: egl_data::DMAbufData,
+
+    pub tasks: SyncEventQueue<DisplayTask>,
+}
+
+impl Drop for Display {
+    fn drop(&mut self) {
+        let _ = self
+            .egl_data
+            .egl
+            .destroy_image(self.egl_data.display, self.egl_image);
+    }
+}
+
+pub struct DisplayInitParams<'a> {
+    pub wm: Rc<RefCell<window::WindowManager>>,
+    pub renderer: &'a mut GlesRenderer,
+    pub egl_data: Rc<egl_data::EGLData>,
+    pub wayland_env: super::WaylandEnv,
+    pub width: u16,
+    pub height: u16,
+    pub name: &'a str,
+    pub primary: bool,
+}
+
+impl Display {
+    pub fn new(params: DisplayInitParams) -> anyhow::Result<Self> {
+        if params.width > MAX_DISPLAY_SIZE {
+            anyhow::bail!(
+                "display width ({}) is larger than {}",
+                params.width,
+                MAX_DISPLAY_SIZE
+            );
+        }
+
+        if params.height > MAX_DISPLAY_SIZE {
+            anyhow::bail!(
+                "display height ({}) is larger than {}",
+                params.height,
+                MAX_DISPLAY_SIZE
+            );
+        }
+
+        let tex_format = ffi::RGBA;
+        let internal_format = ffi::RGBA8;
+
+        let tex_id = params.renderer.with_context(|gl| {
+            smithay_wrapper::create_framebuffer_texture(
+                gl,
+                params.width as u32,
+                params.height as u32,
+                tex_format,
+                internal_format,
+            )
+        })?;
+
+        let egl_image = params.egl_data.create_egl_image(tex_id)?;
+        let dmabuf_data = params.egl_data.create_dmabuf_data(&egl_image)?;
+
+        let opaque = false;
+        let size = (params.width as i32, params.height as i32).into();
+        let gles_texture = unsafe {
+            GlesTexture::from_raw(params.renderer, Some(tex_format), opaque, tex_id, size)
+        };
+
+        Ok(Self {
+            egl_data: params.egl_data,
+            width: params.width,
+            height: params.height,
+            name: String::from(params.name),
+            primary: params.primary,
+            wayland_env: params.wayland_env,
+            wm: params.wm,
+            displayed_windows: Vec::new(),
+            dmabuf_data,
+            egl_image,
+            gles_texture,
+            last_pressed_time_ms: 0,
+            no_windows_since: None,
+            overlay_id: None,
+            tasks: SyncEventQueue::new(),
+            visible: true,
+            wants_redraw: true,
+            layout: packet_server::WvrDisplayWindowLayout::Tiling,
+        })
+    }
+
+    pub fn as_packet(&self, handle: DisplayHandle) -> packet_server::WvrDisplay {
+        packet_server::WvrDisplay {
+            width: self.width,
+            height: self.height,
+            name: self.name.clone(),
+            visible: self.visible,
+            handle: handle.as_packet(),
+        }
+    }
+
+    pub fn add_window(
+        &mut self,
+        window_handle: window::WindowHandle,
+        process_handle: process::ProcessHandle,
+        toplevel: &ToplevelSurface,
+    ) {
+        log::debug!("Attaching toplevel surface into display");
+        self.displayed_windows.push(DisplayWindow {
+            window_handle,
+            process_handle,
+            toplevel: toplevel.clone(),
+        });
+        self.reposition_windows();
+    }
+
+    pub fn reposition_windows(&mut self) {
+        let window_count = self.displayed_windows.len();
+
+        match &self.layout {
+            packet_server::WvrDisplayWindowLayout::Tiling => {
+                let mut i = 0;
+                for win in self.displayed_windows.iter_mut() {
+                    if let Some(window) = self.wm.borrow_mut().windows.get_mut(&win.window_handle) {
+                        if !window.visible {
+                            continue;
+                        }
+                        let d_cur = i as f32 / window_count as f32;
+                        let d_next = (i + 1) as f32 / window_count as f32;
+
+                        let left = (d_cur * self.width as f32) as i32;
+                        let right = (d_next * self.width as f32) as i32;
+
+                        window.set_pos(left, 0);
+                        window.set_size((right - left) as u32, self.height as u32);
+                        i += 1;
+                    }
+                }
+            }
+            packet_server::WvrDisplayWindowLayout::Stacking(opts) => {
+                let do_margins = |margins: &packet_server::Margins, window: &mut window::Window| {
+                    let top = margins.top as i32;
+                    let bottom = self.height as i32 - margins.bottom as i32;
+                    let left = margins.left as i32;
+                    let right = self.width as i32 - margins.right as i32;
+                    let width = right - left;
+                    let height = bottom - top;
+                    if width < 0 || height < 0 {
+                        return; // wrong parameters, do nothing!
+                    }
+
+                    window.set_pos(left, top);
+                    window.set_size(width as u32, height as u32);
+                };
+
+                let mut i = 0;
+                for win in self.displayed_windows.iter_mut() {
+                    if let Some(window) = self.wm.borrow_mut().windows.get_mut(&win.window_handle) {
+                        if !window.visible {
+                            continue;
+                        }
+                        do_margins(
+                            if i == 0 {
+                                &opts.margins_first
+                            } else {
+                                &opts.margins_rest
+                            },
+                            window,
+                        );
+                        i += 1;
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn tick(
+        &mut self,
+        config: &super::Config,
+        handle: &DisplayHandle,
+        signals: &mut SyncEventQueue<WayVRSignal>,
+    ) {
+        if self.visible {
+            if !self.displayed_windows.is_empty() {
+                self.no_windows_since = None;
+            } else if let Some(auto_hide_delay) = config.auto_hide_delay {
+                if let Some(s) = self.no_windows_since {
+                    if s + (auto_hide_delay as u64) < get_millis() {
+                        // Auto-hide after specific time
+                        signals.send(WayVRSignal::DisplayVisibility(*handle, false));
+                    }
+                }
+            }
+        }
+
+        while let Some(task) = self.tasks.read() {
+            match task {
+                DisplayTask::ProcessCleanup(process_handle) => {
+                    let count = self.displayed_windows.len();
+                    self.displayed_windows
+                        .retain(|win| win.process_handle != process_handle);
+                    log::info!(
+                        "Cleanup finished for display \"{}\". Current window count: {}",
+                        self.name,
+                        self.displayed_windows.len()
+                    );
+                    self.no_windows_since = Some(get_millis());
+
+                    if count != self.displayed_windows.len() {
+                        signals.send(WayVRSignal::BroadcastStateChanged(
+                            packet_server::WvrStateChanged::WindowRemoved,
+                        ));
+                    }
+
+                    self.reposition_windows();
+                }
+            }
+        }
+    }
+
+    pub fn tick_render(&self, renderer: &mut GlesRenderer, time_ms: u64) -> anyhow::Result<()> {
+        renderer.bind(self.gles_texture.clone())?;
+
+        let size = Size::from((self.width as i32, self.height as i32));
+        let damage: Rectangle<i32, smithay::utils::Physical> = Rectangle::from_size(size);
+
+        let elements: Vec<WaylandSurfaceRenderElement<GlesRenderer>> = self
+            .displayed_windows
+            .iter()
+            .flat_map(|display_window| {
+                let wm = self.wm.borrow_mut();
+                if let Some(window) = wm.windows.get(&display_window.window_handle) {
+                    if !window.visible {
+                        return vec![];
+                    }
+                    render_elements_from_surface_tree(
+                        renderer,
+                        display_window.toplevel.wl_surface(),
+                        (window.pos_x, window.pos_y),
+                        1.0,
+                        1.0,
+                        Kind::Unspecified,
+                    )
+                } else {
+                    // Failed to fetch window
+                    vec![]
+                }
+            })
+            .collect();
+
+        let mut frame = renderer.render(size, Transform::Normal)?;
+
+        let clear_color = if self.displayed_windows.is_empty() {
+            Color32F::new(1.0, 1.0, 1.0, 0.5)
+        } else {
+            Color32F::new(0.0, 0.0, 0.0, 0.0)
+        };
+
+        frame.clear(clear_color, &[damage])?;
+
+        draw_render_elements(&mut frame, 1.0, &elements, &[damage])?;
+
+        let _sync_point = frame.finish()?;
+
+        for window in &self.displayed_windows {
+            send_frames_surface_tree(window.toplevel.wl_surface(), time_ms as u32);
+        }
+
+        Ok(())
+    }
+
+    fn get_hovered_window(&self, cursor_x: u32, cursor_y: u32) -> Option<window::WindowHandle> {
+        let wm = self.wm.borrow();
+
+        for cell in self.displayed_windows.iter().rev() {
+            if let Some(window) = wm.windows.get(&cell.window_handle) {
+                if !window.visible {
+                    continue;
+                }
+
+                if (cursor_x as i32) >= window.pos_x
+                    && (cursor_x as i32) < window.pos_x + window.size_x as i32
+                    && (cursor_y as i32) >= window.pos_y
+                    && (cursor_y as i32) < window.pos_y + window.size_y as i32
+                {
+                    return Some(cell.window_handle);
+                }
+            }
+        }
+        None
+    }
+
+    pub fn trigger_rerender(&mut self) {
+        self.wants_redraw = true;
+    }
+
+    pub fn set_visible(&mut self, visible: bool) {
+        log::info!("Display \"{}\" visible: {}", self.name.as_str(), visible);
+        if self.visible == visible {
+            return;
+        }
+        self.visible = visible;
+        if visible {
+            self.no_windows_since = None;
+            self.trigger_rerender();
+        }
+    }
+
+    pub fn set_layout(&mut self, layout: packet_server::WvrDisplayWindowLayout) {
+        log::info!("Display \"{}\" layout: {:?}", self.name.as_str(), layout);
+        if self.layout == layout {
+            return;
+        }
+        self.layout = layout;
+        self.trigger_rerender();
+        self.reposition_windows();
+    }
+
+    pub fn send_mouse_move(
+        &self,
+        config: &super::Config,
+        manager: &mut WayVRCompositor,
+        x: u32,
+        y: u32,
+    ) {
+        let current_ms = time::get_millis();
+        if self.last_pressed_time_ms + config.click_freeze_time_ms as u64 > current_ms {
+            return;
+        }
+
+        if let Some(window_handle) = self.get_hovered_window(x, y) {
+            let wm = self.wm.borrow();
+            if let Some(window) = wm.windows.get(&window_handle) {
+                let surf = window.toplevel.wl_surface().clone();
+                let point = Point::<f64, Logical>::from((
+                    (x as i32 - window.pos_x) as f64,
+                    (y as i32 - window.pos_y) as f64,
+                ));
+
+                manager.seat_pointer.motion(
+                    &mut manager.state,
+                    Some((surf, Point::from((0.0, 0.0)))),
+                    &input::pointer::MotionEvent {
+                        serial: manager.serial_counter.next_serial(),
+                        time: 0,
+                        location: point,
+                    },
+                );
+
+                manager.seat_pointer.frame(&mut manager.state);
+            }
+        }
+    }
+
+    fn get_mouse_index_number(index: super::MouseIndex) -> u32 {
+        match index {
+            super::MouseIndex::Left => 0x110,   /* BTN_LEFT */
+            super::MouseIndex::Center => 0x112, /* BTN_MIDDLE */
+            super::MouseIndex::Right => 0x111,  /* BTN_RIGHT */
+        }
+    }
+
+    pub fn send_mouse_down(&mut self, manager: &mut WayVRCompositor, index: super::MouseIndex) {
+        // Change keyboard focus to pressed window
+        let loc = manager.seat_pointer.current_location();
+
+        self.last_pressed_time_ms = time::get_millis();
+
+        if let Some(window_handle) =
+            self.get_hovered_window(loc.x.max(0.0) as u32, loc.y.max(0.0) as u32)
+        {
+            let wm = self.wm.borrow();
+            if let Some(window) = wm.windows.get(&window_handle) {
+                let surf = window.toplevel.wl_surface().clone();
+
+                if manager.seat_keyboard.current_focus().is_none() {
+                    manager.seat_keyboard.set_focus(
+                        &mut manager.state,
+                        Some(surf),
+                        manager.serial_counter.next_serial(),
+                    );
+                }
+            }
+        }
+
+        manager.seat_pointer.button(
+            &mut manager.state,
+            &input::pointer::ButtonEvent {
+                button: Self::get_mouse_index_number(index),
+                serial: manager.serial_counter.next_serial(),
+                time: 0,
+                state: smithay::backend::input::ButtonState::Pressed,
+            },
+        );
+
+        manager.seat_pointer.frame(&mut manager.state);
+    }
+
+    pub fn send_mouse_up(&self, manager: &mut WayVRCompositor, index: super::MouseIndex) {
+        manager.seat_pointer.button(
+            &mut manager.state,
+            &input::pointer::ButtonEvent {
+                button: Self::get_mouse_index_number(index),
+                serial: manager.serial_counter.next_serial(),
+                time: 0,
+                state: smithay::backend::input::ButtonState::Released,
+            },
+        );
+
+        manager.seat_pointer.frame(&mut manager.state);
+    }
+
+    pub fn send_mouse_scroll(&self, manager: &mut WayVRCompositor, delta: f32) {
+        manager.seat_pointer.axis(
+            &mut manager.state,
+            input::pointer::AxisFrame {
+                source: None,
+                relative_direction: (
+                    smithay::backend::input::AxisRelativeDirection::Identical,
+                    smithay::backend::input::AxisRelativeDirection::Identical,
+                ),
+                time: 0,
+                axis: (0.0, -delta as f64),
+                v120: Some((0, (delta * -120.0) as i32)),
+                stop: (false, false),
+            },
+        );
+        manager.seat_pointer.frame(&mut manager.state);
+    }
+
+    fn configure_env(&self, cmd: &mut std::process::Command, auth_key: &str) {
+        cmd.env_remove("DISPLAY"); // Goodbye X11
+        cmd.env("WAYLAND_DISPLAY", self.wayland_env.display_num_string());
+        cmd.env("WAYVR_DISPLAY_AUTH", auth_key);
+    }
+
+    pub fn spawn_process(
+        &mut self,
+        exec_path: &str,
+        args: &[&str],
+        env: &[(&str, &str)],
+    ) -> anyhow::Result<SpawnProcessResult> {
+        log::info!("Spawning subprocess with exec path \"{}\"", exec_path);
+
+        let auth_key = generate_auth_key();
+
+        let mut cmd = std::process::Command::new(exec_path);
+        self.configure_env(&mut cmd, auth_key.as_str());
+        cmd.args(args);
+
+        for e in env {
+            cmd.env(e.0, e.1);
+        }
+
+        match cmd.spawn() {
+            Ok(child) => Ok(SpawnProcessResult { auth_key, child }),
+            Err(e) => {
+                anyhow::bail!(
+					"Failed to launch process with path \"{}\": {}. Make sure your exec path exists.",
+					exec_path,
+					e
+				);
+            }
+        }
+    }
+}
+
+gen_id!(DisplayVec, Display, DisplayCell, DisplayHandle);
+
+impl DisplayHandle {
+    pub fn from_packet(handle: packet_server::WvrDisplayHandle) -> Self {
+        Self {
+            generation: handle.generation,
+            idx: handle.idx,
+        }
+    }
+
+    pub fn as_packet(&self) -> packet_server::WvrDisplayHandle {
+        packet_server::WvrDisplayHandle {
+            idx: self.idx,
+            generation: self.generation,
+        }
+    }
+}
@@ -0,0 +1,258 @@
+use super::egl_ex;
+use anyhow::anyhow;
+
+#[derive(Debug)]
+pub struct EGLData {
+    pub egl: khronos_egl::Instance<khronos_egl::Static>,
+    pub display: khronos_egl::Display,
+    pub config: khronos_egl::Config,
+    pub context: khronos_egl::Context,
+}
+
+#[macro_export]
+macro_rules! bind_egl_function {
+    ($func_type:ident, $func:expr) => {
+        std::mem::transmute_copy::<_, $func_type>($func).unwrap()
+    };
+}
+
+#[derive(Debug, Clone)]
+pub struct DMAbufModifierInfo {
+    pub modifiers: Vec<u64>,
+    pub fourcc: u32,
+}
+
+#[derive(Debug, Clone)]
+pub struct DMAbufData {
+    pub fd: i32,
+    pub stride: i32,
+    pub offset: i32,
+    pub mod_info: DMAbufModifierInfo,
+}
+
+impl EGLData {
+    pub fn load_func(&self, func_name: &str) -> anyhow::Result<extern "system" fn()> {
+        let raw_fn = self.egl.get_proc_address(func_name).ok_or(anyhow::anyhow!(
+            "Required EGL function {} not found",
+            func_name
+        ))?;
+        Ok(raw_fn)
+    }
+
+    pub fn new() -> anyhow::Result<EGLData> {
+        unsafe {
+            let egl = khronos_egl::Instance::new(khronos_egl::Static);
+
+            let display = egl
+                .get_display(khronos_egl::DEFAULT_DISPLAY)
+                .ok_or(anyhow!(
+                    "eglGetDisplay failed. This shouldn't happen unless you don't have any display manager running. Cannot continue, check your EGL installation."
+                ))?;
+
+            let (major, minor) = egl.initialize(display)?;
+            log::debug!("EGL version: {}.{}", major, minor);
+
+            let attrib_list = [
+                khronos_egl::RED_SIZE,
+                8,
+                khronos_egl::GREEN_SIZE,
+                8,
+                khronos_egl::BLUE_SIZE,
+                8,
+                khronos_egl::SURFACE_TYPE,
+                khronos_egl::WINDOW_BIT,
+                khronos_egl::RENDERABLE_TYPE,
+                khronos_egl::OPENGL_BIT,
+                khronos_egl::NONE,
+            ];
+
+            let config = egl
+                .choose_first_config(display, &attrib_list)?
+                .ok_or(anyhow!("Failed to get EGL config"))?;
+
+            egl.bind_api(khronos_egl::OPENGL_ES_API)?;
+
+            log::debug!("eglCreateContext");
+
+            // Require OpenGL ES 3.0
+            let context_attrib_list = [
+                khronos_egl::CONTEXT_MAJOR_VERSION,
+                3,
+                khronos_egl::CONTEXT_MINOR_VERSION,
+                0,
+                khronos_egl::NONE,
+            ];
+
+            let context = egl.create_context(display, config, None, &context_attrib_list)?;
+
+            log::debug!("eglMakeCurrent");
+
+            egl.make_current(display, None, None, Some(context))?;
+
+            Ok(EGLData {
+                egl,
+                display,
+                config,
+                context,
+            })
+        }
+    }
+
+    fn query_dmabuf_mod_info(&self) -> anyhow::Result<DMAbufModifierInfo> {
+        let target_fourcc = 0x34324258; //XB24
+
+        unsafe {
+            use egl_ex::PFNEGLQUERYDMABUFFORMATSEXTPROC;
+            use egl_ex::PFNEGLQUERYDMABUFMODIFIERSEXTPROC;
+
+            let egl_query_dmabuf_formats_ext = bind_egl_function!(
+                PFNEGLQUERYDMABUFFORMATSEXTPROC,
+                &self.load_func("eglQueryDmaBufFormatsEXT")?
+            );
+
+            // Query format count
+            let mut num_formats: khronos_egl::Int = 0;
+            egl_query_dmabuf_formats_ext(
+                self.display.as_ptr(),
+                0,
+                std::ptr::null_mut(),
+                &mut num_formats,
+            );
+
+            // Retrieve formt list
+            let mut formats: Vec<i32> = vec![0; num_formats as usize];
+            egl_query_dmabuf_formats_ext(
+                self.display.as_ptr(),
+                num_formats,
+                formats.as_mut_ptr(),
+                &mut num_formats,
+            );
+
+            /*for (idx, format) in formats.iter().enumerate() {
+                let bytes = format.to_le_bytes();
+                log::trace!(
+                    "idx {}, format {}{}{}{} (hex {:#x})",
+                    idx,
+                    bytes[0] as char,
+                    bytes[1] as char,
+                    bytes[2] as char,
+                    bytes[3] as char,
+                    format
+                );
+            }*/
+
+            let egl_query_dmabuf_modifiers_ext = bind_egl_function!(
+                PFNEGLQUERYDMABUFMODIFIERSEXTPROC,
+                &self.load_func("eglQueryDmaBufModifiersEXT")?
+            );
+
+            let mut num_mods: khronos_egl::Int = 0;
+
+            // Query modifier count
+            egl_query_dmabuf_modifiers_ext(
+                self.display.as_ptr(),
+                target_fourcc,
+                0,
+                std::ptr::null_mut(),
+                std::ptr::null_mut(),
+                &mut num_mods,
+            );
+
+            if num_mods == 0 {
+                anyhow::bail!("eglQueryDmaBufModifiersEXT modifier count is zero");
+            }
+
+            let mut mods: Vec<u64> = vec![0; num_mods as usize];
+            egl_query_dmabuf_modifiers_ext(
+                self.display.as_ptr(),
+                target_fourcc,
+                num_mods,
+                mods.as_mut_ptr(),
+                std::ptr::null_mut(),
+                &mut num_mods,
+            );
+
+            if mods[0] == 0xFFFFFFFFFFFFFFFF {
+                anyhow::bail!("modifier is -1")
+            }
+
+            log::trace!("Modifier list:");
+            for modifier in &mods {
+                log::trace!("{:#x}", modifier);
+            }
+
+            // We should not change these modifier values. Passing all of them to the Vulkan dmabuf
+            // texture system causes significant graphical corruption due to invalid memory layout and
+            // tiling on this specific GPU model (very probably others also have the same issue).
+            // It is not guaranteed that this modifier will be present in other models.
+            // If not, the full list of modifiers will be passed. Further testing is required.
+            // For now, it looks like only NAVI32-based gpus have this problem.
+            let mod_whitelist: [u64; 2] = [
+                0x20000002086bf04, /* AMD RX 7800 XT, Navi32 */
+                0x20000001866bf04, /* AMD RX 7600 XT, Navi33 */
+            ];
+
+            for modifier in &mod_whitelist {
+                if mods.contains(modifier) {
+                    log::warn!("Using whitelisted dmabuf tiling modifier: {:#x}", modifier);
+                    mods = vec![*modifier, 0x0 /* also important (???) */];
+                    break;
+                }
+            }
+
+            Ok(DMAbufModifierInfo {
+                modifiers: mods,
+                fourcc: target_fourcc as u32,
+            })
+        }
+    }
+
+    pub fn create_dmabuf_data(&self, egl_image: &khronos_egl::Image) -> anyhow::Result<DMAbufData> {
+        use egl_ex::PFNEGLEXPORTDMABUFIMAGEMESAPROC as FUNC;
+        unsafe {
+            let egl_export_dmabuf_image_mesa =
+                bind_egl_function!(FUNC, &self.load_func("eglExportDMABUFImageMESA")?);
+
+            let mut fds: [i32; 3] = [0; 3];
+            let mut strides: [i32; 3] = [0; 3];
+            let mut offsets: [i32; 3] = [0; 3];
+
+            if egl_export_dmabuf_image_mesa(
+                self.display.as_ptr(),
+                egl_image.as_ptr(),
+                fds.as_mut_ptr(),
+                strides.as_mut_ptr(),
+                offsets.as_mut_ptr(),
+            ) != khronos_egl::TRUE
+            {
+                anyhow::bail!("eglExportDMABUFImageMESA failed");
+            }
+
+            // many planes in RGB data?
+            debug_assert!(fds[1] == 0);
+            debug_assert!(strides[1] == 0);
+            debug_assert!(offsets[1] == 0);
+
+            let mod_info = self.query_dmabuf_mod_info()?;
+
+            Ok(DMAbufData {
+                fd: fds[0],
+                stride: strides[0],
+                offset: offsets[0],
+                mod_info,
+            })
+        }
+    }
+
+    pub fn create_egl_image(&self, gl_tex_id: u32) -> anyhow::Result<khronos_egl::Image> {
+        unsafe {
+            Ok(self.egl.create_image(
+                self.display,
+                self.context,
+                khronos_egl::GL_TEXTURE_2D as std::ffi::c_uint,
+                khronos_egl::ClientBuffer::from_ptr(gl_tex_id as *mut std::ffi::c_void),
+                &[khronos_egl::ATTRIB_NONE],
+            )?)
+        }
+    }
+}
@@ -0,0 +1,34 @@
+#![allow(clippy::all)]
+
+//eglExportDMABUFImageMESA
+pub type PFNEGLEXPORTDMABUFIMAGEMESAPROC = Option<
+    unsafe extern "C" fn(
+        dpy: khronos_egl::EGLDisplay,
+        image: khronos_egl::EGLImage,
+        fds: *mut i32,
+        strides: *mut khronos_egl::Int,
+        offsets: *mut khronos_egl::Int,
+    ) -> khronos_egl::Boolean,
+>;
+
+//eglQueryDmaBufModifiersEXT
+pub type PFNEGLQUERYDMABUFMODIFIERSEXTPROC = Option<
+    unsafe extern "C" fn(
+        dpy: khronos_egl::EGLDisplay,
+        format: khronos_egl::Int,
+        max_modifiers: khronos_egl::Int,
+        modifiers: *mut u64,
+        external_only: *mut khronos_egl::Boolean,
+        num_modifiers: *mut khronos_egl::Int,
+    ) -> khronos_egl::Boolean,
+>;
+
+//eglQueryDmaBufFormatsEXT
+pub type PFNEGLQUERYDMABUFFORMATSEXTPROC = Option<
+    unsafe extern "C" fn(
+        dpy: khronos_egl::EGLDisplay,
+        max_formats: khronos_egl::Int,
+        formats: *mut khronos_egl::Int,
+        num_formats: *mut khronos_egl::Int,
+    ) -> khronos_egl::Boolean,
+>;
@@ -0,0 +1,33 @@
+#![allow(dead_code)]
+
+use std::{cell::RefCell, collections::VecDeque, rc::Rc};
+
+#[derive(Debug)]
+struct Data<DataType> {
+    queue: VecDeque<DataType>,
+}
+
+#[derive(Debug, Clone)]
+pub struct SyncEventQueue<DataType> {
+    data: Rc<RefCell<Data<DataType>>>,
+}
+
+impl<DataType> SyncEventQueue<DataType> {
+    pub fn new() -> Self {
+        Self {
+            data: Rc::new(RefCell::new(Data {
+                queue: Default::default(),
+            })),
+        }
+    }
+
+    pub fn send(&self, message: DataType) {
+        let mut data = self.data.borrow_mut();
+        data.queue.push_back(message);
+    }
+
+    pub fn read(&self) -> Option<DataType> {
+        let mut data = self.data.borrow_mut();
+        data.queue.pop_front()
+    }
+}
@@ -0,0 +1,175 @@
+#[macro_export]
+macro_rules! gen_id {
+    (
+		$container_name:ident,
+		$instance_name:ident,
+		$cell_name:ident,
+		$handle_name:ident) => {
+        //ThingCell
+        #[derive(Debug)]
+        pub struct $cell_name {
+            pub obj: $instance_name,
+            pub generation: u64,
+        }
+
+        //ThingVec
+        #[derive(Debug)]
+        pub struct $container_name {
+            // Vec<Option<ThingCell>>
+            pub vec: Vec<Option<$cell_name>>,
+
+            cur_generation: u64,
+        }
+
+        //ThingHandle
+        #[derive(Default, Debug, Clone, Copy, PartialEq, Hash, Eq)]
+        pub struct $handle_name {
+            idx: u32,
+            generation: u64,
+        }
+
+        #[allow(dead_code)]
+        impl $handle_name {
+            pub fn reset(&mut self) {
+                self.generation = 0;
+            }
+
+            pub fn is_set(&self) -> bool {
+                self.generation > 0
+            }
+
+            pub fn id(&self) -> u32 {
+                self.idx
+            }
+
+            pub fn new(idx: u32, generation: u64) -> Self {
+                Self { idx, generation }
+            }
+        }
+
+        //ThingVec
+        #[allow(dead_code)]
+        impl $container_name {
+            pub fn new() -> Self {
+                Self {
+                    vec: Vec::new(),
+                    cur_generation: 0,
+                }
+            }
+
+            pub fn iter(&self, callback: &dyn Fn($handle_name, &$instance_name)) {
+                for (idx, opt_cell) in self.vec.iter().enumerate() {
+                    if let Some(cell) = opt_cell {
+                        let handle = $container_name::get_handle(&cell, idx);
+                        callback(handle, &cell.obj);
+                    }
+                }
+            }
+
+            pub fn iter_mut(
+                &mut self,
+                callback: &mut dyn FnMut($handle_name, &mut $instance_name),
+            ) {
+                for (idx, opt_cell) in self.vec.iter_mut().enumerate() {
+                    if let Some(cell) = opt_cell {
+                        let handle = $container_name::get_handle(&cell, idx);
+                        callback(handle, &mut cell.obj);
+                    }
+                }
+            }
+
+            pub fn get_handle(cell: &$cell_name, idx: usize) -> $handle_name {
+                $handle_name {
+                    idx: idx as u32,
+                    generation: cell.generation,
+                }
+            }
+
+            fn find_unused_idx(&mut self) -> Option<u32> {
+                for (num, obj) in self.vec.iter().enumerate() {
+                    if obj.is_none() {
+                        return Some(num as u32);
+                    }
+                }
+                None
+            }
+
+            pub fn add(&mut self, obj: $instance_name) -> $handle_name {
+                self.cur_generation += 1;
+                let generation = self.cur_generation;
+
+                let unused_idx = self.find_unused_idx();
+
+                let idx = if let Some(idx) = unused_idx {
+                    idx
+                } else {
+                    self.vec.len() as u32
+                };
+
+                let handle = $handle_name { idx, generation };
+
+                let cell = $cell_name { obj, generation };
+
+                if let Some(idx) = unused_idx {
+                    self.vec[idx as usize] = Some(cell);
+                } else {
+                    self.vec.push(Some(cell))
+                }
+
+                handle
+            }
+
+            pub fn remove(&mut self, handle: &$handle_name) {
+                // Out of bounds, ignore
+                if handle.idx as usize >= self.vec.len() {
+                    return;
+                }
+
+                // Remove only if the generation matches
+                if let Some(cell) = &self.vec[handle.idx as usize] {
+                    if cell.generation == handle.generation {
+                        self.vec[handle.idx as usize] = None;
+                    }
+                }
+            }
+
+            pub fn get(&self, handle: &$handle_name) -> Option<&$instance_name> {
+                // Out of bounds, ignore
+                if handle.idx as usize >= self.vec.len() {
+                    return None;
+                }
+
+                if let Some(cell) = &self.vec[handle.idx as usize] {
+                    if cell.generation == handle.generation {
+                        return Some(&cell.obj);
+                    }
+                }
+
+                None
+            }
+
+            pub fn get_mut(&mut self, handle: &$handle_name) -> Option<&mut $instance_name> {
+                // Out of bounds, ignore
+                if handle.idx as usize >= self.vec.len() {
+                    return None;
+                }
+
+                if let Some(cell) = &mut self.vec[handle.idx as usize] {
+                    if cell.generation == handle.generation {
+                        return Some(&mut cell.obj);
+                    }
+                }
+
+                None
+            }
+        }
+    };
+}
+
+/* Example usage:
+gen_id!(ThingVec, ThingInstance, ThingCell, ThingHandle);
+
+struct ThingInstance {}
+
+impl ThingInstance {}
+ */
@@ -0,0 +1,661 @@
+pub mod client;
+mod comp;
+pub mod display;
+pub mod egl_data;
+mod egl_ex;
+pub mod event_queue;
+mod handle;
+mod process;
+pub mod server_ipc;
+mod smithay_wrapper;
+mod time;
+mod window;
+use comp::Application;
+use display::{DisplayInitParams, DisplayVec};
+use event_queue::SyncEventQueue;
+use process::ProcessVec;
+use server_ipc::WayVRServer;
+use smallvec::SmallVec;
+use smithay::{
+    backend::{
+        egl,
+        renderer::{gles::GlesRenderer, ImportDma},
+    },
+    input::SeatState,
+    output::{Mode, Output},
+    reexports::wayland_server::{self, backend::ClientId},
+    wayland::{
+        compositor,
+        dmabuf::{DmabufFeedbackBuilder, DmabufState},
+        selection::data_device::DataDeviceState,
+        shell::xdg::{ToplevelSurface, XdgShellState},
+        shm::ShmState,
+    },
+};
+use std::{
+    cell::RefCell,
+    collections::{HashMap, HashSet},
+    rc::Rc,
+};
+use time::get_millis;
+use wayvr_ipc::{packet_client, packet_server};
+
+use crate::state::AppState;
+
+const STR_INVALID_HANDLE_DISP: &str = "Invalid display handle";
+const STR_INVALID_HANDLE_PROCESS: &str = "Invalid process handle";
+
+#[derive(Debug, Clone)]
+pub struct WaylandEnv {
+    pub display_num: u32,
+}
+
+impl WaylandEnv {
+    pub fn display_num_string(&self) -> String {
+        // e.g. "wayland-20"
+        format!("wayland-{}", self.display_num)
+    }
+}
+
+#[derive(Clone)]
+pub struct ProcessWayVREnv {
+    pub display_auth: Option<String>,
+    pub display_name: Option<String>, // Externally spawned process by a user script
+}
+
+#[derive(Clone)]
+pub struct ExternalProcessRequest {
+    pub env: ProcessWayVREnv,
+    pub client: wayland_server::Client,
+    pub pid: u32,
+}
+
+#[derive(Clone)]
+pub enum WayVRTask {
+    NewToplevel(ClientId, ToplevelSurface),
+    NewExternalProcess(ExternalProcessRequest),
+    DropOverlay(super::overlay::OverlayID),
+    ProcessTerminationRequest(process::ProcessHandle),
+    Haptics(super::input::Haptics),
+}
+
+#[derive(Clone)]
+pub enum WayVRSignal {
+    DisplayVisibility(display::DisplayHandle, bool),
+    DisplayWindowLayout(
+        display::DisplayHandle,
+        packet_server::WvrDisplayWindowLayout,
+    ),
+    BroadcastStateChanged(packet_server::WvrStateChanged),
+}
+
+pub struct Config {
+    pub click_freeze_time_ms: u32,
+    pub keyboard_repeat_delay_ms: u32,
+    pub keyboard_repeat_rate: u32,
+    pub auto_hide_delay: Option<u32>, // if None, auto-hide is disabled
+}
+
+pub struct WayVRState {
+    time_start: u64,
+    pub displays: display::DisplayVec,
+    pub manager: client::WayVRCompositor,
+    wm: Rc<RefCell<window::WindowManager>>,
+    egl_data: Rc<egl_data::EGLData>,
+    pub processes: process::ProcessVec,
+    config: Config,
+    dashboard_display: Option<display::DisplayHandle>,
+    pub tasks: SyncEventQueue<WayVRTask>,
+    pub signals: SyncEventQueue<WayVRSignal>,
+    ticks: u64,
+    pub pending_haptic: Option<super::input::Haptics>,
+}
+
+pub struct WayVR {
+    pub state: WayVRState,
+    pub ipc_server: WayVRServer,
+}
+
+pub enum MouseIndex {
+    Left,
+    Center,
+    Right,
+}
+
+pub enum TickTask {
+    NewExternalProcess(ExternalProcessRequest), // Call WayVRCompositor::add_client after receiving this message
+    NewDisplay(
+        packet_client::WvrDisplayCreateParams,
+        Option<display::DisplayHandle>, /* existing handle? */
+    ),
+    DropOverlay(super::overlay::OverlayID),
+}
+
+impl WayVR {
+    pub fn new(config: Config) -> anyhow::Result<Self> {
+        log::info!("Initializing WayVR");
+        let display: wayland_server::Display<Application> = wayland_server::Display::new()?;
+        let dh = display.handle();
+        let compositor = compositor::CompositorState::new::<Application>(&dh);
+        let xdg_shell = XdgShellState::new::<Application>(&dh);
+        let mut seat_state = SeatState::new();
+        let shm = ShmState::new::<Application>(&dh, Vec::new());
+        let data_device = DataDeviceState::new::<Application>(&dh);
+        let mut seat = seat_state.new_wl_seat(&dh, "wayvr");
+
+        let dummy_width = 1280;
+        let dummy_height = 720;
+        let dummy_milli_hz = 60000; /* refresh rate in millihertz */
+
+        let output = Output::new(
+            String::from("wayvr_display"),
+            smithay::output::PhysicalProperties {
+                size: (dummy_width, dummy_height).into(),
+                subpixel: smithay::output::Subpixel::None,
+                make: String::from("Completely Legit"),
+                model: String::from("Virtual WayVR Display"),
+            },
+        );
+
+        let mode = Mode {
+            refresh: dummy_milli_hz,
+            size: (dummy_width, dummy_height).into(),
+        };
+
+        let _global = output.create_global::<Application>(&dh);
+        output.change_current_state(Some(mode), None, None, None);
+        output.set_preferred(mode);
+
+        let egl_data = egl_data::EGLData::new()?;
+
+        let smithay_display = smithay_wrapper::get_egl_display(&egl_data)?;
+        let smithay_context = smithay_wrapper::get_egl_context(&egl_data, &smithay_display)?;
+
+        let render_node = egl::EGLDevice::device_for_display(&smithay_display)
+            .and_then(|device| device.try_get_render_node());
+
+        let gles_renderer = unsafe { GlesRenderer::new(smithay_context)? };
+
+        let dmabuf_default_feedback = match render_node {
+            Ok(Some(node)) => {
+                let dmabuf_formats = gles_renderer.dmabuf_formats();
+                let dmabuf_default_feedback =
+                    DmabufFeedbackBuilder::new(node.dev_id(), dmabuf_formats)
+                        .build()
+                        .unwrap();
+                Some(dmabuf_default_feedback)
+            }
+            Ok(None) => {
+                log::warn!("dmabuf: Failed to query render node");
+                None
+            }
+            Err(err) => {
+                log::warn!("dmabuf: Failed to get egl device for display: {}", err);
+                None
+            }
+        };
+
+        let dmabuf_state = if let Some(default_feedback) = dmabuf_default_feedback {
+            let mut dmabuf_state = DmabufState::new();
+            let dmabuf_global = dmabuf_state.create_global_with_default_feedback::<Application>(
+                &display.handle(),
+                &default_feedback,
+            );
+            (dmabuf_state, dmabuf_global, Some(default_feedback))
+        } else {
+            let dmabuf_formats = gles_renderer.dmabuf_formats();
+            let mut dmabuf_state = DmabufState::new();
+            let dmabuf_global =
+                dmabuf_state.create_global::<Application>(&display.handle(), dmabuf_formats);
+            (dmabuf_state, dmabuf_global, None)
+        };
+
+        let seat_keyboard = seat.add_keyboard(
+            Default::default(),
+            config.keyboard_repeat_delay_ms as i32,
+            config.keyboard_repeat_rate as i32,
+        )?;
+        let seat_pointer = seat.add_pointer();
+
+        let tasks = SyncEventQueue::new();
+
+        let state = Application {
+            compositor,
+            xdg_shell,
+            seat_state,
+            shm,
+            data_device,
+            wayvr_tasks: tasks.clone(),
+            redraw_requests: HashSet::new(),
+            dmabuf_state,
+            gles_renderer,
+        };
+
+        let time_start = get_millis();
+
+        let ipc_server = WayVRServer::new()?;
+
+        let state = WayVRState {
+            time_start,
+            manager: client::WayVRCompositor::new(state, display, seat_keyboard, seat_pointer)?,
+            displays: DisplayVec::new(),
+            processes: ProcessVec::new(),
+            egl_data: Rc::new(egl_data),
+            wm: Rc::new(RefCell::new(window::WindowManager::new())),
+            config,
+            dashboard_display: None,
+            ticks: 0,
+            tasks,
+            pending_haptic: None,
+            signals: SyncEventQueue::new(),
+        };
+
+        Ok(Self { state, ipc_server })
+    }
+
+    pub fn tick_display(&mut self, display: display::DisplayHandle) -> anyhow::Result<()> {
+        // millis since the start of wayvr
+        let display = self
+            .state
+            .displays
+            .get_mut(&display)
+            .ok_or(anyhow::anyhow!(STR_INVALID_HANDLE_DISP))?;
+
+        if !display.wants_redraw {
+            // Nothing changed, do not render
+            return Ok(());
+        }
+
+        if !display.visible {
+            // Display is invisible, do not render
+            return Ok(());
+        }
+
+        let time_ms = get_millis() - self.state.time_start;
+
+        display.tick_render(&mut self.state.manager.state.gles_renderer, time_ms)?;
+        display.wants_redraw = false;
+
+        Ok(())
+    }
+
+    pub fn tick_events(&mut self, app: &AppState) -> anyhow::Result<Vec<TickTask>> {
+        let mut tasks: Vec<TickTask> = Vec::new();
+
+        self.ipc_server.tick(&mut server_ipc::TickParams {
+            state: &mut self.state,
+            tasks: &mut tasks,
+            app,
+        })?;
+
+        // Check for redraw events
+        self.state.displays.iter_mut(&mut |_, disp| {
+            for disp_window in &disp.displayed_windows {
+                if self
+                    .state
+                    .manager
+                    .state
+                    .check_redraw(disp_window.toplevel.wl_surface())
+                {
+                    disp.wants_redraw = true;
+                }
+            }
+        });
+
+        // Tick all child processes
+        let mut to_remove: SmallVec<[(process::ProcessHandle, display::DisplayHandle); 2]> =
+            SmallVec::new();
+
+        self.state.processes.iter_mut(&mut |handle, process| {
+            if !process.is_running() {
+                to_remove.push((handle, process.display_handle()));
+            }
+        });
+
+        for (p_handle, disp_handle) in &to_remove {
+            self.state.processes.remove(p_handle);
+
+            if let Some(display) = self.state.displays.get_mut(disp_handle) {
+                display
+                    .tasks
+                    .send(display::DisplayTask::ProcessCleanup(*p_handle));
+                display.wants_redraw = true;
+            }
+        }
+
+        self.state.displays.iter_mut(&mut |handle, display| {
+            display.tick(&self.state.config, &handle, &mut self.state.signals);
+        });
+
+        if !to_remove.is_empty() {
+            self.state.signals.send(WayVRSignal::BroadcastStateChanged(
+                packet_server::WvrStateChanged::ProcessRemoved,
+            ));
+        }
+
+        while let Some(task) = self.state.tasks.read() {
+            match task {
+                WayVRTask::NewExternalProcess(req) => {
+                    tasks.push(TickTask::NewExternalProcess(req));
+                }
+                WayVRTask::DropOverlay(overlay_id) => {
+                    tasks.push(TickTask::DropOverlay(overlay_id));
+                }
+                WayVRTask::NewToplevel(client_id, toplevel) => {
+                    // Attach newly created toplevel surfaces to displays
+                    for client in &self.state.manager.clients {
+                        if client.client.id() == client_id {
+                            if let Some(process_handle) =
+                                process::find_by_pid(&self.state.processes, client.pid)
+                            {
+                                let window_handle = self
+                                    .state
+                                    .wm
+                                    .borrow_mut()
+                                    .create_window(client.display_handle, &toplevel);
+
+                                if let Some(display) =
+                                    self.state.displays.get_mut(&client.display_handle)
+                                {
+                                    display.add_window(window_handle, process_handle, &toplevel);
+                                    self.state.signals.send(WayVRSignal::BroadcastStateChanged(
+                                        packet_server::WvrStateChanged::WindowCreated,
+                                    ));
+                                } else {
+                                    // This shouldn't happen, scream if it does
+                                    log::error!("Could not attach window handle into display");
+                                }
+                            } else {
+                                log::error!(
+                                    "WayVR window creation failed: Unexpected process ID {}. It wasn't registered before.",
+                                    client.pid
+                                );
+                            }
+
+                            break;
+                        }
+                    }
+                }
+                WayVRTask::ProcessTerminationRequest(process_handle) => {
+                    if let Some(process) = self.state.processes.get_mut(&process_handle) {
+                        process.terminate();
+                    }
+                }
+                WayVRTask::Haptics(haptics) => {
+                    self.state.pending_haptic = Some(haptics);
+                }
+            }
+        }
+
+        self.state
+            .manager
+            .tick_wayland(&mut self.state.displays, &mut self.state.processes)?;
+
+        if self.state.ticks % 200 == 0 {
+            self.state.manager.cleanup_clients();
+        }
+
+        self.state.ticks += 1;
+
+        Ok(tasks)
+    }
+
+    pub fn tick_finish(&mut self) -> anyhow::Result<()> {
+        self.state
+            .manager
+            .state
+            .gles_renderer
+            .with_context(|gl| unsafe {
+                gl.Flush();
+                gl.Finish();
+            })?;
+        Ok(())
+    }
+
+    pub fn get_primary_display(displays: &DisplayVec) -> Option<display::DisplayHandle> {
+        for (idx, cell) in displays.vec.iter().enumerate() {
+            if let Some(cell) = cell {
+                if cell.obj.primary {
+                    return Some(DisplayVec::get_handle(cell, idx));
+                }
+            }
+        }
+        None
+    }
+
+    pub fn get_display_by_name(
+        displays: &DisplayVec,
+        name: &str,
+    ) -> Option<display::DisplayHandle> {
+        for (idx, cell) in displays.vec.iter().enumerate() {
+            if let Some(cell) = cell {
+                if cell.obj.name == name {
+                    return Some(DisplayVec::get_handle(cell, idx));
+                }
+            }
+        }
+        None
+    }
+
+    pub fn terminate_process(&mut self, process_handle: process::ProcessHandle) {
+        self.state
+            .tasks
+            .send(WayVRTask::ProcessTerminationRequest(process_handle));
+    }
+}
+
+impl WayVRState {
+    pub fn send_mouse_move(&mut self, display: display::DisplayHandle, x: u32, y: u32) {
+        if let Some(display) = self.displays.get(&display) {
+            display.send_mouse_move(&self.config, &mut self.manager, x, y);
+        }
+    }
+
+    pub fn send_mouse_down(&mut self, display: display::DisplayHandle, index: MouseIndex) {
+        if let Some(display) = self.displays.get_mut(&display) {
+            display.send_mouse_down(&mut self.manager, index);
+        }
+    }
+
+    pub fn send_mouse_up(&mut self, display: display::DisplayHandle, index: MouseIndex) {
+        if let Some(display) = self.displays.get(&display) {
+            display.send_mouse_up(&mut self.manager, index);
+        }
+    }
+
+    pub fn send_mouse_scroll(&mut self, display: display::DisplayHandle, delta: f32) {
+        if let Some(display) = self.displays.get(&display) {
+            display.send_mouse_scroll(&mut self.manager, delta);
+        }
+    }
+
+    pub fn send_key(&mut self, virtual_key: u32, down: bool) {
+        self.manager.send_key(virtual_key, down);
+    }
+
+    pub fn set_display_visible(&mut self, display: display::DisplayHandle, visible: bool) {
+        if let Some(display) = self.displays.get_mut(&display) {
+            display.set_visible(visible);
+        }
+    }
+
+    pub fn set_display_layout(
+        &mut self,
+        display: display::DisplayHandle,
+        layout: packet_server::WvrDisplayWindowLayout,
+    ) {
+        if let Some(display) = self.displays.get_mut(&display) {
+            display.set_layout(layout);
+        }
+    }
+
+    pub fn get_dmabuf_data(&self, display: display::DisplayHandle) -> Option<egl_data::DMAbufData> {
+        self.displays
+            .get(&display)
+            .map(|display| display.dmabuf_data.clone())
+    }
+
+    pub fn create_display(
+        &mut self,
+        width: u16,
+        height: u16,
+        name: &str,
+        primary: bool,
+    ) -> anyhow::Result<display::DisplayHandle> {
+        let display = display::Display::new(DisplayInitParams {
+            wm: self.wm.clone(),
+            egl_data: self.egl_data.clone(),
+            renderer: &mut self.manager.state.gles_renderer,
+            wayland_env: self.manager.wayland_env.clone(),
+            width,
+            height,
+            name,
+            primary,
+        })?;
+
+        let handle = self.displays.add(display);
+
+        self.signals.send(WayVRSignal::BroadcastStateChanged(
+            packet_server::WvrStateChanged::DisplayCreated,
+        ));
+
+        Ok(handle)
+    }
+
+    pub fn destroy_display(&mut self, handle: display::DisplayHandle) -> anyhow::Result<()> {
+        let Some(display) = self.displays.get(&handle) else {
+            anyhow::bail!("Display not found");
+        };
+
+        if let Some(overlay_id) = display.overlay_id {
+            self.tasks.send(WayVRTask::DropOverlay(overlay_id));
+        } else {
+            log::warn!("Destroying display without OverlayID set"); // This shouldn't happen, but log it anyways.
+        }
+
+        let mut process_names = Vec::<String>::new();
+
+        self.processes.iter_mut(&mut |_, process| {
+            if process.display_handle() == handle {
+                process_names.push(process.get_name());
+            }
+        });
+
+        if !display.displayed_windows.is_empty() || !process_names.is_empty() {
+            anyhow::bail!(
+                "Display is not empty. Attached processes: {}",
+                process_names.join(", ")
+            );
+        }
+
+        self.manager.cleanup_clients();
+
+        for client in self.manager.clients.iter() {
+            if client.display_handle == handle {
+                // This shouldn't happen, but make sure we are all set to destroy this display
+                anyhow::bail!("Wayland client still exists");
+            }
+        }
+
+        self.displays.remove(&handle);
+
+        self.signals.send(WayVRSignal::BroadcastStateChanged(
+            packet_server::WvrStateChanged::DisplayRemoved,
+        ));
+
+        Ok(())
+    }
+
+    pub fn get_or_create_dashboard_display(
+        &mut self,
+        width: u16,
+        height: u16,
+        name: &str,
+    ) -> anyhow::Result<(bool /* newly created? */, display::DisplayHandle)> {
+        if let Some(handle) = &self.dashboard_display {
+            // ensure it still exists
+            if self.displays.get(handle).is_some() {
+                return Ok((false, *handle));
+            }
+        }
+
+        let new_disp = self.create_display(width, height, name, false)?;
+        self.dashboard_display = Some(new_disp);
+
+        Ok((true, new_disp))
+    }
+
+    // Check if process with given arguments already exists
+    pub fn process_query(
+        &self,
+        display_handle: display::DisplayHandle,
+        exec_path: &str,
+        args: &[&str],
+        _env: &[(&str, &str)],
+    ) -> Option<process::ProcessHandle> {
+        for (idx, cell) in self.processes.vec.iter().enumerate() {
+            if let Some(cell) = &cell {
+                if let process::Process::Managed(process) = &cell.obj {
+                    if process.display_handle != display_handle
+                        || process.exec_path != exec_path
+                        || process.args != args
+                    {
+                        continue;
+                    }
+                    return Some(process::ProcessVec::get_handle(cell, idx));
+                }
+            }
+        }
+
+        None
+    }
+
+    pub fn add_external_process(
+        &mut self,
+        display_handle: display::DisplayHandle,
+        pid: u32,
+    ) -> process::ProcessHandle {
+        self.processes
+            .add(process::Process::External(process::ExternalProcess {
+                display_handle,
+                pid,
+            }))
+    }
+
+    pub fn spawn_process(
+        &mut self,
+        display_handle: display::DisplayHandle,
+        exec_path: &str,
+        args: &[&str],
+        env: &[(&str, &str)],
+        userdata: HashMap<String, String>,
+    ) -> anyhow::Result<process::ProcessHandle> {
+        let display = self
+            .displays
+            .get_mut(&display_handle)
+            .ok_or(anyhow::anyhow!(STR_INVALID_HANDLE_DISP))?;
+
+        let res = display.spawn_process(exec_path, args, env)?;
+
+        let handle = self
+            .processes
+            .add(process::Process::Managed(process::WayVRProcess {
+                auth_key: res.auth_key,
+                child: res.child,
+                display_handle,
+                exec_path: String::from(exec_path),
+                userdata,
+                args: args.iter().map(|x| String::from(*x)).collect(),
+                env: env
+                    .iter()
+                    .map(|(a, b)| (String::from(*a), String::from(*b)))
+                    .collect(),
+            }));
+
+        self.signals.send(WayVRSignal::BroadcastStateChanged(
+            packet_server::WvrStateChanged::ProcessCreated,
+        ));
+
+        Ok(handle)
+    }
+}
@@ -0,0 +1,189 @@
+use std::collections::HashMap;
+
+use wayvr_ipc::packet_server;
+
+use crate::gen_id;
+
+use super::display;
+
+#[derive(Debug)]
+pub struct WayVRProcess {
+    pub auth_key: String,
+    pub child: std::process::Child,
+    pub display_handle: display::DisplayHandle,
+
+    pub exec_path: String,
+    pub args: Vec<String>,
+    pub env: Vec<(String, String)>,
+
+    pub userdata: HashMap<String, String>,
+}
+
+#[derive(Debug)]
+pub struct ExternalProcess {
+    pub pid: u32,
+    pub display_handle: display::DisplayHandle,
+}
+
+#[derive(Debug)]
+pub enum Process {
+    Managed(WayVRProcess),     // Process spawned by WayVR
+    External(ExternalProcess), // External process not directly controlled by us
+}
+
+impl Process {
+    pub fn display_handle(&self) -> display::DisplayHandle {
+        match self {
+            Process::Managed(p) => p.display_handle,
+            Process::External(p) => p.display_handle,
+        }
+    }
+
+    pub fn is_running(&mut self) -> bool {
+        match self {
+            Process::Managed(p) => p.is_running(),
+            Process::External(p) => p.is_running(),
+        }
+    }
+
+    pub fn terminate(&mut self) {
+        match self {
+            Process::Managed(p) => p.terminate(),
+            Process::External(p) => p.terminate(),
+        }
+    }
+
+    pub fn get_name(&self) -> String {
+        match self {
+            Process::Managed(p) => p.get_name().unwrap_or(String::from("unknown")),
+            Process::External(p) => p.get_name().unwrap_or(String::from("unknown")),
+        }
+    }
+
+    pub fn to_packet(&self, handle: ProcessHandle) -> packet_server::WvrProcess {
+        match self {
+            Process::Managed(p) => packet_server::WvrProcess {
+                name: p.get_name().unwrap_or(String::from("unknown")),
+                userdata: p.userdata.clone(),
+                display_handle: p.display_handle.as_packet(),
+                handle: handle.as_packet(),
+            },
+            Process::External(p) => packet_server::WvrProcess {
+                name: p.get_name().unwrap_or(String::from("unknown")),
+                userdata: Default::default(),
+                display_handle: p.display_handle.as_packet(),
+                handle: handle.as_packet(),
+            },
+        }
+    }
+}
+
+impl Drop for WayVRProcess {
+    fn drop(&mut self) {
+        log::info!(
+            "Sending SIGTERM (graceful exit) to process {}",
+            self.exec_path.as_str()
+        );
+        self.terminate();
+    }
+}
+
+impl WayVRProcess {
+    fn is_running(&mut self) -> bool {
+        match self.child.try_wait() {
+            Ok(Some(_exit_status)) => false,
+            Ok(None) => true,
+            Err(e) => {
+                // this shouldn't happen
+                log::error!("Child::try_wait failed: {}", e);
+                false
+            }
+        }
+    }
+
+    fn terminate(&mut self) {
+        unsafe {
+            // Gracefully stop process
+            libc::kill(self.child.id() as i32, libc::SIGTERM);
+        }
+    }
+
+    pub fn get_name(&self) -> Option<String> {
+        get_exec_name_from_pid(self.child.id())
+    }
+}
+
+fn get_exec_name_from_pid(pid: u32) -> Option<String> {
+    let path = format!("/proc/{}/exe", pid);
+    match std::fs::read_link(&path) {
+        Ok(buf) => {
+            if let Some(process_name) = buf.file_name().and_then(|s| s.to_str()) {
+                return Some(String::from(process_name));
+            }
+            None
+        }
+        Err(_) => None,
+    }
+}
+
+impl ExternalProcess {
+    fn is_running(&self) -> bool {
+        if self.pid == 0 {
+            false
+        } else {
+            std::fs::metadata(format!("/proc/{}", self.pid)).is_ok()
+        }
+    }
+
+    fn terminate(&mut self) {
+        if self.pid != 0 {
+            unsafe {
+                // send SIGINT (^C)
+                libc::kill(self.pid as i32, libc::SIGINT);
+            }
+        }
+        self.pid = 0;
+    }
+
+    pub fn get_name(&self) -> Option<String> {
+        get_exec_name_from_pid(self.pid)
+    }
+}
+
+gen_id!(ProcessVec, Process, ProcessCell, ProcessHandle);
+
+pub fn find_by_pid(processes: &ProcessVec, pid: u32) -> Option<ProcessHandle> {
+    for (idx, cell) in processes.vec.iter().enumerate() {
+        if let Some(cell) = cell {
+            match &cell.obj {
+                Process::Managed(wayvr_process) => {
+                    if wayvr_process.child.id() == pid {
+                        return Some(ProcessVec::get_handle(cell, idx));
+                    }
+                }
+                Process::External(external_process) => {
+                    if external_process.pid == pid {
+                        return Some(ProcessVec::get_handle(cell, idx));
+                    }
+                }
+            }
+        }
+    }
+    None
+}
+
+impl ProcessHandle {
+    pub fn from_packet(handle: packet_server::WvrProcessHandle) -> Self {
+        Self {
+            generation: handle.generation,
+            idx: handle.idx,
+        }
+    }
+
+    pub fn as_packet(&self) -> packet_server::WvrProcessHandle {
+        packet_server::WvrProcessHandle {
+            idx: self.idx,
+            generation: self.generation,
+        }
+    }
+}
@@ -0,0 +1,678 @@
+use crate::state::AppState;
+
+use super::{display, process, window, TickTask, WayVRSignal};
+use bytes::BufMut;
+use glam::Vec3A;
+use interprocess::local_socket::{self, traits::Listener, ToNsName};
+use smallvec::SmallVec;
+use std::io::{Read, Write};
+use wayvr_ipc::{
+    ipc::{self},
+    packet_client::{self, PacketClient},
+    packet_server::{self, PacketServer, WlxInputStatePointer},
+};
+
+pub struct AuthInfo {
+    pub client_name: String,
+    pub protocol_version: u32, // client protocol version
+}
+
+pub struct Connection {
+    alive: bool,
+    conn: local_socket::Stream,
+    next_packet: Option<u32>,
+    auth: Option<AuthInfo>,
+}
+
+pub fn send_packet(conn: &mut local_socket::Stream, data: &[u8]) -> anyhow::Result<()> {
+    let mut bytes = bytes::BytesMut::new();
+
+    // packet size
+    bytes.put_u32(data.len() as u32);
+
+    // packet data
+    bytes.put_slice(data);
+
+    conn.write_all(&bytes)?;
+
+    Ok(())
+}
+
+fn read_check(expected_size: u32, res: std::io::Result<usize>) -> bool {
+    match res {
+        Ok(count) => {
+            if count == 0 {
+                return false;
+            }
+            if count as u32 != expected_size {
+                log::error!("count {} is not {}", count, expected_size);
+                false
+            } else {
+                true // read succeeded
+            }
+        }
+        Err(_e) => {
+            //log::error!("failed to get packet size: {}", e);
+            false
+        }
+    }
+}
+
+type Payload = SmallVec<[u8; 64]>;
+
+fn read_payload(conn: &mut local_socket::Stream, size: u32) -> Option<Payload> {
+    let mut payload = Payload::new();
+    payload.resize(size as usize, 0);
+    if !read_check(size, conn.read(&mut payload)) {
+        None
+    } else {
+        Some(payload)
+    }
+}
+
+pub struct TickParams<'a> {
+    pub state: &'a mut super::WayVRState,
+    pub tasks: &'a mut Vec<TickTask>,
+    pub app: &'a AppState,
+}
+
+pub fn gen_args_vec(input: &str) -> Vec<&str> {
+    input.split_whitespace().collect()
+}
+
+pub fn gen_env_vec(input: &[String]) -> Vec<(&str, &str)> {
+    let res = input
+        .iter()
+        .filter_map(|e| e.as_str().split_once('='))
+        .collect();
+    res
+}
+
+impl Connection {
+    fn new(conn: local_socket::Stream) -> Self {
+        Self {
+            conn,
+            alive: true,
+            auth: None,
+            next_packet: None,
+        }
+    }
+
+    fn kill(&mut self, reason: &str) {
+        let _dont_care = send_packet(
+            &mut self.conn,
+            &ipc::data_encode(&PacketServer::Disconnect(packet_server::Disconnect {
+                reason: String::from(reason),
+            })),
+        );
+        self.alive = false;
+    }
+
+    fn process_handshake(&mut self, handshake: &packet_client::Handshake) -> anyhow::Result<()> {
+        if self.auth.is_some() {
+            anyhow::bail!("You were already authenticated");
+        }
+
+        if handshake.protocol_version != ipc::PROTOCOL_VERSION {
+            anyhow::bail!(
+                "Unsupported protocol version {}",
+                handshake.protocol_version
+            );
+        }
+
+        if handshake.magic != ipc::CONNECTION_MAGIC {
+            anyhow::bail!("Invalid magic");
+        }
+
+        match handshake.client_name.len() {
+            0 => anyhow::bail!("Client name is empty"),
+            1..32 => {}
+            _ => anyhow::bail!("Client name is too long"),
+        }
+
+        log::info!("IPC: Client \"{}\" connected.", handshake.client_name);
+
+        self.auth = Some(AuthInfo {
+            client_name: handshake.client_name.clone(),
+            protocol_version: handshake.protocol_version,
+        });
+
+        // Send auth response
+        send_packet(
+            &mut self.conn,
+            &ipc::data_encode(&PacketServer::HandshakeSuccess(
+                packet_server::HandshakeSuccess {
+                    runtime: String::from("wlx-overlay-s"),
+                },
+            )),
+        )?;
+
+        Ok(())
+    }
+
+    fn handle_wvr_display_list(
+        &mut self,
+        params: &TickParams,
+        serial: ipc::Serial,
+    ) -> anyhow::Result<()> {
+        let list: Vec<packet_server::WvrDisplay> = params
+            .state
+            .displays
+            .vec
+            .iter()
+            .enumerate()
+            .filter_map(|(idx, opt_cell)| {
+                let Some(cell) = opt_cell else {
+                    return None;
+                };
+                let display = &cell.obj;
+                Some(display.as_packet(display::DisplayHandle::new(idx as u32, cell.generation)))
+            })
+            .collect();
+
+        send_packet(
+            &mut self.conn,
+            &ipc::data_encode(&PacketServer::WvrDisplayListResponse(
+                serial,
+                packet_server::WvrDisplayList { list },
+            )),
+        )?;
+
+        Ok(())
+    }
+
+    fn handle_wlx_input_state(
+        &mut self,
+        params: &TickParams,
+        serial: ipc::Serial,
+    ) -> anyhow::Result<()> {
+        let input_state = &params.app.input_state;
+
+        let to_arr = |vec: &Vec3A| -> [f32; 3] { [vec.x, vec.y, vec.z] };
+
+        send_packet(
+            &mut self.conn,
+            &ipc::data_encode(&PacketServer::WlxInputStateResponse(
+                serial,
+                packet_server::WlxInputState {
+                    hmd_pos: to_arr(&input_state.hmd.translation),
+                    left: WlxInputStatePointer {
+                        pos: to_arr(&input_state.pointers[0].raw_pose.translation),
+                    },
+                    right: WlxInputStatePointer {
+                        pos: to_arr(&input_state.pointers[0].raw_pose.translation),
+                    },
+                },
+            )),
+        )?;
+
+        Ok(())
+    }
+
+    fn handle_wvr_display_create(
+        &mut self,
+        params: &mut TickParams,
+        serial: ipc::Serial,
+        packet_params: packet_client::WvrDisplayCreateParams,
+    ) -> anyhow::Result<()> {
+        let display_handle = params.state.create_display(
+            packet_params.width,
+            packet_params.height,
+            &packet_params.name,
+            false,
+        )?;
+
+        params.tasks.push(TickTask::NewDisplay(
+            packet_params.clone(),
+            Some(display_handle),
+        ));
+
+        send_packet(
+            &mut self.conn,
+            &ipc::data_encode(&PacketServer::WvrDisplayCreateResponse(
+                serial,
+                display_handle.as_packet(),
+            )),
+        )?;
+        Ok(())
+    }
+
+    fn handle_wvr_display_remove(
+        &mut self,
+        params: &mut TickParams,
+        serial: ipc::Serial,
+        handle: packet_server::WvrDisplayHandle,
+    ) -> anyhow::Result<()> {
+        let res = params
+            .state
+            .destroy_display(display::DisplayHandle::from_packet(handle))
+            .map_err(|e| format!("{:?}", e));
+
+        send_packet(
+            &mut self.conn,
+            &ipc::data_encode(&PacketServer::WvrDisplayRemoveResponse(serial, res)),
+        )?;
+        Ok(())
+    }
+
+    fn handle_wvr_display_set_visible(
+        &mut self,
+        params: &mut TickParams,
+        handle: packet_server::WvrDisplayHandle,
+        visible: bool,
+    ) -> anyhow::Result<()> {
+        params.state.signals.send(WayVRSignal::DisplayVisibility(
+            display::DisplayHandle::from_packet(handle),
+            visible,
+        ));
+        Ok(())
+    }
+
+    fn handle_wvr_display_set_window_layout(
+        &mut self,
+        params: &mut TickParams,
+        handle: packet_server::WvrDisplayHandle,
+        layout: packet_server::WvrDisplayWindowLayout,
+    ) -> anyhow::Result<()> {
+        params.state.signals.send(WayVRSignal::DisplayWindowLayout(
+            display::DisplayHandle::from_packet(handle),
+            layout,
+        ));
+        Ok(())
+    }
+
+    fn handle_wvr_display_window_list(
+        &mut self,
+        params: &mut TickParams,
+        serial: ipc::Serial,
+        display_handle: packet_server::WvrDisplayHandle,
+    ) -> anyhow::Result<()> {
+        let mut send = |list: Option<packet_server::WvrWindowList>| -> anyhow::Result<()> {
+            send_packet(
+                &mut self.conn,
+                &ipc::data_encode(&PacketServer::WvrDisplayWindowListResponse(serial, list)),
+            )
+        };
+
+        let Some(display) = params
+            .state
+            .displays
+            .get(&display::DisplayHandle::from_packet(display_handle.clone()))
+        else {
+            return send(None);
+        };
+
+        send(Some(packet_server::WvrWindowList {
+            list: display
+                .displayed_windows
+                .iter()
+                .filter_map(|disp_win| {
+                    params
+                        .state
+                        .wm
+                        .borrow_mut()
+                        .windows
+                        .get(&disp_win.window_handle)
+                        .map(|win| packet_server::WvrWindow {
+                            handle: window::WindowHandle::as_packet(&disp_win.window_handle),
+                            process_handle: process::ProcessHandle::as_packet(
+                                &disp_win.process_handle,
+                            ),
+                            pos_x: win.pos_x,
+                            pos_y: win.pos_y,
+                            size_x: win.size_x,
+                            size_y: win.size_y,
+                            visible: win.visible,
+                            display_handle: display_handle.clone(),
+                        })
+                })
+                .collect::<Vec<_>>(),
+        }))
+    }
+
+    fn handle_wvr_window_set_visible(
+        &mut self,
+        params: &mut TickParams,
+        handle: packet_server::WvrWindowHandle,
+        visible: bool,
+    ) -> anyhow::Result<()> {
+        let mut to_resize = None;
+
+        if let Some(window) = params
+            .state
+            .wm
+            .borrow_mut()
+            .windows
+            .get_mut(&window::WindowHandle::from_packet(handle))
+        {
+            window.visible = visible;
+            to_resize = Some(window.display_handle);
+        }
+
+        if let Some(to_resize) = to_resize {
+            if let Some(display) = params.state.displays.get_mut(&to_resize) {
+                display.reposition_windows();
+                display.trigger_rerender();
+            }
+        }
+
+        Ok(())
+    }
+
+    fn handle_wvr_process_launch(
+        &mut self,
+        params: &mut TickParams,
+        serial: ipc::Serial,
+        packet_params: packet_client::WvrProcessLaunchParams,
+    ) -> anyhow::Result<()> {
+        let args_vec = gen_args_vec(&packet_params.args);
+        let env_vec = gen_env_vec(&packet_params.env);
+
+        let res = params.state.spawn_process(
+            super::display::DisplayHandle::from_packet(packet_params.target_display),
+            &packet_params.exec,
+            &args_vec,
+            &env_vec,
+            packet_params.userdata,
+        );
+
+        let res = res.map(|r| r.as_packet()).map_err(|e| e.to_string());
+
+        send_packet(
+            &mut self.conn,
+            &ipc::data_encode(&PacketServer::WvrProcessLaunchResponse(serial, res)),
+        )?;
+
+        Ok(())
+    }
+
+    fn handle_wvr_display_get(
+        &mut self,
+        params: &TickParams,
+        serial: ipc::Serial,
+        display_handle: packet_server::WvrDisplayHandle,
+    ) -> anyhow::Result<()> {
+        let native_handle = &display::DisplayHandle::from_packet(display_handle.clone());
+        let disp = params
+            .state
+            .displays
+            .get(native_handle)
+            .map(|disp| disp.as_packet(*native_handle));
+
+        send_packet(
+            &mut self.conn,
+            &ipc::data_encode(&PacketServer::WvrDisplayGetResponse(serial, disp)),
+        )?;
+
+        Ok(())
+    }
+
+    fn handle_wvr_process_list(
+        &mut self,
+        params: &TickParams,
+        serial: ipc::Serial,
+    ) -> anyhow::Result<()> {
+        let list: Vec<packet_server::WvrProcess> = params
+            .state
+            .processes
+            .vec
+            .iter()
+            .enumerate()
+            .filter_map(|(idx, opt_cell)| {
+                let Some(cell) = opt_cell else {
+                    return None;
+                };
+                let process = &cell.obj;
+                Some(process.to_packet(process::ProcessHandle::new(idx as u32, cell.generation)))
+            })
+            .collect();
+
+        send_packet(
+            &mut self.conn,
+            &ipc::data_encode(&PacketServer::WvrProcessListResponse(
+                serial,
+                packet_server::WvrProcessList { list },
+            )),
+        )?;
+
+        Ok(())
+    }
+
+    // This request doesn't return anything to the client
+    fn handle_wvr_process_terminate(
+        &mut self,
+        params: &mut TickParams,
+        process_handle: packet_server::WvrProcessHandle,
+    ) -> anyhow::Result<()> {
+        let native_handle = &process::ProcessHandle::from_packet(process_handle.clone());
+        let process = params.state.processes.get_mut(native_handle);
+
+        let Some(process) = process else {
+            return Ok(());
+        };
+
+        process.terminate();
+
+        Ok(())
+    }
+
+    fn handle_wvr_process_get(
+        &mut self,
+        params: &TickParams,
+        serial: ipc::Serial,
+        process_handle: packet_server::WvrProcessHandle,
+    ) -> anyhow::Result<()> {
+        let native_handle = &process::ProcessHandle::from_packet(process_handle.clone());
+        let process = params
+            .state
+            .processes
+            .get(native_handle)
+            .map(|process| process.to_packet(*native_handle));
+
+        send_packet(
+            &mut self.conn,
+            &ipc::data_encode(&PacketServer::WvrProcessGetResponse(serial, process)),
+        )?;
+
+        Ok(())
+    }
+
+    fn handle_wlx_haptics(
+        &mut self,
+        params: &mut TickParams,
+        haptics_params: packet_client::WlxHapticsParams,
+    ) -> anyhow::Result<()> {
+        params
+            .state
+            .tasks
+            .send(super::WayVRTask::Haptics(crate::backend::input::Haptics {
+                duration: haptics_params.duration,
+                frequency: haptics_params.frequency,
+                intensity: haptics_params.intensity,
+            }));
+        Ok(())
+    }
+
+    fn process_payload(&mut self, params: &mut TickParams, payload: Payload) -> anyhow::Result<()> {
+        let packet: PacketClient = ipc::data_decode(&payload)?;
+
+        if let PacketClient::Handshake(handshake) = &packet {
+            self.process_handshake(handshake)?;
+            return Ok(());
+        }
+
+        match packet {
+            PacketClient::Handshake(_) => unreachable!(), // handled previously
+            PacketClient::WlxInputState(serial) => {
+                self.handle_wlx_input_state(params, serial)?;
+            }
+            PacketClient::WvrDisplayList(serial) => {
+                self.handle_wvr_display_list(params, serial)?;
+            }
+            PacketClient::WvrDisplayGet(serial, display_handle) => {
+                self.handle_wvr_display_get(params, serial, display_handle)?;
+            }
+            PacketClient::WvrDisplayRemove(serial, display_handle) => {
+                self.handle_wvr_display_remove(params, serial, display_handle)?;
+            }
+            PacketClient::WvrDisplaySetVisible(display_handle, visible) => {
+                self.handle_wvr_display_set_visible(params, display_handle, visible)?;
+            }
+            PacketClient::WvrDisplaySetWindowLayout(display_handle, layout) => {
+                self.handle_wvr_display_set_window_layout(params, display_handle, layout)?;
+            }
+            PacketClient::WvrDisplayWindowList(serial, display_handle) => {
+                self.handle_wvr_display_window_list(params, serial, display_handle)?;
+            }
+            PacketClient::WvrWindowSetVisible(window_handle, visible) => {
+                self.handle_wvr_window_set_visible(params, window_handle, visible)?;
+            }
+            PacketClient::WvrProcessGet(serial, process_handle) => {
+                self.handle_wvr_process_get(params, serial, process_handle)?;
+            }
+            PacketClient::WvrProcessList(serial) => {
+                self.handle_wvr_process_list(params, serial)?;
+            }
+            PacketClient::WvrProcessLaunch(serial, packet_params) => {
+                self.handle_wvr_process_launch(params, serial, packet_params)?;
+            }
+            PacketClient::WvrDisplayCreate(serial, packet_params) => {
+                self.handle_wvr_display_create(params, serial, packet_params)?;
+            }
+            PacketClient::WvrProcessTerminate(process_handle) => {
+                self.handle_wvr_process_terminate(params, process_handle)?;
+            }
+            PacketClient::WlxHaptics(haptics_params) => {
+                self.handle_wlx_haptics(params, haptics_params)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn process_check_payload(&mut self, params: &mut TickParams, payload: Payload) -> bool {
+        log::debug!("payload size {}", payload.len());
+
+        if let Err(e) = self.process_payload(params, payload) {
+            log::error!("Invalid payload from the client, closing connection: {}", e);
+            // send also error message directly to the client before disconnecting
+            self.kill(format!("{}", e).as_str());
+            false
+        } else {
+            true
+        }
+    }
+
+    fn read_packet(&mut self, params: &mut TickParams) -> bool {
+        if let Some(payload_size) = self.next_packet {
+            let Some(payload) = read_payload(&mut self.conn, payload_size) else {
+                // still failed to read payload, try in next tick
+                return false;
+            };
+
+            if !self.process_check_payload(params, payload) {
+                return false;
+            }
+
+            self.next_packet = None;
+        }
+
+        let mut buf_packet_header: [u8; 4] = [0; 4];
+        if !read_check(4, self.conn.read(&mut buf_packet_header)) {
+            return false;
+        }
+
+        let payload_size = u32::from_be_bytes(buf_packet_header[0..4].try_into().unwrap()); // 0-3 bytes (u32 size)
+
+        let size_limit: u32 = 128 * 1024;
+
+        if payload_size > size_limit {
+            // over 128 KiB?
+            log::error!(
+                "Client sent a packet header with the size over {} bytes, closing connection.",
+                size_limit
+            );
+            self.kill("Too big packet received (over 128 KiB)");
+            return false;
+        }
+
+        let Some(payload) = read_payload(&mut self.conn, payload_size) else {
+            // failed to read payload, try in next tick
+            self.next_packet = Some(payload_size);
+            return false;
+        };
+
+        if !self.process_check_payload(params, payload) {
+            return false;
+        }
+
+        true
+    }
+
+    fn tick(&mut self, params: &mut TickParams) {
+        while self.read_packet(params) {}
+    }
+}
+
+impl Drop for Connection {
+    fn drop(&mut self) {
+        log::info!("Connection closed");
+    }
+}
+
+pub struct WayVRServer {
+    listener: local_socket::Listener,
+    connections: Vec<Connection>,
+}
+
+impl WayVRServer {
+    pub fn new() -> anyhow::Result<Self> {
+        let printname = "/tmp/wayvr_ipc.sock";
+        let name = printname.to_ns_name::<local_socket::GenericNamespaced>()?;
+        let opts = local_socket::ListenerOptions::new()
+            .name(name)
+            .nonblocking(local_socket::ListenerNonblockingMode::Both);
+        let listener = match opts.create_sync() {
+            Ok(listener) => listener,
+            Err(e) => anyhow::bail!("Failed to start WayVRServer IPC listener. Reason: {}", e),
+        };
+
+        log::info!("WayVRServer IPC running at {}", printname);
+
+        Ok(Self {
+            listener,
+            connections: Vec::new(),
+        })
+    }
+
+    fn accept_connections(&mut self) {
+        let Ok(conn) = self.listener.accept() else {
+            return; // No new connection or other error
+        };
+
+        self.connections.push(Connection::new(conn));
+    }
+
+    fn tick_connections(&mut self, params: &mut TickParams) {
+        for c in &mut self.connections {
+            c.tick(params);
+        }
+
+        // remove killed connections
+        self.connections.retain(|c| c.alive);
+    }
+
+    pub fn tick(&mut self, params: &mut TickParams) -> anyhow::Result<()> {
+        self.accept_connections();
+        self.tick_connections(params);
+        Ok(())
+    }
+
+    pub fn broadcast(&mut self, packet: packet_server::PacketServer) {
+        for connection in &mut self.connections {
+            if let Err(e) = send_packet(&mut connection.conn, &ipc::data_encode(&packet)) {
+                log::error!("failed to broadcast packet: {:?}", e);
+            }
+        }
+    }
+}
@@ -0,0 +1,54 @@
+use super::egl_data;
+use smithay::backend::{egl as smithay_egl, renderer::gles::ffi};
+
+pub fn get_egl_display(data: &egl_data::EGLData) -> anyhow::Result<smithay_egl::EGLDisplay> {
+	Ok(unsafe { smithay_egl::EGLDisplay::from_raw(data.display.as_ptr(), data.config.as_ptr())? })
+}
+
+pub fn get_egl_context(
+	data: &egl_data::EGLData,
+	display: &smithay_egl::EGLDisplay,
+) -> anyhow::Result<smithay_egl::EGLContext> {
+	let display_ptr = display.get_display_handle().handle;
+	debug_assert!(display_ptr == data.display.as_ptr());
+	let config_ptr = data.config.as_ptr();
+	let context_ptr = data.context.as_ptr();
+	Ok(unsafe { smithay_egl::EGLContext::from_raw(display_ptr, config_ptr, context_ptr)? })
+}
+
+pub fn create_framebuffer_texture(
+	gl: &ffi::Gles2,
+	width: u32,
+	height: u32,
+	tex_format: u32,
+	internal_format: u32,
+) -> u32 {
+	unsafe {
+		let mut tex = 0;
+		gl.GenTextures(1, &mut tex);
+		gl.BindTexture(ffi::TEXTURE_2D, tex);
+		gl.TexParameteri(
+			ffi::TEXTURE_2D,
+			ffi::TEXTURE_MIN_FILTER,
+			ffi::NEAREST as i32,
+		);
+		gl.TexParameteri(
+			ffi::TEXTURE_2D,
+			ffi::TEXTURE_MAG_FILTER,
+			ffi::NEAREST as i32,
+		);
+		gl.TexImage2D(
+			ffi::TEXTURE_2D,
+			0,
+			internal_format as i32,
+			width as i32,
+			height as i32,
+			0,
+			tex_format,
+			ffi::UNSIGNED_BYTE,
+			std::ptr::null(),
+		);
+		gl.BindTexture(ffi::TEXTURE_2D, 0);
+		tex
+	}
+}
@@ -0,0 +1,9 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+
+// Returns milliseconds since unix epoch
+pub fn get_millis() -> u64 {
+	SystemTime::now()
+		.duration_since(UNIX_EPOCH)
+		.unwrap()
+		.as_millis() as u64
+}
@@ -0,0 +1,98 @@
+use smithay::wayland::shell::xdg::ToplevelSurface;
+use wayvr_ipc::packet_server;
+
+use crate::gen_id;
+
+use super::display;
+
+#[derive(Debug)]
+pub struct Window {
+    pub pos_x: i32,
+    pub pos_y: i32,
+    pub size_x: u32,
+    pub size_y: u32,
+    pub visible: bool,
+    pub toplevel: ToplevelSurface,
+    pub display_handle: display::DisplayHandle,
+}
+
+impl Window {
+    pub fn new(display_handle: display::DisplayHandle, toplevel: &ToplevelSurface) -> Self {
+        Self {
+            pos_x: 0,
+            pos_y: 0,
+            size_x: 0,
+            size_y: 0,
+            visible: true,
+            toplevel: toplevel.clone(),
+            display_handle,
+        }
+    }
+
+    pub fn set_pos(&mut self, pos_x: i32, pos_y: i32) {
+        self.pos_x = pos_x;
+        self.pos_y = pos_y;
+    }
+
+    pub fn set_size(&mut self, size_x: u32, size_y: u32) {
+        self.toplevel.with_pending_state(|state| {
+            //state.bounds = Some((size_x as i32, size_y as i32).into());
+            state.size = Some((size_x as i32, size_y as i32).into());
+        });
+        self.toplevel.send_configure();
+
+        self.size_x = size_x;
+        self.size_y = size_y;
+    }
+}
+
+#[derive(Debug)]
+pub struct WindowManager {
+    pub windows: WindowVec,
+}
+
+impl WindowManager {
+    pub fn new() -> Self {
+        Self {
+            windows: WindowVec::new(),
+        }
+    }
+
+    pub fn find_window_handle(&self, toplevel: &ToplevelSurface) -> Option<WindowHandle> {
+        for (idx, cell) in self.windows.vec.iter().enumerate() {
+            if let Some(cell) = cell {
+                let window = &cell.obj;
+                if window.toplevel == *toplevel {
+                    return Some(WindowVec::get_handle(cell, idx));
+                }
+            }
+        }
+        None
+    }
+
+    pub fn create_window(
+        &mut self,
+        display_handle: display::DisplayHandle,
+        toplevel: &ToplevelSurface,
+    ) -> WindowHandle {
+        self.windows.add(Window::new(display_handle, toplevel))
+    }
+}
+
+gen_id!(WindowVec, Window, WindowCell, WindowHandle);
+
+impl WindowHandle {
+    pub fn from_packet(handle: packet_server::WvrWindowHandle) -> Self {
+        Self {
+            generation: handle.generation,
+            idx: handle.idx,
+        }
+    }
+
+    pub fn as_packet(&self) -> packet_server::WvrWindowHandle {
+        packet_server::WvrWindowHandle {
+            idx: self.idx,
+            generation: self.generation,
+        }
+    }
+}
@@ -2,13 +2,12 @@ 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::overlays::toast::DisplayMethod;
 use crate::overlays::toast::ToastTopic;
 use crate::state::LeftRight;
 use anyhow::bail;
+use chrono::Offset;
 use config::Config;
 use config::File;
 use glam::vec3a;
@@ -97,6 +96,10 @@ pub fn def_pw_tokens() -> PwTokenMap {
    AStrMap::new()
 }

+fn def_mouse_move_interval_ms() -> u32 {
+    10 // 100fps
+}
+
 fn def_click_freeze_time_ms() -> u32 {
    300
 }
@@ -129,6 +132,23 @@ fn def_osc_port() -> u16 {
    9000
 }

+fn def_empty_vec_string() -> Vec<String> {
+    Vec::new()
+}
+
+fn def_timezones() -> Vec<String> {
+    let offset = chrono::Local::now().offset().fix();
+
+    const EMEA: i32 = -60 * 60; // UTC-1
+    const APAC: i32 = 5 * 60 * 60; // UTC+5
+
+    match offset.local_minus_utc() {
+        i32::MIN..EMEA => vec!["Europe/Paris".into(), "Asia/Tokyo".into()],
+        EMEA..APAC => vec!["America/New_York".into(), "Asia/Tokyo".into()],
+        APAC..=i32::MAX => vec!["Europe/Paris".into(), "America/New_York".into()],
+    }
+}
+
 fn def_screens() -> AStrSet {
    AStrSet::new()
 }
@@ -175,6 +195,9 @@ pub struct GeneralConfig {
    #[serde(default = "def_click_freeze_time_ms")]
    pub click_freeze_time_ms: u32,

+    #[serde(default = "def_mouse_move_interval_ms")]
+    pub mouse_move_interval_ms: u32,
+
    #[serde(default = "def_true")]
    pub notifications_enabled: bool,

@@ -262,10 +285,13 @@ pub struct GeneralConfig {
    #[serde(default = "def_true")]
    pub use_skybox: bool,

+    #[serde(default = "def_true")]
+    pub use_passthrough: bool,
+
    #[serde(default = "def_max_height")]
    pub screen_max_height: u16,

-    #[serde(default = "def_false")]
+    #[serde(default = "def_true")]
    pub screen_render_down: bool,

    #[serde(default = "def_point3")]
@@ -273,6 +299,15 @@ pub struct GeneralConfig {

    #[serde(default = "def_false")]
    pub space_rotate_unlocked: bool,
+
+    #[serde(default = "def_empty_vec_string")]
+    pub alt_click_down: Vec<String>,
+
+    #[serde(default = "def_empty_vec_string")]
+    pub alt_click_up: Vec<String>,
+
+    #[serde(default = "def_timezones")]
+    pub timezones: Vec<String>,
 }

 impl GeneralConfig {
@@ -297,18 +332,20 @@ impl GeneralConfig {
    }
 }

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

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

 #[derive(Clone, Copy)]
@@ -318,6 +355,8 @@ pub enum ConfigType {
    Watch,
    Settings,
    Anchor,
+    #[allow(dead_code)]
+    WayVR,
 }

 pub fn load_known_yaml<T>(config_type: ConfigType) -> T
@@ -349,14 +388,20 @@ pub fn load_custom_ui(name: &str) -> anyhow::Result<ModularUiConfig> {
    Ok(serde_yaml::from_str(&yaml_data)?)
 }

-pub fn load_general() -> GeneralConfig {
+pub fn load_config_with_conf_d<ConfigData>(
+    root_config_filename: &str,
+    ctype: config_io::ConfigRoot,
+) -> ConfigData
+where
+    ConfigData: for<'de> Deserialize<'de>,
+{
    let mut settings_builder = Config::builder();

    // Add files from conf.d directory
-    let path_conf_d = get_conf_d_path();
+    let path_conf_d = ctype.get_conf_d_path();

-    for mut base_conf in [CONFIG_ROOT_PATH.clone(), path_conf_d.clone()] {
-        base_conf.push("config.yaml");
+    for mut base_conf in [config_io::get_config_root(), path_conf_d.clone()] {
+        base_conf.push(root_config_filename);
        if base_conf.exists() {
            log::info!("Loading config file: {}", base_conf.to_string_lossy());
            settings_builder = settings_builder.add_source(File::from(base_conf));
@@ -382,7 +427,7 @@ pub fn load_general() -> GeneralConfig {
    }

    match settings_builder.build() {
-        Ok(settings) => match settings.try_deserialize::<GeneralConfig>() {
+        Ok(settings) => match settings.try_deserialize::<ConfigData>() {
            Ok(config) => config,
            Err(e) => {
                panic!("Failed to deserialize settings: {}", e);
@@ -394,6 +439,10 @@ pub fn load_general() -> GeneralConfig {
    }
 }

+pub fn load_general() -> GeneralConfig {
+    load_config_with_conf_d::<GeneralConfig>("config.yaml", config_io::ConfigRoot::Generic)
+}
+
 // Config that is saved from the settings panel

 #[derive(Serialize)]
@@ -411,10 +460,11 @@ pub struct AutoSettings {
 }

 fn get_settings_path() -> PathBuf {
-    let mut path = config_io::get_conf_d_path();
-    path.push("zz-saved-config.json5");
-    path
+    config_io::ConfigRoot::Generic
+        .get_conf_d_path()
+        .join("zz-saved-config.json5")
 }
+
 pub fn save_settings(config: &GeneralConfig) -> anyhow::Result<()> {
    let conf = AutoSettings {
        watch_pos: config.watch_pos,
@@ -445,9 +495,9 @@ pub struct AutoState {
 }

 fn get_state_path() -> PathBuf {
-    let mut path = config_io::get_conf_d_path();
-    path.push("zz-saved-state.json5");
-    path
+    config_io::ConfigRoot::Generic
+        .get_conf_d_path()
+        .join("zz-saved-state.json5")
 }

 pub fn save_layout(config: &GeneralConfig) -> anyhow::Result<()> {
@@ -1,13 +1,16 @@
 use log::error;
 use once_cell::sync::Lazy;
-use std::{
-    fs::{self, create_dir},
-    path::PathBuf,
-};
+use std::path::PathBuf;
+
+pub enum ConfigRoot {
+    Generic,
+    #[allow(dead_code)]
+    WayVR,
+}

 const FALLBACK_CONFIG_PATH: &str = "/tmp/wlxoverlay";

-pub static CONFIG_ROOT_PATH: Lazy<PathBuf> = Lazy::new(|| {
+static CONFIG_ROOT_PATH: Lazy<PathBuf> = Lazy::new(|| {
    if let Ok(xdg_dirs) = xdg::BaseDirectories::new() {
        let mut dir = xdg_dirs.get_config_home();
        dir.push("wlxoverlay");
@@ -21,33 +24,38 @@ pub static CONFIG_ROOT_PATH: Lazy<PathBuf> = Lazy::new(|| {
    PathBuf::from(FALLBACK_CONFIG_PATH)
 });

-pub fn get_conf_d_path() -> PathBuf {
-    let mut config_root = CONFIG_ROOT_PATH.clone();
-    config_root.push("conf.d");
-    config_root
+pub fn get_config_root() -> PathBuf {
+    CONFIG_ROOT_PATH.clone()
 }

-// Make sure config directory is present and return root config path
-pub fn ensure_config_root() -> PathBuf {
-    let path = CONFIG_ROOT_PATH.clone();
-    let _ = create_dir(&path);
+impl ConfigRoot {
+    pub fn get_conf_d_path(&self) -> PathBuf {
+        get_config_root().join(match self {
+            ConfigRoot::Generic => "conf.d",
+            ConfigRoot::WayVR => "wayvr.conf.d",
+        })
+    }

-    let path_conf_d = get_conf_d_path();
-    let _ = create_dir(path_conf_d);
-    path
+    // Make sure config directory is present and return root config path
+    pub fn ensure_dir(&self) -> PathBuf {
+        let path = get_config_root();
+        let _ = std::fs::create_dir(&path);
+
+        let path_conf_d = self.get_conf_d_path();
+        let _ = std::fs::create_dir(path_conf_d);
+        path
+    }
 }

-fn get_config_file_path(filename: &str) -> PathBuf {
-    let mut config_root = CONFIG_ROOT_PATH.clone();
-    config_root.push(filename);
-    config_root
+pub fn get_config_file_path(filename: &str) -> PathBuf {
+    get_config_root().join(filename)
 }

 pub fn load(filename: &str) -> Option<String> {
    let path = get_config_file_path(filename);
-    log::info!("Loading config {}", path.to_string_lossy());
+    log::info!("Loading config: {}", path.to_string_lossy());

-    if let Ok(data) = fs::read_to_string(path) {
+    if let Ok(data) = std::fs::read_to_string(path) {
        Some(data)
    } else {
        None
@@ -0,0 +1,245 @@
+#[cfg(not(feature = "wayvr"))]
+compile_error!("WayVR feature is not enabled");
+
+use std::{
+    cell::RefCell,
+    collections::{BTreeMap, HashMap},
+    rc::Rc,
+    sync::Arc,
+};
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    backend::{
+        overlay::RelativeTo,
+        task::{TaskContainer, TaskType},
+        wayvr,
+    },
+    config::load_config_with_conf_d,
+    config_io,
+    gui::modular::button::WayVRAction,
+    overlays::wayvr::WayVRData,
+};
+
+// Flat version of RelativeTo
+#[derive(Clone, Deserialize, Serialize)]
+pub enum AttachTo {
+    None,
+    HandLeft,
+    HandRight,
+    Head,
+    Stage,
+}
+
+impl AttachTo {
+    pub fn get_relative_to(&self) -> RelativeTo {
+        match self {
+            AttachTo::None => RelativeTo::None,
+            AttachTo::HandLeft => RelativeTo::Hand(0),
+            AttachTo::HandRight => RelativeTo::Hand(1),
+            AttachTo::Stage => RelativeTo::Stage,
+            AttachTo::Head => RelativeTo::Head,
+        }
+    }
+
+    pub fn from_packet(input: &wayvr_ipc::packet_client::AttachTo) -> AttachTo {
+        match input {
+            wayvr_ipc::packet_client::AttachTo::None => AttachTo::None,
+            wayvr_ipc::packet_client::AttachTo::HandLeft => AttachTo::HandLeft,
+            wayvr_ipc::packet_client::AttachTo::HandRight => AttachTo::HandRight,
+            wayvr_ipc::packet_client::AttachTo::Head => AttachTo::Head,
+            wayvr_ipc::packet_client::AttachTo::Stage => AttachTo::Stage,
+        }
+    }
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+pub struct Rotation {
+    pub axis: [f32; 3],
+    pub angle: f32,
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+pub struct WayVRAppEntry {
+    pub name: String,
+    pub target_display: String,
+    pub exec: String,
+    pub args: Option<String>,
+    pub env: Option<Vec<String>>,
+    pub shown_at_start: Option<bool>,
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+pub struct WayVRDisplay {
+    pub width: u16,
+    pub height: u16,
+    pub scale: Option<f32>,
+    pub rotation: Option<Rotation>,
+    pub pos: Option<[f32; 3]>,
+    pub attach_to: Option<AttachTo>,
+    pub primary: Option<bool>,
+}
+
+#[derive(Clone, Deserialize, Serialize)]
+pub struct WayVRCatalog {
+    pub apps: Vec<WayVRAppEntry>,
+}
+
+impl WayVRCatalog {
+    pub fn get_app(&self, name: &str) -> Option<&WayVRAppEntry> {
+        self.apps.iter().find(|&app| app.name.as_str() == name)
+    }
+}
+
+fn def_false() -> bool {
+    false
+}
+
+fn def_true() -> bool {
+    true
+}
+
+fn def_autohide_delay() -> u32 {
+    750
+}
+
+fn def_keyboard_repeat_delay() -> u32 {
+    200
+}
+
+fn def_keyboard_repeat_rate() -> u32 {
+    50
+}
+
+fn def_version() -> u32 {
+    1
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct WayVRDashboard {
+    pub exec: String,
+    pub args: Option<String>,
+    pub env: Option<Vec<String>>,
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct WayVRConfig {
+    #[serde(default = "def_version")]
+    pub version: u32,
+    #[serde(default = "def_false")]
+    pub run_compositor_at_start: bool,
+
+    #[serde(default = "Default::default")]
+    pub catalogs: HashMap<String, WayVRCatalog>,
+
+    #[serde(default = "Default::default")]
+    pub displays: BTreeMap<String, WayVRDisplay>, // sorted alphabetically
+
+    #[serde(default = "Default::default")]
+    pub dashboard: Option<WayVRDashboard>,
+
+    #[serde(default = "def_true")]
+    pub auto_hide: bool,
+
+    #[serde(default = "def_autohide_delay")]
+    pub auto_hide_delay: u32,
+
+    #[serde(default = "def_keyboard_repeat_delay")]
+    pub keyboard_repeat_delay: u32,
+
+    #[serde(default = "def_keyboard_repeat_rate")]
+    pub keyboard_repeat_rate: u32,
+}
+
+impl WayVRConfig {
+    pub fn get_catalog(&self, name: &str) -> Option<&WayVRCatalog> {
+        self.catalogs.get(name)
+    }
+
+    pub fn get_display(&self, name: &str) -> Option<&WayVRDisplay> {
+        self.displays.get(name)
+    }
+
+    pub fn get_default_display(&self) -> Option<(String, &WayVRDisplay)> {
+        for (disp_name, disp) in &self.displays {
+            if disp.primary.unwrap_or(false) {
+                return Some((disp_name.clone(), disp));
+            }
+        }
+        None
+    }
+
+    pub fn get_wayvr_config(
+        config_general: &crate::config::GeneralConfig,
+        config_wayvr: &crate::config_wayvr::WayVRConfig,
+    ) -> wayvr::Config {
+        wayvr::Config {
+            click_freeze_time_ms: config_general.click_freeze_time_ms,
+            keyboard_repeat_delay_ms: config_wayvr.keyboard_repeat_delay,
+            keyboard_repeat_rate: config_wayvr.keyboard_repeat_rate,
+            auto_hide_delay: if config_wayvr.auto_hide {
+                Some(config_wayvr.auto_hide_delay)
+            } else {
+                None
+            },
+        }
+    }
+
+    pub fn post_load(
+        &self,
+        config: &crate::config::GeneralConfig,
+        tasks: &mut TaskContainer,
+    ) -> anyhow::Result<Option<Rc<RefCell<WayVRData>>>> {
+        let primary_count = self
+            .displays
+            .iter()
+            .filter(|d| d.1.primary.unwrap_or(false))
+            .count();
+
+        if primary_count > 1 {
+            anyhow::bail!("Number of primary displays is more than 1")
+        } else if primary_count == 0 {
+            log::warn!("No primary display specified");
+        }
+
+        for (catalog_name, catalog) in &self.catalogs {
+            for app in &catalog.apps {
+                if let Some(b) = app.shown_at_start {
+                    if b {
+                        tasks.enqueue(TaskType::WayVR(WayVRAction::AppClick {
+                            catalog_name: Arc::from(catalog_name.as_str()),
+                            app_name: Arc::from(app.name.as_str()),
+                        }));
+                    }
+                }
+            }
+        }
+
+        if self.run_compositor_at_start {
+            // Start Wayland server instantly
+            Ok(Some(Rc::new(RefCell::new(WayVRData::new(
+                Self::get_wayvr_config(config, self),
+            )?))))
+        } else {
+            // Lazy-init WayVR later if the user requested
+            Ok(None)
+        }
+    }
+}
+
+pub fn load_wayvr() -> WayVRConfig {
+    let config_root_path = config_io::ConfigRoot::WayVR.ensure_dir();
+    log::info!("WayVR Config root path: {:?}", config_root_path);
+    log::info!(
+        "WayVR conf.d path: {:?}",
+        config_io::ConfigRoot::WayVR.get_conf_d_path()
+    );
+
+    let config = load_config_with_conf_d::<WayVRConfig>("wayvr.yaml", config_io::ConfigRoot::WayVR);
+
+    if config.version != def_version() {
+        panic!("WayVR config version {} is not supported", config.version);
+    }
+    config
+}
@@ -553,7 +553,9 @@ impl WlxGraphics {
        Arc<winit::window::Window>,
        Arc<vulkano::swapchain::Surface>,
    )> {
-        use vulkano::swapchain::Surface;
+        use vulkano::{
+            device::physical::PhysicalDeviceType, instance::InstanceCreateFlags, swapchain::Surface,
+        };
        use winit::{event_loop::EventLoop, window::Window};

        let event_loop = EventLoop::new().unwrap(); // want panic
@@ -795,30 +797,17 @@ impl WlxGraphics {
        )?)
    }

-    pub fn dmabuf_texture(&self, frame: DmabufFrame) -> anyhow::Result<Arc<Image>> {
+    pub fn dmabuf_texture_ex(
+        &self,
+        frame: DmabufFrame,
+        tiling: ImageTiling,
+        layouts: Vec<SubresourceLayout>,
+        modifiers: Vec<u64>,
+    ) -> anyhow::Result<Arc<Image>> {
        let extent = [frame.format.width, frame.format.height, 1];

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

-        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];
-                layouts.push(SubresourceLayout {
-                    offset: plane.offset as _,
-                    size: 0,
-                    row_pitch: plane.stride as _,
-                    array_pitch: None,
-                    depth_pitch: None,
-                });
-                modifiers.push(frame.format.modifier);
-            });
-            tiling = ImageTiling::DrmFormatModifier;
-        };
-
        let image = unsafe {
            RawImage::new_unchecked(
                self.device.clone(),
@@ -859,7 +848,7 @@ impl WlxGraphics {

            let file = std::fs::File::from_raw_fd(fd);
            let new_file = file.try_clone()?;
-            file.into_raw_fd();
+            let _ = file.into_raw_fd();

            let memory = DeviceMemory::allocate_unchecked(
                self.device.clone(),
@@ -885,6 +874,29 @@ impl WlxGraphics {
        }
    }

+    pub fn dmabuf_texture(&self, frame: DmabufFrame) -> anyhow::Result<Arc<Image>> {
+        let mut modifiers: Vec<u64> = vec![];
+        let mut tiling: ImageTiling = ImageTiling::Optimal;
+        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];
+                layouts.push(SubresourceLayout {
+                    offset: plane.offset as _,
+                    size: 0,
+                    row_pitch: plane.stride as _,
+                    array_pitch: None,
+                    depth_pitch: None,
+                });
+                modifiers.push(frame.format.modifier);
+            });
+            tiling = ImageTiling::DrmFormatModifier;
+        };
+
+        self.dmabuf_texture_ex(frame, tiling, layouts, modifiers)
+    }
+
    pub fn render_texture(
        &self,
        width: u32,
@@ -930,6 +942,7 @@ impl WlxGraphics {
        )?))
    }

+    #[allow(clippy::too_many_arguments)]
    pub fn create_pipeline_with_layouts(
        self: &Arc<Self>,
        render_target: Arc<ImageView>,
@@ -1292,6 +1305,7 @@ impl WlxPipeline<WlxPipelineLegacy> {
        )
    }

+    #[allow(clippy::too_many_arguments)]
    fn new_with_layout(
        render_target: Arc<ImageView>,
        graphics: Arc<WlxGraphics>,
@@ -111,6 +111,7 @@ impl<D, S> CanvasBuilder<D, S> {
    }

    // Creates a sprite that highlights on pointer hover. Will not draw anything until set_sprite is called.
+    #[allow(dead_code)]
    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 {
@@ -152,6 +153,7 @@ impl<D, S> CanvasBuilder<D, S> {
        &mut self.canvas.controls[idx]
    }

+    #[allow(clippy::too_many_arguments)]
    pub fn key_button(
        &mut self,
        x: f32,
@@ -19,6 +19,7 @@ pub type ControlRendererHl<D, S> = fn(
    Vec4,
 ) -> anyhow::Result<()>;

+#[allow(clippy::type_complexity)]
 pub(crate) struct Control<D, S> {
    pub state: Option<S>,
    pub rect: Rect,
@@ -336,6 +337,7 @@ impl<D, S> Control<D, S> {
        Ok(())
    }

+    #[allow(dead_code)]
    pub(super) fn render_sprite_hl(
        &self,
        canvas: &CanvasData<D>,
@@ -13,7 +13,7 @@ use vulkano::{
 use crate::{
    backend::{
        input::{Haptics, InteractionHandler, PointerHit},
-        overlay::{OverlayBackend, OverlayRenderer},
+        overlay::{FrameTransform, OverlayBackend, OverlayRenderer},
    },
    graphics::{WlxGraphics, WlxPass, WlxPipeline, WlxPipelineLegacy, BLEND_ALPHA},
    state::AppState,
@@ -375,8 +375,11 @@ impl<D, S> OverlayRenderer for Canvas<D, S> {
        Some(self.view_final.clone())
    }

-    fn extent(&mut self) -> Option<[u32; 3]> {
-        Some(self.view_final.image().extent())
+    fn frame_transform(&mut self) -> Option<FrameTransform> {
+        Some(FrameTransform {
+            extent: self.view_final.image().extent(),
+            ..Default::default()
+        })
    }
 }

@@ -124,11 +124,8 @@ impl FontCache {
        let pattern = pattern.font_match(&mut self.fc);

        if let Some(path) = pattern.filename() {
-            log::debug!(
-                "Loading font: {} {}pt",
-                pattern.name().unwrap_or(path),
-                size
-            );
+            let name = pattern.name().unwrap_or(path);
+            log::debug!("Loading font: {} {}pt", name, size);

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

@@ -150,14 +147,16 @@ impl FontCache {
            };

            let idx = coll.fonts.len();
-            for cp in 0..0xFFFF {
+            for (cp, _) in face.chars() {
                if coll.cp_map.contains_key(cp) {
                    continue;
                }
-                let g = face.get_char_index(cp);
-                if g.is_some() {
-                    coll.cp_map.insert(cp, idx);
-                }
+                coll.cp_map.insert(cp, idx);
+            }
+
+            if !coll.cp_map.contains_key(cp) {
+                log::warn!("Got font '{name}' for CP 0x{cp:x}, but CP is not present in font!",);
+                coll.cp_map.insert(cp, 0);
            }

            let zero_glyph = Rc::new(Glyph {
@@ -189,7 +188,7 @@ impl FontCache {
        let key = self.get_font_for_cp(cp, size);

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

@@ -19,12 +19,18 @@ use crate::{
    config::{save_layout, save_settings, AStrSetExt},
    hid::VirtualKey,
    overlays::{
-        toast::{Toast, ToastTopic},
+        toast::{error_toast, Toast, ToastTopic},
        watch::WATCH_NAME,
    },
    state::AppState,
 };

+#[cfg(any(not(feature = "wayvr"), not(feature = "osc")))]
+use crate::overlays::toast::error_toast_str;
+
+#[cfg(feature = "osc")]
+use rosc::OscType;
+
 use super::{ExecArgs, ModularControl, ModularData};

 #[derive(Deserialize, Clone)]
@@ -116,6 +122,26 @@ pub enum WindowAction {
    Destroy,
 }

+#[derive(Deserialize, Clone)]
+pub enum WayVRDisplayClickAction {
+    ToggleVisibility,
+    Reset,
+}
+
+#[derive(Deserialize, Clone)]
+#[allow(dead_code)] // in case if WayVR feature is disabled
+pub enum WayVRAction {
+    AppClick {
+        catalog_name: Arc<str>,
+        app_name: Arc<str>,
+    },
+    DisplayClick {
+        display_name: Arc<str>,
+        action: WayVRDisplayClickAction,
+    },
+    ToggleDashboard,
+}
+
 #[derive(Deserialize, Clone)]
 #[serde(tag = "type")]
 pub enum ButtonAction {
@@ -134,6 +160,10 @@ pub enum ButtonAction {
        target: OverlaySelector,
        action: OverlayAction,
    },
+    // Ignored if "wayvr" feature is not enabled
+    WayVR {
+        action: WayVRAction,
+    },
    Window {
        target: Arc<str>,
        action: WindowAction,
@@ -153,6 +183,26 @@ pub enum ButtonAction {
    System {
        action: SystemAction,
    },
+    SendOscValue {
+        parameter: Arc<str>,
+        values: Option<Vec<OscValue>>,
+    },
+}
+
+#[derive(Deserialize, Clone)]
+#[serde(tag = "type")]
+#[cfg(feature = "osc")]
+pub enum OscValue {
+    Int { value: i32 },
+    Float { value: f32 },
+    String { value: String },
+    Bool { value: bool },
+}
+#[derive(Deserialize, Clone)]
+#[serde(tag = "type")]
+#[cfg(not(feature = "osc"))]
+pub enum OscValue {
+    None,
 }

 pub(super) struct PressData {
@@ -327,6 +377,17 @@ fn handle_action(action: &ButtonAction, press: &mut PressData, app: &mut AppStat
        ButtonAction::Watch { action } => run_watch(action, app),
        ButtonAction::Overlay { target, action } => run_overlay(target, action, app),
        ButtonAction::Window { target, action } => run_window(target, action, app),
+        ButtonAction::WayVR { action } => {
+            #[cfg(feature = "wayvr")]
+            {
+                app.tasks.enqueue(TaskType::WayVR(action.clone()));
+            }
+            #[cfg(not(feature = "wayvr"))]
+            {
+                let _ = &action;
+                error_toast_str(app, "WayVR feature is not enabled");
+            }
+        }
        ButtonAction::VirtualKey { keycode, action } => app
            .hid_provider
            .send_key(*keycode, matches!(*action, PressRelease::Press)),
@@ -353,6 +414,34 @@ fn handle_action(action: &ButtonAction, press: &mut PressData, app: &mut AppStat
        ButtonAction::DragMultiplier { delta } => {
            app.session.config.space_drag_multiplier += delta;
        }
+        ButtonAction::SendOscValue { parameter, values } => {
+            #[cfg(feature = "osc")]
+            if let Some(ref mut sender) = app.osc_sender {
+                // convert OscValue to OscType
+                let mut converted: Vec<OscType> = Vec::new();
+
+                for value in values.as_ref().unwrap() {
+                    let converted_value = match value {
+                        OscValue::Bool { value } => OscType::Bool(*value),
+                        OscValue::Int { value } => OscType::Int(*value),
+                        OscValue::Float { value } => OscType::Float(*value),
+                        OscValue::String { value } => OscType::String(value.to_string()),
+                    };
+
+                    converted.push(converted_value);
+                }
+
+                let _ = sender.send_single_param(parameter.to_string(), converted);
+                audio_thump(app); // play sound for feedback
+            };
+
+            #[cfg(not(feature = "osc"))]
+            {
+                let _ = &parameter;
+                let _ = &values;
+                error_toast_str(app, "OSC feature is not enabled");
+            }
+        }
    }
 }

@@ -452,12 +541,12 @@ fn run_system(action: &SystemAction, app: &mut AppState) {
        }
        SystemAction::PersistConfig => {
            if let Err(e) = save_settings(&app.session.config) {
-                log::error!("Failed to save config: {:?}", e);
+                error_toast(app, "Failed to save config", e);
            }
        }
        SystemAction::PersistLayout => {
            if let Err(e) = save_layout(&app.session.config) {
-                log::error!("Failed to save layout: {:?}", e);
+                error_toast(app, "Failed to save layout", e);
            }
        }
    }
@@ -468,7 +557,7 @@ fn run_exec(args: &ExecArgs, toast: &Option<Arc<str>>, press: &mut PressData, ap
        match proc.try_wait() {
            Ok(Some(code)) => {
                if !code.success() {
-                    log::error!("Child process exited with code: {}", code);
+                    error_toast(app, "Child process exited with code", code);
                }
                press.child = None;
            }
@@ -478,7 +567,7 @@ fn run_exec(args: &ExecArgs, toast: &Option<Arc<str>>, press: &mut PressData, ap
            }
            Err(e) => {
                press.child = None;
-                log::error!("Error checking child process: {:?}", e);
+                error_toast(app, "Error checking child process", e);
            }
        }
    }
@@ -491,7 +580,7 @@ fn run_exec(args: &ExecArgs, toast: &Option<Arc<str>>, press: &mut PressData, ap
            }
        }
        Err(e) => {
-            log::error!("Failed to spawn process {:?}: {:?}", args, e);
+            error_toast(app, &format!("Failed to spawn process {:?}", args), e);
        }
    };
 }
@@ -642,7 +731,9 @@ fn run_overlay(overlay: &OverlaySelector, action: &OverlayAction, app: &mut AppS
                    if state_dirty {
                        match save_layout(&app.session.config) {
                            Ok(_) => log::debug!("Saved state"),
-                            Err(e) => log::error!("Failed to save state: {:?}", e),
+                            Err(e) => {
+                                error_toast(app, "Failed to save state", e);
+                            }
                        }
                    }
                }),
@@ -9,12 +9,23 @@ use std::{
    time::Instant,
 };

-use crate::{gui::modular::FALLBACK_COLOR, state::AppState};
+use crate::{
+    gui::modular::FALLBACK_COLOR,
+    overlays::toast::{error_toast, error_toast_str},
+    state::AppState,
+};

 use serde::Deserialize;

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

+#[derive(Deserialize)]
+#[serde(untagged)]
+pub enum TimezoneDef {
+    Idx(usize),
+    Str(Arc<str>),
+}
+
 #[derive(Deserialize)]
 #[serde(tag = "source")]
 pub enum LabelContent {
@@ -27,7 +38,10 @@ pub enum LabelContent {
    },
    Clock {
        format: Arc<str>,
-        timezone: Option<Arc<str>>,
+        timezone: Option<TimezoneDef>,
+    },
+    Timezone {
+        timezone: usize,
    },
    Timer {
        format: Arc<str>,
@@ -70,7 +84,7 @@ pub enum LabelData {
    DragMultiplier,
 }

-pub fn modular_label_init(label: &mut ModularControl, content: &LabelContent) {
+pub fn modular_label_init(label: &mut ModularControl, content: &LabelContent, app: &AppState) {
    let state = match content {
        LabelContent::Battery {
            device,
@@ -85,19 +99,49 @@ pub fn modular_label_init(label: &mut ModularControl, content: &LabelContent) {
            charging_color: color_parse_or_default(charging_color),
        }),
        LabelContent::Clock { format, timezone } => {
-            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);
-                    Tz::UTC
-                })
-            });
+            let tz_str = match timezone {
+                Some(TimezoneDef::Idx(idx)) => {
+                    if let Some(tz) = app.session.config.timezones.get(*idx) {
+                        Some(tz.as_str())
+                    } else {
+                        log::error!("Timezone index out of range '{}'", idx);
+                        label.set_fg_color(*FALLBACK_COLOR);
+                        None
+                    }
+                }
+                Some(TimezoneDef::Str(tz_str)) => Some(tz_str.as_ref()),
+                None => None,
+            };

            Some(LabelData::Clock {
                format: format.clone(),
-                timezone: tz,
+                timezone: tz_str.and_then(|tz| {
+                    tz.parse()
+                        .map_err(|_| {
+                            log::error!("Failed to parse timezone '{}'", &tz);
+                            label.set_fg_color(*FALLBACK_COLOR);
+                        })
+                        .ok()
+                }),
            })
        }
+        LabelContent::Timezone { timezone } => {
+            if let Some(tz) = app.session.config.timezones.get(*timezone) {
+                let pretty_tz = tz.split('/').last().map(|x| x.replace("_", " "));
+
+                if let Some(pretty_tz) = pretty_tz {
+                    label.set_text(&pretty_tz);
+                    return;
+                } else {
+                    log::error!("Timezone name not valid '{}'", &tz);
+                }
+            } else {
+                log::error!("Timezone index out of range '{}'", &timezone);
+            }
+            label.set_fg_color(*FALLBACK_COLOR);
+            label.set_text("Error");
+            None
+        }
        LabelContent::Timer { format } => Some(LabelData::Timer {
            format: format.clone(),
            start: Instant::now(),
@@ -193,14 +237,21 @@ pub(super) fn label_update(control: &mut ModularControl, _: &mut (), app: &mut A
                match proc.try_wait() {
                    Ok(Some(code)) => {
                        if !code.success() {
-                            log::error!("Child process exited with code: {}", code);
+                            error_toast(
+                                app,
+                                "LabelData::Exec: Child process exited with code",
+                                code,
+                            );
                        } else {
                            if let Some(mut stdout) = proc.stdout.take() {
                                let mut buf = String::new();
                                if stdout.read_to_string(&mut buf).is_ok() {
                                    control.set_text(&buf);
                                } else {
-                                    log::error!("Failed to read stdout for child process");
+                                    error_toast_str(
+                                        app,
+                                        "LabelData::Exec: Failed to read stdout for child process",
+                                    );
                                    return;
                                }
                                return;
@@ -216,7 +267,7 @@ pub(super) fn label_update(control: &mut ModularControl, _: &mut (), app: &mut A
                    }
                    Err(e) => {
                        *child = None;
-                        log::error!("Error checking child process: {:?}", e);
+                        error_toast(app, "Error checking child process", e);
                        return;
                    }
                }
@@ -242,7 +293,7 @@ pub(super) fn label_update(control: &mut ModularControl, _: &mut (), app: &mut A
                        *child = Some(proc);
                    }
                    Err(e) => {
-                        log::error!("Failed to spawn process {:?}: {:?}", args, e);
+                        error_toast(app, &format!("Failed to spawn process {:?}", args), e);
                    }
                };
            }
@@ -3,12 +3,15 @@ pub mod label;

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

+#[cfg(feature = "wayvr")]
+use button::{WayVRAction, WayVRDisplayClickAction};
+
 use glam::Vec4;
 use serde::Deserialize;
 use vulkano::{command_buffer::CommandBufferUsage, image::view::ImageView};

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

@@ -110,6 +113,23 @@ pub enum ModularElement {
        #[serde(flatten)]
        template: Box<OverlayListTemplate>,
    },
+    // Ignored if "wayvr" feature is not enabled
+    WayVRLauncher {
+        rect: [f32; 4],
+        corner_radius: Option<f32>,
+        font_size: isize,
+        fg_color: Arc<str>,
+        bg_color: Arc<str>,
+        catalog_name: Arc<str>,
+    },
+    // Ignored if "wayvr" feature is not enabled
+    WayVRDisplayList {
+        rect: [f32; 4],
+        corner_radius: Option<f32>,
+        font_size: isize,
+        fg_color: Arc<str>,
+        bg_color: Arc<str>,
+    },
 }

 #[derive(Deserialize, Clone)]
@@ -169,7 +189,7 @@ pub fn modular_canvas(
                    corner_radius.unwrap_or_default(),
                    empty_str.clone(),
                );
-                modular_label_init(label, data);
+                modular_label_init(label, data, state);
            }
            ModularElement::CenteredLabel {
                rect: [x, y, w, h],
@@ -188,7 +208,7 @@ pub fn modular_canvas(
                    corner_radius.unwrap_or_default(),
                    empty_str.clone(),
                );
-                modular_label_init(label, data);
+                modular_label_init(label, data, state);
            }
            ModularElement::Sprite {
                rect: [x, y, w, h],
@@ -272,6 +292,7 @@ pub fn modular_canvas(
                            low_color: fg_color_low.clone(),
                            charging_color: fg_color_charging.clone(),
                        },
+                        state,
                    );

                    button_x += match layout {
@@ -398,6 +419,115 @@ pub fn modular_canvas(
                    };
                }
            }
+            #[allow(unused_variables)] // needed in case if wayvr feature is not enabled
+            ModularElement::WayVRLauncher {
+                rect: [x, y, w, h],
+                corner_radius,
+                font_size,
+                fg_color,
+                bg_color,
+                catalog_name,
+            } => {
+                #[cfg(feature = "wayvr")]
+                {
+                    if let Some(catalog) = state.session.wayvr_config.get_catalog(catalog_name) {
+                        let mut button_x = *x;
+                        let button_y = *y;
+
+                        for app in &catalog.apps {
+                            let button_w: f32 = *w / catalog.apps.len() as f32;
+                            let button_h: f32 = *h;
+
+                            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(
+                                button_x + 2.,
+                                button_y + 2.,
+                                button_w - 4.,
+                                button_h - 4.,
+                                corner_radius.unwrap_or_default(),
+                                Arc::from(app.name.as_str()),
+                            );
+
+                            let data = ButtonData {
+                                click_up: Some(vec![ButtonAction::WayVR {
+                                    action: WayVRAction::AppClick {
+                                        catalog_name: catalog_name.clone(),
+                                        app_name: Arc::from(app.name.as_str()),
+                                    },
+                                }]),
+                                ..Default::default()
+                            };
+
+                            modular_button_init(button, &data);
+                            button_x += button_w;
+                        }
+                    } else {
+                        log::error!("WayVR catalog \"{}\" not found", catalog_name);
+                    }
+                }
+                #[cfg(not(feature = "wayvr"))]
+                {
+                    log::error!("WayVR feature is not enabled, ignoring");
+                }
+            }
+            #[allow(unused_variables)]
+            ModularElement::WayVRDisplayList {
+                rect: [x, y, w, h],
+                corner_radius,
+                font_size,
+                fg_color,
+                bg_color,
+            } => {
+                #[cfg(feature = "wayvr")]
+                {
+                    let mut button_x = *x;
+                    let button_y = *y;
+                    let displays = &state.session.wayvr_config.displays;
+                    for (display_name, display) in displays {
+                        let button_w: f32 = (*w / displays.len() as f32).min(80.0);
+                        let button_h: f32 = *h;
+
+                        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(
+                            button_x + 2.,
+                            button_y + 2.,
+                            button_w - 4.,
+                            button_h - 4.,
+                            corner_radius.unwrap_or_default(),
+                            Arc::from(display_name.as_str()),
+                        );
+
+                        let data = ButtonData {
+                            click_up: Some(vec![ButtonAction::WayVR {
+                                action: WayVRAction::DisplayClick {
+                                    display_name: Arc::from(display_name.as_str()),
+                                    action: WayVRDisplayClickAction::ToggleVisibility,
+                                },
+                            }]),
+                            long_click_up: Some(vec![ButtonAction::WayVR {
+                                action: WayVRAction::DisplayClick {
+                                    display_name: Arc::from(display_name.as_str()),
+                                    action: WayVRDisplayClickAction::Reset,
+                                },
+                            }]),
+                            ..Default::default()
+                        };
+
+                        modular_button_init(button, &data);
+                        button_x += button_w;
+                    }
+                }
+                #[cfg(not(feature = "wayvr"))]
+                {
+                    log::error!("WayVR feature is not enabled, ignoring")
+                }
+            }
        }
    }
    Ok(canvas.build())
@@ -415,7 +545,7 @@ fn sprite_from_path(path: Arc<str>, app: &mut AppState) -> anyhow::Result<Arc<Im
        return Ok(view.clone());
    }

-    let real_path = CONFIG_ROOT_PATH.join(&*path);
+    let real_path = config_io::get_config_root().join(&*path);

    let Ok(f) = File::open(real_path) else {
        anyhow::bail!("Could not open custom sprite at: {}", path);
@@ -68,7 +68,8 @@ struct MouseAction {
 }

 pub struct UInputProvider {
-    handle: UInputHandle<File>,
+    keyboard_handle: UInputHandle<File>,
+    mouse_handle: UInputHandle<File>,
    desktop_extent: Vec2,
    desktop_origin: Vec2,
    cur_modifiers: u8,
@@ -90,97 +91,89 @@ const EV_ABS: u16 = 0x3;

 impl UInputProvider {
    fn try_new() -> Option<Self> {
-        if let Ok(file) = File::create("/dev/uinput") {
-            let handle = UInputHandle::new(file);
+        let keyboard_file = File::create("/dev/uinput").ok()?;
+        let keyboard_handle = UInputHandle::new(keyboard_file);

-            let id = InputId {
-                bustype: 0x03,
-                vendor: 0x4711,
-                product: 0x0829,
-                version: 5,
-            };
+        let mouse_file = File::create("/dev/uinput").ok()?;
+        let mouse_handle = UInputHandle::new(mouse_file);

-            let name = b"WlxOverlay-S Keyboard-Mouse Hybrid Thing\0";
+        let kbd_id = InputId {
+            bustype: 0x03,
+            vendor: 0x4711,
+            product: 0x0829,
+            version: 5,
+        };
+        let mouse_id = InputId {
+            bustype: 0x03,
+            vendor: 0x4711,
+            product: 0x0830,
+            version: 5,
+        };
+        let kbd_name = b"WlxOverlay-S Keyboard\0";
+        let mouse_name = b"WlxOverlay-S Mouse\0";

-            let abs_info = vec![
-                AbsoluteInfoSetup {
-                    axis: input_linux::AbsoluteAxis::X,
-                    info: AbsoluteInfo {
-                        value: 0,
-                        minimum: 0,
-                        maximum: MOUSE_EXTENT as _,
-                        fuzz: 0,
-                        flat: 0,
-                        resolution: 10,
-                    },
+        let abs_info = vec![
+            AbsoluteInfoSetup {
+                axis: input_linux::AbsoluteAxis::X,
+                info: AbsoluteInfo {
+                    value: 0,
+                    minimum: 0,
+                    maximum: MOUSE_EXTENT as _,
+                    fuzz: 0,
+                    flat: 0,
+                    resolution: 10,
                },
-                AbsoluteInfoSetup {
-                    axis: input_linux::AbsoluteAxis::Y,
-                    info: AbsoluteInfo {
-                        value: 0,
-                        minimum: 0,
-                        maximum: MOUSE_EXTENT as _,
-                        fuzz: 0,
-                        flat: 0,
-                        resolution: 10,
-                    },
+            },
+            AbsoluteInfoSetup {
+                axis: input_linux::AbsoluteAxis::Y,
+                info: AbsoluteInfo {
+                    value: 0,
+                    minimum: 0,
+                    maximum: MOUSE_EXTENT as _,
+                    fuzz: 0,
+                    flat: 0,
+                    resolution: 10,
                },
-            ];
+            },
+        ];

-            if handle.set_evbit(EventKind::Key).is_err() {
-                return None;
-            }
-            if handle.set_evbit(EventKind::Absolute).is_err() {
-                return None;
-            }
-            if handle.set_evbit(EventKind::Relative).is_err() {
-                return None;
-            }
-
-            for btn in MOUSE_LEFT..=MOUSE_MIDDLE {
-                let key: Key = unsafe { transmute(btn) };
-                if handle.set_keybit(key).is_err() {
-                    return None;
-                }
-            }
-
-            for key in VirtualKey::iter() {
-                let key: Key = unsafe { transmute((key as u16) - 8) };
-                if handle.set_keybit(key).is_err() {
-                    return None;
-                }
-            }
-
-            if handle.set_absbit(AbsoluteAxis::X).is_err() {
-                return None;
-            }
-            if handle.set_absbit(AbsoluteAxis::Y).is_err() {
-                return None;
-            }
-            if handle.set_relbit(RelativeAxis::Wheel).is_err() {
-                return None;
-            }
-
-            if handle.create(&id, name, 0, &abs_info).is_ok() {
-                return Some(UInputProvider {
-                    handle,
-                    desktop_extent: Vec2::ZERO,
-                    desktop_origin: Vec2::ZERO,
-                    current_action: Default::default(),
-                    cur_modifiers: 0,
-                });
-            }
+        keyboard_handle.set_evbit(EventKind::Key).ok()?;
+        for key in VirtualKey::iter() {
+            let mapped_key: Key = unsafe { std::mem::transmute((key as u16) - 8) };
+            keyboard_handle.set_keybit(mapped_key).ok()?;
        }
-        None
-    }

+        keyboard_handle.create(&kbd_id, kbd_name, 0, &[]).ok()?;
+
+        mouse_handle.set_evbit(EventKind::Absolute).ok()?;
+        mouse_handle.set_evbit(EventKind::Relative).ok()?;
+        mouse_handle.set_absbit(AbsoluteAxis::X).ok()?;
+        mouse_handle.set_absbit(AbsoluteAxis::Y).ok()?;
+        mouse_handle.set_relbit(RelativeAxis::Wheel).ok()?;
+        mouse_handle.set_evbit(EventKind::Key).ok()?;
+
+        for btn in MOUSE_LEFT..=MOUSE_MIDDLE {
+            let mouse_btn: Key = unsafe { transmute(btn) };
+            mouse_handle.set_keybit(mouse_btn).ok()?;
+        }
+        mouse_handle.create(&mouse_id, mouse_name, 0, &abs_info).ok()?;
+
+        Some(UInputProvider {
+            keyboard_handle,
+            mouse_handle,
+            desktop_extent: Vec2::ZERO,
+            desktop_origin: Vec2::ZERO,
+            current_action: Default::default(),
+            cur_modifiers: 0,
+        })
+    }
    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) {
+        if let Err(res) = self.mouse_handle.write(&events) {
            log::error!("send_button: {}", res.to_string());
        }
    }
@@ -196,7 +189,7 @@ impl UInputProvider {
            new_event(time, EV_ABS, AbsoluteAxis::Y as _, pos.y as i32),
            new_event(time, EV_SYN, 0, 0),
        ];
-        if let Err(res) = self.handle.write(&events) {
+        if let Err(res) = self.mouse_handle.write(&events) {
            log::error!("{}", res.to_string());
        }
    }
@@ -206,7 +199,7 @@ impl UInputProvider {
            new_event(time, EV_REL, RelativeAxis::Wheel as _, delta),
            new_event(time, EV_SYN, 0, 0),
        ];
-        if let Err(res) = self.handle.write(&events) {
+        if let Err(res) = self.mouse_handle.write(&events) {
            log::error!("wheel: {}", res.to_string());
        }
    }
@@ -232,7 +225,7 @@ impl HidProvider for UInputProvider {
            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) {
+        if let Err(res) = self.keyboard_handle.write(&events) {
            log::error!("send_key: {}", res.to_string());
        }
    }
@@ -9,6 +9,9 @@ mod overlays;
 mod shaders;
 mod state;

+#[cfg(feature = "wayvr")]
+mod config_wayvr;
+
 use std::{
    path::PathBuf,
    sync::{
@@ -18,7 +21,6 @@ use std::{
 };

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

 /// The lightweight desktop overlay for OpenVR and OpenXR
@@ -178,10 +180,10 @@ fn logging_init(args: &mut Args) -> anyhow::Result<()> {
    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()?;
+            env_logger::init();
        }
    } else {
-        flexi_logger::Logger::try_with_env_or_str("info")?.start()?;
+        env_logger::init();
    }

    log_panics::init();
@@ -189,25 +191,27 @@ fn logging_init(args: &mut Args) -> anyhow::Result<()> {
 }

 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")?;
+    use std::io::Write;
+    let target = Box::new(std::fs::File::create(log_to)?);

-    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,
-        });
+    env_logger::Builder::new()
+        .target(env_logger::Target::Pipe(target))
+        .filter(None, log::LevelFilter::Info)
+        .filter_module("zbus", log::LevelFilter::Warn)
+        .parse_default_env()
+        .format(|buf, record| {
+            eprintln!("[{}] {}", record.level(), record.args());
+            writeln!(
+                buf,
+                "[{} {} {}] {}",
+                chrono::Local::now().format("%H:%M:%S%.3f"),
+                record.level(),
+                record.module_path().unwrap_or_default(),
+                record.args()
+            )
+        })
+        .init();

-    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(())
 }
@@ -223,7 +227,10 @@ fn ensure_single_instance(replace: bool) -> bool {
        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)]));
+                system.refresh_processes(
+                    sysinfo::ProcessesToUpdate::Some(&[Pid::from_u32(pid)]),
+                    false,
+                );
                if let Some(proc) = system.process(sysinfo::Pid::from_u32(pid)) {
                    if replace {
                        proc.kill_with(sysinfo::Signal::Term);
@@ -2,7 +2,7 @@ use glam::Vec3A;
 use once_cell::sync::Lazy;
 use std::sync::Arc;

-use crate::backend::overlay::{OverlayData, OverlayState, RelativeTo};
+use crate::backend::overlay::{OverlayData, OverlayState, RelativeTo, Z_ORDER_ANCHOR};
 use crate::config::{load_known_yaml, ConfigType};
 use crate::gui::modular::{modular_canvas, ModularUiConfig};
 use crate::state::AppState;
@@ -21,7 +21,7 @@ where
            want_visible: false,
            interactable: false,
            grabbable: false,
-            z_order: 67,
+            z_order: Z_ORDER_ANCHOR,
            spawn_scale: config.width,
            spawn_point: Vec3A::NEG_Z * 0.5,
            relative_to: RelativeTo::Stage,
@@ -7,7 +7,7 @@ use std::{
 use crate::{
    backend::{
        input::{InteractionHandler, PointerMode},
-        overlay::{OverlayBackend, OverlayData, OverlayRenderer, OverlayState},
+        overlay::{FrameTransform, OverlayBackend, OverlayData, OverlayRenderer, OverlayState},
    },
    config::{self, ConfigType},
    gui::{
@@ -18,7 +18,7 @@ use crate::{
        get_key_type, KeyModifier, KeyType, VirtualKey, XkbKeymap, ALT, CTRL, KEYS_TO_MODS, META,
        NUM_LOCK, SHIFT, SUPER,
    },
-    state::AppState,
+    state::{AppState, KeyboardFocus},
 };
 use glam::{vec2, vec3a, Affine2, Vec4};
 use once_cell::sync::Lazy;
@@ -31,9 +31,33 @@ const AUTO_RELEASE_MODS: [KeyModifier; 5] = [SHIFT, CTRL, ALT, SUPER, META];

 pub const KEYBOARD_NAME: &str = "kbd";

+fn send_key(app: &mut AppState, key: VirtualKey, down: bool) {
+    match app.keyboard_focus {
+        KeyboardFocus::PhysicalScreen => {
+            app.hid_provider.send_key(key, down);
+        }
+        KeyboardFocus::WayVR =>
+        {
+            #[cfg(feature = "wayvr")]
+            if let Some(wayvr) = &app.wayvr {
+                wayvr.borrow_mut().data.state.send_key(key as u32, down);
+            }
+        }
+    }
+}
+
+fn set_modifiers(app: &mut AppState, mods: u8) {
+    match app.keyboard_focus {
+        KeyboardFocus::PhysicalScreen => {
+            app.hid_provider.set_modifiers(mods);
+        }
+        KeyboardFocus::WayVR => {}
+    }
+}
+
 pub fn create_keyboard<O>(
    app: &AppState,
-    keymap: Option<XkbKeymap>,
+    mut keymap: Option<XkbKeymap>,
 ) -> anyhow::Result<OverlayData<O>>
 where
    O: Default,
@@ -45,6 +69,14 @@ where

    let data = KeyboardData {
        modifiers: 0,
+        alt_modifier: match LAYOUT.alt_modifier {
+            AltModifier::Shift => SHIFT,
+            AltModifier::Ctrl => CTRL,
+            AltModifier::Alt => ALT,
+            AltModifier::Super => SUPER,
+            AltModifier::Meta => META,
+            _ => 0,
+        },
        processes: vec![],
    };

@@ -63,7 +95,11 @@ where
    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 has_altgr = keymap.as_ref().is_some_and(|k| k.has_altgr());
+
+    if !LAYOUT.auto_labels.unwrap_or(true) {
+        keymap = None;
+    }

    let unit_size = size.x / LAYOUT.row_size;
    let h = unit_size - 2. * BUTTON_PADDING;
@@ -89,7 +125,7 @@ where
                                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()) {
+                                if label0.chars().next().is_some_and(|f| f.is_alphabetic()) {
                                    label.push(label1);
                                    if has_altgr {
                                        cap_type = KeyCapType::RegularAltGr;
@@ -195,24 +231,27 @@ fn key_press(
        Some(KeyButtonData::Key { vk, pressed }) => {
            data.key_click(app);

-            if let PointerMode::Right = mode {
-                data.modifiers |= SHIFT;
-                app.hid_provider.set_modifiers(data.modifiers);
-            }
+            data.modifiers |= match mode {
+                PointerMode::Right => SHIFT,
+                PointerMode::Middle => data.alt_modifier,
+                _ => 0,
+            };

-            app.hid_provider.send_key(*vk, true);
+            app.hid_provider.set_modifiers(data.modifiers);
+
+            send_key(app, *vk, true);
            *pressed = true;
        }
        Some(KeyButtonData::Modifier { modifier, sticky }) => {
            *sticky = data.modifiers & *modifier == 0;
            data.modifiers |= *modifier;
            data.key_click(app);
-            app.hid_provider.set_modifiers(data.modifiers);
+            set_modifiers(app, data.modifiers);
        }
        Some(KeyButtonData::Macro { verbs }) => {
            data.key_click(app);
            for (vk, press) in verbs {
-                app.hid_provider.send_key(*vk, *press);
+                send_key(app, *vk, *press);
            }
        }
        Some(KeyButtonData::Exec { program, args, .. }) => {
@@ -236,20 +275,20 @@ fn key_release(
 ) {
    match control.state.as_mut() {
        Some(KeyButtonData::Key { vk, pressed }) => {
-            app.hid_provider.send_key(*vk, false);
+            send_key(app, *vk, false);
            *pressed = false;

            for m in AUTO_RELEASE_MODS.iter() {
                if data.modifiers & *m != 0 {
                    data.modifiers &= !*m;
-                    app.hid_provider.set_modifiers(data.modifiers);
+                    set_modifiers(app, data.modifiers);
                }
            }
        }
        Some(KeyButtonData::Modifier { modifier, sticky }) => {
            if !*sticky {
                data.modifiers &= !*modifier;
-                app.hid_provider.set_modifiers(data.modifiers);
+                set_modifiers(app, data.modifiers);
            }
        }
        Some(KeyButtonData::Exec {
@@ -293,6 +332,7 @@ fn test_highlight(

 struct KeyboardData {
    modifiers: KeyModifier,
+    alt_modifier: KeyModifier,
    processes: Vec<Child>,
 }

@@ -331,15 +371,29 @@ static LAYOUT: Lazy<Layout> = Lazy::new(Layout::load_from_disk);
 static MACRO_REGEX: Lazy<Regex> =
    Lazy::new(|| Regex::new(r"^([A-Za-z0-9_-]+)(?: +(UP|DOWN))?$").unwrap()); // want panic

+#[derive(Debug, Default, Clone, Copy, Deserialize, Serialize)]
+#[repr(usize)]
+pub enum AltModifier {
+    #[default]
+    None,
+    Shift,
+    Ctrl,
+    Alt,
+    Super,
+    Meta,
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 pub struct Layout {
    name: String,
    row_size: f32,
    key_sizes: Vec<Vec<f32>>,
    main_layout: Vec<Vec<Option<String>>>,
+    alt_modifier: AltModifier,
    exec_commands: HashMap<String, Vec<String>>,
    macros: HashMap<String, Vec<String>>,
    labels: HashMap<String, Vec<String>>,
+    auto_labels: Option<bool>,
 }

 impl Layout {
@@ -485,15 +539,15 @@ impl OverlayRenderer for KeyboardBackend {
    fn render(&mut self, app: &mut AppState) -> anyhow::Result<()> {
        self.canvas.render(app)
    }
-    fn extent(&mut self) -> Option<[u32; 3]> {
-        self.canvas.extent()
+    fn frame_transform(&mut self) -> Option<FrameTransform> {
+        self.canvas.frame_transform()
    }
    fn view(&mut self) -> Option<std::sync::Arc<vulkano::image::view::ImageView>> {
        self.canvas.view()
    }
    fn pause(&mut self, app: &mut AppState) -> anyhow::Result<()> {
        self.canvas.data_mut().modifiers = 0;
-        app.hid_provider.set_modifiers(0);
+        set_modifiers(app, 0);
        self.canvas.pause(app)
    }
    fn resume(&mut self, app: &mut AppState) -> anyhow::Result<()> {
@@ -10,7 +10,8 @@ use crate::{
    backend::{
        common::OverlaySelector,
        overlay::{
-            ui_transform, OverlayBackend, OverlayRenderer, OverlayState, SplitOverlayBackend,
+            ui_transform, FrameTransform, OverlayBackend, OverlayRenderer, OverlayState,
+            SplitOverlayBackend,
        },
        task::TaskType,
    },
@@ -121,8 +122,11 @@ impl OverlayRenderer for MirrorRenderer {
        self.renderer.as_mut().and_then(|r| r.view())
    }

-    fn extent(&mut self) -> Option<[u32; 3]> {
-        Some(self.last_extent)
+    fn frame_transform(&mut self) -> Option<FrameTransform> {
+        Some(FrameTransform {
+            extent: self.last_extent,
+            ..Default::default()
+        })
    }
 }

@@ -6,3 +6,6 @@ pub mod mirror;
 pub mod screen;
 pub mod toast;
 pub mod watch;
+
+#[cfg(feature = "wayvr")]
+pub mod wayvr;
@@ -13,12 +13,13 @@ use vulkano::{
    image::{sampler::Filter, view::ImageView, Image},
    pipeline::graphics::color_blend::AttachmentBlend,
 };
+use wlx_capture::frame as wlx_frame;
+
 use wlx_capture::{
    frame::{
        DrmFormat, FrameFormat, MouseMeta, WlxFrame, DRM_FORMAT_ABGR2101010, DRM_FORMAT_ABGR8888,
        DRM_FORMAT_ARGB8888, DRM_FORMAT_XBGR2101010, DRM_FORMAT_XBGR8888, DRM_FORMAT_XRGB8888,
    },
-    pipewire::PipewireSelectScreenResult,
    WlxCapture,
 };

@@ -28,6 +29,7 @@ use {
    std::error::Error,
    std::{ops::Deref, path::PathBuf, task},
    wlx_capture::pipewire::PipewireCapture,
+    wlx_capture::pipewire::PipewireSelectScreenResult,
 };

 #[cfg(all(feature = "x11", feature = "pipewire"))]
@@ -46,19 +48,19 @@ use {
 #[cfg(feature = "x11")]
 use wlx_capture::xshm::{XshmCapture, XshmScreen};

-use glam::{vec2, vec3a, Affine2, Quat, Vec2, Vec3};
+use glam::{vec2, vec3a, Affine2, Affine3A, Quat, Vec2, Vec3};

 use crate::{
    backend::{
        input::{Haptics, InteractionHandler, PointerHit, PointerMode},
-        overlay::{OverlayRenderer, OverlayState, SplitOverlayBackend},
+        overlay::{FrameTransform, OverlayRenderer, OverlayState, SplitOverlayBackend},
    },
    config::{def_pw_tokens, GeneralConfig, PwTokenMap},
    graphics::{
        fourcc_to_vk, WlxCommandBuffer, WlxPipeline, WlxPipelineLegacy, DRM_FORMAT_MOD_INVALID,
    },
    hid::{MOUSE_LEFT, MOUSE_MIDDLE, MOUSE_RIGHT},
-    state::{AppSession, AppState, ScreenMeta},
+    state::{AppSession, AppState, KeyboardFocus, ScreenMeta},
 };

 #[cfg(feature = "wayland")]
@@ -127,6 +129,7 @@ impl InteractionHandler for ScreenInteractionHandler {
        {
            let pos = self.mouse_transform.transform_point2(hit.uv);
            app.hid_provider.mouse_move(pos);
+            set_next_move(app.session.config.mouse_move_interval_ms as u64);
        }
        None
    }
@@ -284,6 +287,7 @@ pub struct ScreenRenderer {
    capture: Box<dyn WlxCapture>,
    pipeline: Option<ScreenPipeline>,
    last_view: Option<Arc<ImageView>>,
+    transform: Affine3A,
    extent: Option<[u32; 3]>,
 }

@@ -295,6 +299,7 @@ impl ScreenRenderer {
            capture,
            pipeline: None,
            last_view: None,
+            transform: Affine3A::IDENTITY,
            extent: None,
        }
    }
@@ -309,6 +314,7 @@ impl ScreenRenderer {
            capture: Box::new(capture),
            pipeline: None,
            last_view: None,
+            transform: Affine3A::IDENTITY,
            extent: None,
        })
    }
@@ -323,6 +329,7 @@ impl ScreenRenderer {
            capture: Box::new(capture),
            pipeline: None,
            last_view: None,
+            transform: Affine3A::IDENTITY,
            extent: None,
        })
    }
@@ -365,6 +372,7 @@ impl ScreenRenderer {
                capture: Box::new(capture),
                pipeline: None,
                last_view: None,
+                transform: Affine3A::IDENTITY,
                extent: None,
            },
            select_screen_result.restore_token,
@@ -380,6 +388,7 @@ impl ScreenRenderer {
            capture: Box::new(capture),
            pipeline: None,
            last_view: None,
+            transform: Affine3A::IDENTITY,
            extent: None,
        }
    }
@@ -471,6 +480,9 @@ impl OverlayRenderer for ScreenRenderer {
                    self.extent.get_or_insert_with(|| {
                        extent_from_format(frame.format, &app.session.config)
                    });
+                    if let Some(new_transform) = affine_from_format(&frame.format) {
+                        self.transform = new_transform;
+                    }
                    match app.graphics.dmabuf_texture(frame) {
                        Ok(new) => {
                            let pipeline = match self.pipeline {
@@ -513,6 +525,9 @@ impl OverlayRenderer for ScreenRenderer {
                    self.extent.get_or_insert_with(|| {
                        extent_from_format(frame.format, &app.session.config)
                    });
+                    if let Some(new_transform) = affine_from_format(&frame.format) {
+                        self.transform = new_transform;
+                    }
                    log::debug!("{}: New MemFd frame", self.name);
                    let format = fourcc_to_vk(frame.format.fourcc)?;

@@ -601,8 +616,11 @@ impl OverlayRenderer for ScreenRenderer {
    fn view(&mut self) -> Option<Arc<ImageView>> {
        self.last_view.clone()
    }
-    fn extent(&mut self) -> Option<[u32; 3]> {
-        self.extent
+    fn frame_transform(&mut self) -> Option<FrameTransform> {
+        self.extent.map(|extent| FrameTransform {
+            extent,
+            transform: self.transform,
+        })
    }
 }

@@ -712,6 +730,7 @@ fn create_screen_state(

    OverlayState {
        name: name.clone(),
+        keyboard_focus: Some(KeyboardFocus::PhysicalScreen),
        grabbable: true,
        recenter: true,
        anchored: true,
@@ -732,7 +751,7 @@ pub struct TokenConf {

 #[cfg(feature = "pipewire")]
 fn get_pw_token_path() -> PathBuf {
-    let mut path = config_io::get_conf_d_path();
+    let mut path = config_io::ConfigRoot::Generic.get_conf_d_path();
    path.push("pw_tokens.yaml");
    path
 }
@@ -770,16 +789,10 @@ pub fn create_screens_wayland(
    wl: &mut WlxClientAlias,
    app: &mut AppState,
 ) -> anyhow::Result<ScreenCreateData> {
-    use crate::config::AStrMap;
-
    let mut screens = vec![];

    // Load existing Pipewire tokens from file
-    let mut pw_tokens: PwTokenMap = if let Ok(conf) = load_pw_token_config() {
-        conf
-    } else {
-        AStrMap::new()
-    };
+    let mut pw_tokens: PwTokenMap = load_pw_token_config().unwrap_or_default();

    let pw_tokens_copy = pw_tokens.clone();
    let has_wlr_dmabuf = wl.maybe_wlr_dmabuf_mgr.is_some();
@@ -856,15 +869,10 @@ pub fn create_screens_x11pw(_app: &mut AppState) -> anyhow::Result<ScreenCreateD

 #[cfg(all(feature = "x11", feature = "pipewire"))]
 pub fn create_screens_x11pw(app: &mut AppState) -> anyhow::Result<ScreenCreateData> {
-    use crate::config::{AStrMap, AStrMapExt};
    use anyhow::bail;

    // Load existing Pipewire tokens from file
-    let mut pw_tokens: PwTokenMap = if let Ok(conf) = load_pw_token_config() {
-        conf
-    } else {
-        AStrMap::new()
-    };
+    let mut pw_tokens: PwTokenMap = load_pw_token_config().unwrap_or_default();
    let pw_tokens_copy = pw_tokens.clone();
    let token = pw_tokens.arc_get("x11").map(|s| s.as_str());
    let embed_mouse = !app.session.config.double_cursor_fix;
@@ -930,6 +938,7 @@ pub fn create_screens_x11pw(app: &mut AppState) -> anyhow::Result<ScreenCreateDa
                capture: Box::new(PipewireCapture::new(m.name.clone(), s.node_id)),
                pipeline: None,
                last_view: None,
+                transform: Affine3A::IDENTITY,
                extent: Some(extent_from_res(
                    size.0 as _,
                    size.1 as _,
@@ -1049,6 +1058,32 @@ fn extent_from_res(width: u32, height: u32, config: &GeneralConfig) -> [u32; 3]
    [w, h, 1]
 }

+fn affine_from_format(format: &FrameFormat) -> Option<Affine3A> {
+    const FLIP_X: Vec3 = Vec3 {
+        x: -1.0,
+        y: 1.0,
+        z: 1.0,
+    };
+
+    Some(match format.transform {
+        wlx_frame::Transform::Normal => Affine3A::IDENTITY,
+        wlx_frame::Transform::Rotated90 => Affine3A::from_rotation_z(-PI / 2.0),
+        wlx_frame::Transform::Rotated180 => Affine3A::from_rotation_z(PI),
+        wlx_frame::Transform::Rotated270 => Affine3A::from_rotation_z(PI / 2.0),
+        wlx_frame::Transform::Flipped => Affine3A::from_scale(FLIP_X),
+        wlx_frame::Transform::Flipped90 => {
+            Affine3A::from_scale(FLIP_X) * Affine3A::from_rotation_z(-PI / 2.0)
+        }
+        wlx_frame::Transform::Flipped180 => {
+            Affine3A::from_scale(FLIP_X) * Affine3A::from_rotation_z(PI)
+        }
+        wlx_frame::Transform::Flipped270 => {
+            Affine3A::from_scale(FLIP_X) * Affine3A::from_rotation_z(PI / 2.0)
+        }
+        wlx_frame::Transform::Undefined => return None,
+    })
+}
+
 #[cfg(all(feature = "pipewire", feature = "x11"))]
 fn best_match<'a>(
    stream: &PipewireStream,
@@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize};
 use crate::{
    backend::{
        common::OverlaySelector,
-        overlay::{OverlayBackend, OverlayState, RelativeTo},
+        overlay::{OverlayBackend, OverlayState, RelativeTo, Z_ORDER_TOAST},
        task::TaskType,
    },
    gui::{canvas::builder::CanvasBuilder, color_parse},
@@ -199,7 +199,7 @@ fn new_toast(toast: Toast, app: &mut AppState) -> Option<(OverlayState, Box<dyn
        spawn_scale: size.0 * PIXELS_TO_METERS,
        spawn_rotation,
        spawn_point,
-        z_order: 70,
+        z_order: Z_ORDER_TOAST,
        relative_to,
        ..Default::default()
    };
@@ -207,3 +207,26 @@ fn new_toast(toast: Toast, app: &mut AppState) -> Option<(OverlayState, Box<dyn

    Some((state, backend))
 }
+
+fn msg_err(app: &mut AppState, message: &str) {
+    Toast::new(ToastTopic::System, "Error".into(), message.into())
+        .with_timeout(3.)
+        .submit(app);
+}
+
+// Display the same error in the terminal and as a toast in VR.
+// Formatted as "Failed to XYZ: Object is not defined"
+pub fn error_toast<ErrorType>(app: &mut AppState, title: &str, err: ErrorType)
+where
+    ErrorType: std::fmt::Display + std::fmt::Debug,
+{
+    log::error!("{}: {:?}", title, err); // More detailed version (use Debug)
+
+    // Brief version (use Display)
+    msg_err(app, &format!("{}: {}", title, err));
+}
+
+pub fn error_toast_str(app: &mut AppState, message: &str) {
+    log::error!("{}", message);
+    msg_err(app, message);
+}
@@ -1,7 +1,7 @@
 use glam::Vec3A;

 use crate::{
-    backend::overlay::{ui_transform, OverlayData, OverlayState, RelativeTo},
+    backend::overlay::{ui_transform, OverlayData, OverlayState, RelativeTo, Z_ORDER_WATCH},
    config::{load_known_yaml, ConfigType},
    gui::{
        canvas::Canvas,
@@ -25,7 +25,7 @@ where
            name: WATCH_NAME.into(),
            want_visible: true,
            interactable: true,
-            z_order: 68,
+            z_order: Z_ORDER_WATCH,
            spawn_scale: config.width,
            spawn_point: state.session.config.watch_pos,
            spawn_rotation: state.session.config.watch_rot,
@@ -0,0 +1,853 @@
+use glam::{vec3a, Affine2, Vec3, Vec3A};
+use std::{cell::RefCell, collections::HashMap, rc::Rc, sync::Arc};
+use vulkano::image::SubresourceLayout;
+use wayvr_ipc::packet_server::{self, PacketServer, WvrStateChanged};
+use wlx_capture::frame::{DmabufFrame, FourCC, FrameFormat, FramePlane};
+
+use crate::{
+    backend::{
+        common::{OverlayContainer, OverlaySelector},
+        input::{self, InteractionHandler},
+        overlay::{
+            ui_transform, FrameTransform, OverlayData, OverlayID, OverlayRenderer, OverlayState,
+            SplitOverlayBackend, Z_ORDER_DASHBOARD,
+        },
+        task::TaskType,
+        wayvr::{
+            self, display,
+            server_ipc::{gen_args_vec, gen_env_vec},
+            WayVR,
+        },
+    },
+    config_wayvr,
+    graphics::WlxGraphics,
+    gui::modular::button::{WayVRAction, WayVRDisplayClickAction},
+    state::{self, AppState, KeyboardFocus},
+};
+
+use super::toast::error_toast;
+
+// Hard-coded for now
+const DASHBOARD_WIDTH: u16 = 1920;
+const DASHBOARD_HEIGHT: u16 = 1080;
+const DASHBOARD_DISPLAY_NAME: &str = "_DASHBOARD";
+
+pub struct WayVRContext {
+    wayvr: Rc<RefCell<WayVRData>>,
+    display: wayvr::display::DisplayHandle,
+}
+
+impl WayVRContext {
+    pub fn new(
+        wvr: Rc<RefCell<WayVRData>>,
+        display: wayvr::display::DisplayHandle,
+    ) -> anyhow::Result<Self> {
+        Ok(Self {
+            wayvr: wvr.clone(),
+            display,
+        })
+    }
+}
+
+struct OverlayToCreate {
+    pub conf_display: config_wayvr::WayVRDisplay,
+    pub disp_handle: display::DisplayHandle,
+}
+
+pub struct WayVRData {
+    display_handle_map: HashMap<display::DisplayHandle, OverlayID>,
+    overlays_to_create: Vec<OverlayToCreate>,
+    dashboard_executed: bool,
+    pub data: WayVR,
+}
+
+impl WayVRData {
+    pub fn new(config: wayvr::Config) -> anyhow::Result<Self> {
+        Ok(Self {
+            display_handle_map: Default::default(),
+            data: WayVR::new(config)?,
+            overlays_to_create: Vec::new(),
+            dashboard_executed: false,
+        })
+    }
+
+    fn get_unique_display_name(&self, mut candidate: String) -> String {
+        let mut num = 0;
+
+        while !self
+            .data
+            .state
+            .displays
+            .vec
+            .iter()
+            .flatten()
+            .any(|d| d.obj.name == candidate)
+        {
+            if num > 0 {
+                candidate = format!("{} ({})", candidate, num);
+            }
+            num += 1;
+        }
+
+        candidate
+    }
+}
+
+pub struct WayVRInteractionHandler {
+    context: Rc<RefCell<WayVRContext>>,
+    mouse_transform: Affine2,
+}
+
+impl WayVRInteractionHandler {
+    pub fn new(context: Rc<RefCell<WayVRContext>>, mouse_transform: Affine2) -> Self {
+        Self {
+            context,
+            mouse_transform,
+        }
+    }
+}
+
+impl InteractionHandler for WayVRInteractionHandler {
+    fn on_hover(
+        &mut self,
+        _app: &mut state::AppState,
+        hit: &input::PointerHit,
+    ) -> Option<input::Haptics> {
+        let ctx = self.context.borrow();
+
+        let wayvr = &mut ctx.wayvr.borrow_mut().data;
+
+        if let Some(disp) = wayvr.state.displays.get(&ctx.display) {
+            let pos = self.mouse_transform.transform_point2(hit.uv);
+            let x = ((pos.x * disp.width as f32) as i32).max(0);
+            let y = ((pos.y * disp.height as f32) as i32).max(0);
+
+            let ctx = self.context.borrow();
+            wayvr.state.send_mouse_move(ctx.display, x as u32, y as u32);
+        }
+
+        wayvr.state.pending_haptic.take()
+    }
+
+    fn on_left(&mut self, _app: &mut state::AppState, _pointer: usize) {
+        // Ignore event
+    }
+
+    fn on_pointer(&mut self, _app: &mut state::AppState, hit: &input::PointerHit, pressed: bool) {
+        if let Some(index) = match hit.mode {
+            input::PointerMode::Left => Some(wayvr::MouseIndex::Left),
+            input::PointerMode::Middle => Some(wayvr::MouseIndex::Center),
+            input::PointerMode::Right => Some(wayvr::MouseIndex::Right),
+            _ => {
+                // Unknown pointer event, ignore
+                None
+            }
+        } {
+            let ctx = self.context.borrow();
+            let wayvr = &mut ctx.wayvr.borrow_mut().data;
+            if pressed {
+                wayvr.state.send_mouse_down(ctx.display, index);
+            } else {
+                wayvr.state.send_mouse_up(ctx.display, index);
+            }
+        }
+    }
+
+    fn on_scroll(&mut self, _app: &mut state::AppState, _hit: &input::PointerHit, delta: f32) {
+        let ctx = self.context.borrow();
+        ctx.wayvr
+            .borrow_mut()
+            .data
+            .state
+            .send_mouse_scroll(ctx.display, delta);
+    }
+}
+
+pub struct WayVRRenderer {
+    dmabuf_image: Option<Arc<vulkano::image::Image>>,
+    view: Option<Arc<vulkano::image::view::ImageView>>,
+    context: Rc<RefCell<WayVRContext>>,
+    graphics: Arc<WlxGraphics>,
+}
+
+impl WayVRRenderer {
+    pub fn new(
+        app: &state::AppState,
+        wvr: Rc<RefCell<WayVRData>>,
+        display: wayvr::display::DisplayHandle,
+    ) -> anyhow::Result<Self> {
+        Ok(Self {
+            context: Rc::new(RefCell::new(WayVRContext::new(wvr, display)?)),
+            dmabuf_image: None,
+            view: None,
+            graphics: app.graphics.clone(),
+        })
+    }
+}
+
+fn get_or_create_display_by_name(
+    app: &mut AppState,
+    wayvr: &mut WayVRData,
+    disp_name: &str,
+) -> anyhow::Result<display::DisplayHandle> {
+    let disp_handle =
+        if let Some(disp) = WayVR::get_display_by_name(&wayvr.data.state.displays, disp_name) {
+            disp
+        } else {
+            let conf_display = app
+                .session
+                .wayvr_config
+                .get_display(disp_name)
+                .ok_or(anyhow::anyhow!(
+                    "Cannot find display named \"{}\"",
+                    disp_name
+                ))?
+                .clone();
+
+            let disp_handle = wayvr.data.state.create_display(
+                conf_display.width,
+                conf_display.height,
+                disp_name,
+                conf_display.primary.unwrap_or(false),
+            )?;
+
+            wayvr.overlays_to_create.push(OverlayToCreate {
+                conf_display,
+                disp_handle,
+            });
+
+            disp_handle
+        };
+
+    Ok(disp_handle)
+}
+
+fn executable_exists_in_path(command: &str) -> bool {
+    let Ok(path) = std::env::var("PATH") else {
+        return false; // very unlikely to happen
+    };
+    for dir in path.split(':') {
+        let exec_path = std::path::PathBuf::from(dir).join(command);
+        if exec_path.exists() && exec_path.is_file() {
+            return true; // executable found
+        }
+    }
+    false
+}
+
+fn toggle_dashboard<O>(
+    app: &mut AppState,
+    overlays: &mut OverlayContainer<O>,
+    wayvr: &mut WayVRData,
+) -> anyhow::Result<()>
+where
+    O: Default,
+{
+    let conf_dash = &app.session.wayvr_config.dashboard;
+
+    let Some(conf_dash) = &conf_dash else {
+        anyhow::bail!("Dashboard is not configured");
+    };
+
+    if !wayvr.dashboard_executed && !executable_exists_in_path(&conf_dash.exec) {
+        anyhow::bail!("Executable \"{}\" not found", &conf_dash.exec);
+    }
+
+    let (newly_created, disp_handle) = wayvr.data.state.get_or_create_dashboard_display(
+        DASHBOARD_WIDTH,
+        DASHBOARD_HEIGHT,
+        DASHBOARD_DISPLAY_NAME,
+    )?;
+
+    if newly_created {
+        log::info!("Creating dashboard overlay");
+
+        let mut overlay = create_overlay::<O>(
+            app,
+            wayvr,
+            DASHBOARD_DISPLAY_NAME,
+            OverlayToCreate {
+                disp_handle,
+                conf_display: config_wayvr::WayVRDisplay {
+                    attach_to: None,
+                    width: DASHBOARD_WIDTH,
+                    height: DASHBOARD_HEIGHT,
+                    scale: None,
+                    rotation: None,
+                    pos: None,
+                    primary: None,
+                },
+            },
+        )?;
+
+        overlay.state.want_visible = true;
+        overlay.state.spawn_scale = 2.0;
+        overlay.state.spawn_point = vec3a(0.0, -0.35, -1.75);
+        overlay.state.z_order = Z_ORDER_DASHBOARD;
+        overlay.state.reset(app, true);
+
+        let Some(conf_dash) = &app.session.wayvr_config.dashboard else {
+            unreachable!(); /* safe, not possible to trigger */
+        };
+
+        // FIXME: overlay curvature needs to be dispatched for some unknown reason, this value is not set otherwise
+        app.tasks.enqueue(TaskType::Overlay(
+            OverlaySelector::Id(overlay.state.id),
+            Box::new(move |_app, o| {
+                o.curvature = Some(0.15);
+            }),
+        ));
+
+        overlays.add(overlay);
+
+        let args_vec = match &conf_dash.args {
+            Some(args) => gen_args_vec(args),
+            None => vec![],
+        };
+
+        let env_vec = match &conf_dash.env {
+            Some(env) => gen_env_vec(env),
+            None => vec![],
+        };
+
+        let mut userdata = HashMap::new();
+        userdata.insert(String::from("type"), String::from("dashboard"));
+
+        // Start dashboard specified in the WayVR config
+        let _process_handle_unused = wayvr.data.state.spawn_process(
+            disp_handle,
+            &conf_dash.exec,
+            &args_vec,
+            &env_vec,
+            userdata,
+        )?;
+
+        wayvr.dashboard_executed = true;
+
+        return Ok(());
+    }
+
+    let display = wayvr.data.state.displays.get(&disp_handle).unwrap(); // safe
+    let Some(overlay_id) = display.overlay_id else {
+        anyhow::bail!("Overlay ID not set for dashboard display");
+    };
+
+    let cur_visibility = !display.visible;
+
+    wayvr
+        .data
+        .ipc_server
+        .broadcast(PacketServer::WvrStateChanged(if cur_visibility {
+            WvrStateChanged::DashboardShown
+        } else {
+            WvrStateChanged::DashboardHidden
+        }));
+
+    app.tasks.enqueue(TaskType::Overlay(
+        OverlaySelector::Id(overlay_id),
+        Box::new(move |app, o| {
+            // Toggle visibility
+            o.want_visible = cur_visibility;
+            if cur_visibility {
+                o.reset(app, true);
+            }
+        }),
+    ));
+
+    Ok(())
+}
+
+fn create_overlay<O>(
+    app: &mut AppState,
+    data: &mut WayVRData,
+    name: &str,
+    cell: OverlayToCreate,
+) -> anyhow::Result<OverlayData<O>>
+where
+    O: Default,
+{
+    let conf_display = &cell.conf_display;
+    let disp_handle = cell.disp_handle;
+
+    let mut overlay = create_wayvr_display_overlay::<O>(
+        app,
+        conf_display.width,
+        conf_display.height,
+        disp_handle,
+        conf_display.scale.unwrap_or(1.0),
+        name,
+    )?;
+
+    data.display_handle_map
+        .insert(disp_handle, overlay.state.id);
+
+    if let Some(attach_to) = &conf_display.attach_to {
+        overlay.state.relative_to = attach_to.get_relative_to();
+    }
+
+    if let Some(rot) = &conf_display.rotation {
+        overlay.state.spawn_rotation =
+            glam::Quat::from_axis_angle(Vec3::from_slice(&rot.axis), f32::to_radians(rot.angle));
+    }
+
+    if let Some(pos) = &conf_display.pos {
+        overlay.state.spawn_point = Vec3A::from_slice(pos);
+    }
+
+    let display = data.data.state.displays.get_mut(&disp_handle).unwrap(); // Never fails
+    display.overlay_id = Some(overlay.state.id);
+
+    Ok(overlay)
+}
+
+fn create_queued_displays<O>(
+    app: &mut AppState,
+    data: &mut WayVRData,
+    overlays: &mut OverlayContainer<O>,
+) -> anyhow::Result<()>
+where
+    O: Default,
+{
+    let overlays_to_create = std::mem::take(&mut data.overlays_to_create);
+
+    for cell in overlays_to_create {
+        let Some(disp) = data.data.state.displays.get(&cell.disp_handle) else {
+            continue; // this shouldn't happen
+        };
+
+        let name = disp.name.clone();
+
+        let overlay = create_overlay::<O>(app, data, name.as_str(), cell)?;
+        overlays.add(overlay); // Insert freshly created WayVR overlay into wlx stack
+    }
+
+    Ok(())
+}
+
+pub fn tick_events<O>(app: &mut AppState, overlays: &mut OverlayContainer<O>) -> anyhow::Result<()>
+where
+    O: Default,
+{
+    let Some(r_wayvr) = app.wayvr.clone() else {
+        return Ok(());
+    };
+
+    let mut wayvr = r_wayvr.borrow_mut();
+
+    while let Some(signal) = wayvr.data.state.signals.read() {
+        match signal {
+            wayvr::WayVRSignal::DisplayVisibility(display_handle, visible) => {
+                if let Some(overlay_id) = wayvr.display_handle_map.get(&display_handle) {
+                    let overlay_id = *overlay_id;
+                    wayvr
+                        .data
+                        .state
+                        .set_display_visible(display_handle, visible);
+                    app.tasks.enqueue(TaskType::Overlay(
+                        OverlaySelector::Id(overlay_id),
+                        Box::new(move |_app, o| {
+                            o.want_visible = visible;
+                        }),
+                    ));
+                }
+            }
+            wayvr::WayVRSignal::DisplayWindowLayout(display_handle, layout) => {
+                wayvr.data.state.set_display_layout(display_handle, layout);
+            }
+            wayvr::WayVRSignal::BroadcastStateChanged(packet) => {
+                wayvr
+                    .data
+                    .ipc_server
+                    .broadcast(packet_server::PacketServer::WvrStateChanged(packet));
+            }
+        }
+    }
+
+    let res = wayvr.data.tick_events(app)?;
+    drop(wayvr);
+
+    for result in res {
+        match result {
+            wayvr::TickTask::NewExternalProcess(req) => {
+                let config = &app.session.wayvr_config;
+
+                let disp_name = if let Some(display_name) = req.env.display_name {
+                    config
+                        .get_display(display_name.as_str())
+                        .map(|_| display_name)
+                } else {
+                    config
+                        .get_default_display()
+                        .map(|(display_name, _)| display_name)
+                };
+
+                if let Some(disp_name) = disp_name {
+                    let mut wayvr = r_wayvr.borrow_mut();
+
+                    log::info!("Registering external process with PID {}", req.pid);
+
+                    let disp_handle = get_or_create_display_by_name(app, &mut wayvr, &disp_name)?;
+
+                    wayvr.data.state.add_external_process(disp_handle, req.pid);
+
+                    wayvr
+                        .data
+                        .state
+                        .manager
+                        .add_client(wayvr::client::WayVRClient {
+                            client: req.client,
+                            display_handle: disp_handle,
+                            pid: req.pid,
+                        });
+                }
+            }
+            wayvr::TickTask::NewDisplay(cpar, disp_handle) => {
+                log::info!("Creating new display with name \"{}\"", cpar.name);
+
+                let mut wayvr = r_wayvr.borrow_mut();
+
+                let unique_name = wayvr.get_unique_display_name(cpar.name);
+
+                let disp_handle = match disp_handle {
+                    Some(d) => d,
+                    None => wayvr.data.state.create_display(
+                        cpar.width,
+                        cpar.height,
+                        &unique_name,
+                        false,
+                    )?,
+                };
+
+                wayvr.overlays_to_create.push(OverlayToCreate {
+                    disp_handle,
+                    conf_display: config_wayvr::WayVRDisplay {
+                        attach_to: Some(config_wayvr::AttachTo::from_packet(&cpar.attach_to)),
+                        width: cpar.width,
+                        height: cpar.height,
+                        pos: None,
+                        primary: None,
+                        rotation: None,
+                        scale: cpar.scale,
+                    },
+                });
+            }
+            wayvr::TickTask::DropOverlay(overlay_id) => {
+                app.tasks
+                    .enqueue(TaskType::DropOverlay(OverlaySelector::Id(overlay_id)));
+            }
+        }
+    }
+
+    let mut wayvr = r_wayvr.borrow_mut();
+    create_queued_displays(app, &mut wayvr, overlays)?;
+
+    Ok(())
+}
+
+impl WayVRRenderer {
+    fn ensure_dmabuf(&mut self, data: wayvr::egl_data::DMAbufData) -> anyhow::Result<()> {
+        if self.dmabuf_image.is_none() {
+            // First init
+            let mut planes = [FramePlane::default(); 4];
+            planes[0].fd = Some(data.fd);
+            planes[0].offset = data.offset as u32;
+            planes[0].stride = data.stride;
+
+            let ctx = self.context.borrow_mut();
+            let wayvr = ctx.wayvr.borrow_mut();
+            if let Some(disp) = wayvr.data.state.displays.get(&ctx.display) {
+                let frame = DmabufFrame {
+                    format: FrameFormat {
+                        width: disp.width as u32,
+                        height: disp.height as u32,
+                        fourcc: FourCC {
+                            value: data.mod_info.fourcc,
+                        },
+                        modifier: data.mod_info.modifiers[0], /* possibly not proper? */
+                        ..Default::default()
+                    },
+                    num_planes: 1,
+                    planes,
+                };
+
+                drop(wayvr);
+
+                let layouts: Vec<SubresourceLayout> = vec![SubresourceLayout {
+                    offset: data.offset as _,
+                    size: 0,
+                    row_pitch: data.stride as _,
+                    array_pitch: None,
+                    depth_pitch: None,
+                }];
+
+                let tex = self.graphics.dmabuf_texture_ex(
+                    frame,
+                    vulkano::image::ImageTiling::DrmFormatModifier,
+                    layouts,
+                    data.mod_info.modifiers,
+                )?;
+                self.dmabuf_image = Some(tex.clone());
+                self.view = Some(vulkano::image::view::ImageView::new_default(tex).unwrap());
+            } else {
+                anyhow::bail!("Failed to fetch WayVR display")
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl OverlayRenderer for WayVRRenderer {
+    fn init(&mut self, _app: &mut state::AppState) -> anyhow::Result<()> {
+        Ok(())
+    }
+
+    fn pause(&mut self, _app: &mut state::AppState) -> anyhow::Result<()> {
+        let ctx = self.context.borrow_mut();
+        let wayvr = &mut ctx.wayvr.borrow_mut().data;
+        wayvr.state.set_display_visible(ctx.display, false);
+        Ok(())
+    }
+
+    fn resume(&mut self, _app: &mut state::AppState) -> anyhow::Result<()> {
+        let ctx = self.context.borrow_mut();
+        let wayvr = &mut ctx.wayvr.borrow_mut().data;
+        wayvr.state.set_display_visible(ctx.display, true);
+        Ok(())
+    }
+
+    fn render(&mut self, _app: &mut state::AppState) -> anyhow::Result<()> {
+        let ctx = self.context.borrow();
+        let mut wayvr = ctx.wayvr.borrow_mut();
+
+        match wayvr.data.tick_display(ctx.display) {
+            Ok(_) => {}
+            Err(e) => {
+                log::error!("tick_display failed: {}", e);
+                return Ok(()); // do not proceed further
+            }
+        }
+
+        let dmabuf_data = wayvr
+            .data
+            .state
+            .get_dmabuf_data(ctx.display)
+            .ok_or(anyhow::anyhow!("Failed to fetch dmabuf data"))?
+            .clone();
+
+        drop(wayvr);
+        drop(ctx);
+        self.ensure_dmabuf(dmabuf_data.clone())?;
+
+        Ok(())
+    }
+
+    fn view(&mut self) -> Option<Arc<vulkano::image::view::ImageView>> {
+        self.view.clone()
+    }
+
+    fn frame_transform(&mut self) -> Option<FrameTransform> {
+        self.view.as_ref().map(|view| FrameTransform {
+            extent: view.image().extent(),
+            ..Default::default()
+        })
+    }
+}
+
+#[allow(dead_code)]
+pub fn create_wayvr_display_overlay<O>(
+    app: &mut state::AppState,
+    display_width: u16,
+    display_height: u16,
+    display_handle: wayvr::display::DisplayHandle,
+    display_scale: f32,
+    name: &str,
+) -> anyhow::Result<OverlayData<O>>
+where
+    O: Default,
+{
+    let transform = ui_transform(&[display_width as u32, display_height as u32]);
+
+    let state = OverlayState {
+        name: format!("WayVR - {}", name).into(),
+        keyboard_focus: Some(KeyboardFocus::WayVR),
+        want_visible: true,
+        interactable: true,
+        grabbable: true,
+        spawn_scale: display_scale,
+        spawn_point: vec3a(0.0, -0.1, -1.0),
+        interaction_transform: transform,
+        ..Default::default()
+    };
+
+    let wayvr = app.get_wayvr()?;
+
+    let renderer = WayVRRenderer::new(app, wayvr, display_handle)?;
+    let context = renderer.context.clone();
+
+    let backend = Box::new(SplitOverlayBackend {
+        renderer: Box::new(renderer),
+        interaction: Box::new(WayVRInteractionHandler::new(context, Affine2::IDENTITY)),
+    });
+
+    Ok(OverlayData {
+        state,
+        backend,
+        ..Default::default()
+    })
+}
+
+fn show_display<O>(wayvr: &mut WayVRData, overlays: &mut OverlayContainer<O>, display_name: &str)
+where
+    O: Default,
+{
+    if let Some(display) = WayVR::get_display_by_name(&wayvr.data.state.displays, display_name) {
+        if let Some(overlay_id) = wayvr.display_handle_map.get(&display) {
+            if let Some(overlay) = overlays.mut_by_id(*overlay_id) {
+                overlay.state.want_visible = true;
+            }
+        }
+
+        wayvr.data.state.set_display_visible(display, true);
+    }
+}
+
+fn action_app_click<O>(
+    app: &mut AppState,
+    overlays: &mut OverlayContainer<O>,
+    catalog_name: &Arc<str>,
+    app_name: &Arc<str>,
+) -> anyhow::Result<()>
+where
+    O: Default,
+{
+    let wayvr = app.get_wayvr()?.clone();
+
+    let catalog = app
+        .session
+        .wayvr_config
+        .get_catalog(catalog_name)
+        .ok_or(anyhow::anyhow!(
+            "Failed to get catalog \"{}\"",
+            catalog_name
+        ))?
+        .clone();
+
+    if let Some(app_entry) = catalog.get_app(app_name) {
+        let mut wayvr = wayvr.borrow_mut();
+
+        let disp_handle =
+            get_or_create_display_by_name(app, &mut wayvr, &app_entry.target_display)?;
+
+        let args_vec = match &app_entry.args {
+            Some(args) => gen_args_vec(args),
+            None => vec![],
+        };
+
+        let env_vec = match &app_entry.env {
+            Some(env) => gen_env_vec(env),
+            None => vec![],
+        };
+
+        // Terminate existing process if required
+        if let Some(process_handle) =
+            wayvr
+                .data
+                .state
+                .process_query(disp_handle, &app_entry.exec, &args_vec, &env_vec)
+        {
+            // Terminate process
+            wayvr.data.terminate_process(process_handle);
+        } else {
+            // Spawn process
+            wayvr.data.state.spawn_process(
+                disp_handle,
+                &app_entry.exec,
+                &args_vec,
+                &env_vec,
+                Default::default(),
+            )?;
+
+            show_display::<O>(&mut wayvr, overlays, app_entry.target_display.as_str());
+        }
+    }
+
+    Ok(())
+}
+
+pub fn action_display_click<O>(
+    app: &mut AppState,
+    overlays: &mut OverlayContainer<O>,
+    display_name: &Arc<str>,
+    action: &WayVRDisplayClickAction,
+) -> anyhow::Result<()>
+where
+    O: Default,
+{
+    let wayvr = app.get_wayvr()?;
+    let mut wayvr = wayvr.borrow_mut();
+
+    let Some(handle) = WayVR::get_display_by_name(&wayvr.data.state.displays, display_name) else {
+        return Ok(());
+    };
+
+    let Some(display) = wayvr.data.state.displays.get_mut(&handle) else {
+        return Ok(());
+    };
+
+    let Some(overlay_id) = display.overlay_id else {
+        return Ok(());
+    };
+
+    let Some(overlay) = overlays.mut_by_id(overlay_id) else {
+        return Ok(());
+    };
+
+    match action {
+        WayVRDisplayClickAction::ToggleVisibility => {
+            // Toggle visibility
+            overlay.state.want_visible = !overlay.state.want_visible;
+        }
+        WayVRDisplayClickAction::Reset => {
+            // Show it at the front
+            overlay.state.want_visible = true;
+            overlay.state.reset(app, true);
+        }
+    }
+
+    Ok(())
+}
+
+pub fn wayvr_action<O>(app: &mut AppState, overlays: &mut OverlayContainer<O>, action: &WayVRAction)
+where
+    O: Default,
+{
+    match action {
+        WayVRAction::AppClick {
+            catalog_name,
+            app_name,
+        } => {
+            if let Err(e) = action_app_click(app, overlays, catalog_name, app_name) {
+                // Happens if something went wrong with initialization
+                // or input exec path is invalid. Do nothing, just print an error
+                error_toast(app, "action_app_click failed", e);
+            }
+        }
+        WayVRAction::DisplayClick {
+            display_name,
+            action,
+        } => {
+            if let Err(e) = action_display_click::<O>(app, overlays, display_name, action) {
+                error_toast(app, "action_display_click failed", e);
+            }
+        }
+        WayVRAction::ToggleDashboard => {
+            let wayvr = app.get_wayvr().unwrap(); /* safe */
+            let mut wayvr = wayvr.borrow_mut();
+
+            if let Err(e) = toggle_dashboard::<O>(app, overlays, &mut wayvr) {
+                error_toast(app, "toggle_dashboard failed", e);
+            }
+        }
+    }
+}
@@ -43,6 +43,15 @@ main_layout:
    - ["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", ~]

+# When using the purple pointer...
+# None   - No special functionality when using purple pointer (Default)
+# Shift  - Use same functionality as the orange pointer
+# Ctrl   - Use Main layout with Ctrl modifier
+# Alt    - Use Main layout with Alt modifier
+# Super  - Use Main layout with Super (WinKey) modifier
+# Meta   - Use Main layout with Meta (AltGr) modifier
+alt_modifier: None
+
 # Shell commands to be used in a layout.
 # Value is an array of string arguments.
 exec_commands:
@@ -1,4 +1,4 @@
-# looking to make changes? 
+# looking to make changes?
 # drop me in ~/.config/wlxoverlay/watch.yaml
 #

@@ -24,13 +24,25 @@ elements:
      - type: Window
        target: settings
        action: ShowUi # only triggers if not exists
-      - type: Window 
+      - type: Window
        target: settings
        action: Destroy # only triggers if exists since before current frame

+  # Dashboard toggle button
+  - type: Button
+    rect: [32, 162, 48, 36]
+    corner_radius: 4
+    font_size: 15
+    bg_color: "#2288FF"
+    fg_color: "#24273a"
+    text: "Dash"
+    click_up:
+      - type: WayVR
+        action: ToggleDashboard
+
  # Keyboard button
  - type: Button
-    rect: [32, 162, 60, 36]
+    rect: [84, 162, 48, 36]
    corner_radius: 4
    font_size: 15
    fg_color: "#24273a"
@@ -55,17 +67,17 @@ elements:
    scroll_up:
      - type: Overlay
        target: "kbd"
-        action: 
+        action:
          Opacity: { delta: 0.025 }
    scroll_down:
      - type: Overlay
        target: "kbd"
-        action: 
+        action:
          Opacity: { delta: -0.025 }

  # bottom row, of keyboard + overlays
  - type: OverlayList
-    rect: [94, 160, 306, 40]
+    rect: [134, 160, 266, 40]
    corner_radius: 4
    font_size: 15
    fg_color: "#cad3f5"
@@ -75,9 +87,9 @@ elements:
    long_click_up: Reset
    right_up: ToggleImmovable
    middle_up: ToggleInteraction
-    scroll_up: 
+    scroll_up:
      Opacity: { delta: 0.025 }
-    scroll_down: 
+    scroll_down:
      Opacity: { delta: -0.025 }

  # local clock
@@ -89,7 +101,7 @@ elements:
    source: Clock
    format: "%H:%M" # 23:59
    #format: "%I:%M %p" # 11:59 PM
- 
+
  # local date
  - type: Label
    rect: [20, 117, 200, 20]
@@ -116,7 +128,7 @@ elements:
    font_size: 24 # Use 18 for 12-hour time
    fg_color: "#8bd5ca"
    source: Clock
-    timezone: "Asia/Tokyo" # change TZ1 here
+    timezone: 0
    format: "%H:%M" # 23:59
    #format: "%I:%M %p" # 11:59 PM
  - type: Label
@@ -124,9 +136,9 @@ elements:
    corner_radius: 4
    font_size: 14
    fg_color: "#8bd5ca"
-    source: Static
-    text: "Tokyo" # change TZ1 label here
- 
+    source: Timezone
+    timezone: 0
+
  # alt clock 2
  - type: Label
    rect: [210, 150, 200, 50]
@@ -134,7 +146,7 @@ elements:
    font_size: 24 # Use 18 for 12-hour time
    fg_color: "#b7bdf8"
    source: Clock
-    timezone: "America/Chicago" # change TZ2 here
+    timezone: 1
    format: "%H:%M" # 23:59
    #format: "%I:%M %p" # 11:59 PM
  - type: Label
@@ -142,8 +154,8 @@ elements:
    corner_radius: 4
    font_size: 14
    fg_color: "#b7bdf8"
-    source: Static
-    text: "Chicago" # change TZ2 label here
+    source: Timezone
+    timezone: 1

  # batteries
  - type: BatteryList
@@ -167,7 +179,7 @@ elements:
    text: "Vol +"
    click_down:
      - type: Exec
-        command: [ "pactl", "set-sink-volume", "@DEFAULT_SINK@", "+5%" ]
+        command: ["pactl", "set-sink-volume", "@DEFAULT_SINK@", "+5%"]
  - type: Button
    rect: [315, 116, 70, 32]
    corner_radius: 4
@@ -177,4 +189,4 @@ elements:
    text: "Vol -"
    click_down:
      - type: Exec
-        command: [ "pactl", "set-sink-volume", "@DEFAULT_SINK@", "-5%" ]
+        command: ["pactl", "set-sink-volume", "@DEFAULT_SINK@", "-5%"]
@@ -0,0 +1,71 @@
+# This is an example WayVR panel configuration. It demonstrates all the capabilities of this module.
+# looking to make changes?
+# drop me in ~/.config/wlxoverlay/wayvr.yaml
+#
+
+version: 1
+
+# Set to true if you want to make Wyland server instantly available.
+# By default, WayVR starts only when it's needed.
+# (this option is primarily used for remote starting external processes and development purposes)
+run_compositor_at_start: false 
+
+# Automatically close overlays with zero window count?
+auto_hide: true
+
+# For how long an overlay should be visible in case if there are no windows present? (in milliseconds, auto_hide needs to be enabled)
+# This value shouldn't be set at 0, because some programs could re-initialize a window during startup (splash screens for example)
+auto_hide_delay: 750
+
+# In milliseconds
+keyboard_repeat_delay: 200
+
+# Chars per second
+keyboard_repeat_rate: 50
+
+# WayVR-compatible dashboard.
+# For now, there is only one kind of dashboard with WayVR IPC support (WayVR Dashboard).
+# Build instructions: https://github.com/olekolek1000/wayvr-dashboard
+# exec: Executable path, for example /home/USER/wayvr_dashboard/src-tauri/target/release/wayvr_dashboard
+# GDK_BACKEND=wayland: Force-use Wayland for GTK apps
+dashboard:
+  exec: "wayvr_dashboard"
+  args: ""
+  env: ["GDK_BACKEND=wayland"]
+
+displays:
+  Watch:
+    width: 400
+    height: 600
+    scale: 0.4
+    attach_to: "HandRight" # HandLeft, HandRight
+    pos: [0.0, 0.0, 0.125]
+    rotation: {axis: [1.0, 0.0, 0.0], angle: -45.0}
+  Disp1:
+    width: 640
+    height: 480
+    primary: true # Required if you want to attach external processes (not spawned by WayVR itself) without WAYVR_DISPLAY_NAME set
+  Disp2:
+    width: 1280
+    height: 720
+    scale: 2.0
+
+catalogs:
+  default_catalog:
+    apps:
+      - name: "Calc"
+        target_display: "Disp1"
+        exec: "kcalc"
+        env: ["FOO=bar"]
+        shown_at_start: false
+
+      - name: "htop"
+        target_display: "Watch"
+        exec: "konsole"
+        args: "-e htop"
+
+      - name: "Browser"
+        target_display: "Disp2"
+        exec: "cage"
+        args: "chromium -- --incognito"
+        
@@ -1,15 +1,24 @@
-use std::{io::Cursor, sync::Arc};
-
 use anyhow::bail;
 use glam::Affine3A;
 use idmap::IdMap;
 use rodio::{Decoder, OutputStream, OutputStreamHandle, Source};
 use serde::{Deserialize, Serialize};
 use smallvec::{smallvec, SmallVec};
+use std::{io::Cursor, sync::Arc};
 use vulkano::image::view::ImageView;

+#[cfg(feature = "wayvr")]
+use {
+    crate::config_wayvr::{self, WayVRConfig},
+    crate::overlays::wayvr::WayVRData,
+    std::{cell::RefCell, rc::Rc},
+};
+
+#[cfg(feature = "osc")]
+use crate::backend::osc::OscSender;
+
 use crate::{
-    backend::{input::InputState, task::TaskContainer},
+    backend::{input::InputState, overlay::OverlayID, task::TaskContainer},
    config::{AStrMap, GeneralConfig},
    config_io,
    graphics::WlxGraphics,
@@ -22,6 +31,14 @@ use crate::{
    },
 };

+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum KeyboardFocus {
+    PhysicalScreen,
+
+    #[allow(dead_code)] // Not available if "wayvr" feature is disabled
+    WayVR, // (for now without wayland window id data, it's handled internally),
+}
+
 pub struct AppState {
    pub fc: FontCache,
    pub session: AppSession,
@@ -33,6 +50,13 @@ pub struct AppState {
    pub screens: SmallVec<[ScreenMeta; 8]>,
    pub anchor: Affine3A,
    pub sprites: AStrMap<Arc<ImageView>>,
+    pub keyboard_focus: KeyboardFocus,
+
+    #[cfg(feature = "osc")]
+    pub osc_sender: Option<OscSender>,
+
+    #[cfg(feature = "wayvr")]
+    pub wayvr: Option<Rc<RefCell<WayVRData>>>, // Dynamically created if requested
 }

 impl AppState {
@@ -71,12 +95,26 @@ impl AppState {
            shaders.insert("frag_swapchain", shader);
        }

+        #[cfg(feature = "wayvr")]
+        let mut tasks = TaskContainer::new();
+
+        #[cfg(not(feature = "wayvr"))]
+        let tasks = TaskContainer::new();
+
        let session = AppSession::load();

+        #[cfg(feature = "wayvr")]
+        let wayvr = session
+            .wayvr_config
+            .post_load(&session.config, &mut tasks)?;
+
+        #[cfg(feature = "osc")]
+        let osc_sender = crate::backend::osc::OscSender::new(session.config.osc_out_port).ok();
+
        Ok(AppState {
            fc: FontCache::new(session.config.primary_font.clone())?,
            session,
-            tasks: TaskContainer::new(),
+            tasks,
            graphics,
            input_state: InputState::new(),
            hid_provider: crate::hid::initialize(),
@@ -84,20 +122,44 @@ impl AppState {
            screens: smallvec![],
            anchor: Affine3A::IDENTITY,
            sprites: AStrMap::new(),
+            keyboard_focus: KeyboardFocus::PhysicalScreen,
+
+            #[cfg(feature = "osc")]
+            osc_sender,
+
+            #[cfg(feature = "wayvr")]
+            wayvr,
        })
    }
+
+    #[cfg(feature = "wayvr")]
+    #[allow(dead_code)]
+    pub fn get_wayvr(&mut self) -> anyhow::Result<Rc<RefCell<WayVRData>>> {
+        if let Some(wvr) = &self.wayvr {
+            Ok(wvr.clone())
+        } else {
+            let wayvr = Rc::new(RefCell::new(WayVRData::new(
+                WayVRConfig::get_wayvr_config(&self.session.config, &self.session.wayvr_config),
+            )?));
+            self.wayvr = Some(wayvr.clone());
+            Ok(wayvr)
+        }
+    }
 }

 pub struct AppSession {
    pub config: GeneralConfig,

+    #[cfg(feature = "wayvr")]
+    pub wayvr_config: WayVRConfig,
+
    pub toast_topics: IdMap<ToastTopic, DisplayMethod>,
 }

 impl AppSession {
    pub fn load() -> Self {
-        let config_root_path = config_io::ensure_config_root();
-        log::info!("Config root path: {}", config_root_path.to_string_lossy());
+        let config_root_path = config_io::ConfigRoot::Generic.ensure_dir();
+        log::info!("Config root path: {:?}", config_root_path);
        let config = GeneralConfig::load_from_disk();

        let mut toast_topics = IdMap::new();
@@ -109,9 +171,14 @@ impl AppSession {
            toast_topics.insert(*k, *v);
        });

+        #[cfg(feature = "wayvr")]
+        let wayvr_config = config_wayvr::load_wayvr();
+
        AppSession {
            config,
            toast_topics,
+            #[cfg(feature = "wayvr")]
+            wayvr_config,
        }
    }
 }
@@ -160,7 +227,7 @@ impl AudioOutput {

 pub struct ScreenMeta {
    pub name: Arc<str>,
-    pub id: usize,
+    pub id: OverlayID,
    pub native_handle: u32,
 }
Author	SHA1	Message	Date
galister	009862e2a2	Release 25.3	2025-03-02 21:52:50 +09:00
Aleksander	075e55a8e8	WayVR: Add `DashboardShown` and `DashboardHidden` events, add `WlxInputState` support (#167 ) Wlx: Fix various Clippy warnings	2025-02-28 21:05:27 +00:00
AdiMCS	e66a8d27c9	Add "Toggle Dashboard" button to the WayVR example watch config (#166 )	2025-02-28 01:07:55 +00:00
galister	507ff7353e	Release 25.2	2025-02-20 06:26:35 +09:00
galister	c5a82c2879	update libmonado	2025-02-20 06:26:35 +09:00
Diamond White	965174c781	seperate combined UInputHandle into two handles for mouse and keyboard each (#155 )	2025-02-12 19:24:42 +00:00
Aleksander	bf3f3dafbe	Merge pull request #154 from olekolek1000/wayvr_dashboard_ipc WayVR: Do not hard-error in case if the user bought NVIDIA	2025-02-11 22:43:38 +01:00
Aleksander	4701d2b734	WayVR: Do not hard-error in case if the user bought NVIDIA	2025-02-11 22:30:38 +01:00
Aleksander	e44872f831	Merge pull request #146 from olekolek1000/wayvr_dashboard_ipc WayVR: Layouting system, state changing feedback, process userdata, various IPC changes	2025-01-31 20:12:04 +01:00
Aleksander	3c67abcebb	WayVR: Layouting system, state changing feedback, process userdata, various IPC changes WayVR: - Layouting system (tiled and stacked) IPC: - Implemented routes: `WvrDisplaySetWindowLayout`, `WvrDisplayWindowList`, `WvrWindowSetVisible`, `WvrProcessGet`, - Packet broadcasting - State change feedback to the client (displays/windows/processes)	2025-01-31 20:00:56 +01:00
Jay	da129b62b3	Add UI button actions to send arbitrary OSC values. (#140 ) * osc: start adding osc buttons a button action that sends an osc parameter. struggling with borrows in openxr.rs and openvr.rs when getting the osc sender. * osc: fix osc sender buttons by passing a ref to the device list to send_params instead of the entire app state. * osc: fix warnings * osc: conditionally use OscSender crate in state.rs * osc: fix button.rs compile errors without osc/wayvr features * osc: add other types: int, bool, string. play thump noise when sent. * osc: fix build without osc feature i just want to use OscType directly, but since it doesn't derive serde::Deserialize, i can't just have one OscType action or list of actions... * merge typed actions to one action, support multiple values. i added a new struct OscValue that has Deserialize, and now the action just converts that to the corresponding OscType when sending the parameters. perhaps not the most elegant solution, but it's the best i can think of without modifying the rosc crate. * run `cargo fmt`	2025-01-26 11:23:18 +00:00
Aleksander	52298ccfdf	Merge pull request #145 from olekolek1000/wayvr_dashboard_ipc WayVR: Improvements (WayVR Dash 0.1.1)	2025-01-23 20:49:52 +01:00
Aleksander	8766999e28	WayVR: Haptics support, fix warnings, EGL fix, display visibility IPC, bump dashboard resolution to 1080p	2025-01-23 20:26:34 +01:00
Aleksander	5d9f80ea40	Merge pull request #144 from olekolek1000/wayvr_dashboard_ipc WayVR: def_false fix	2025-01-21 18:53:43 +01:00
Aleksander	ba5228c643	WayVR: def_false fix	2025-01-21 18:42:00 +01:00
Aleksander	8ba0b2ca04	Merge pull request #143 from olekolek1000/wayvr_dashboard_ipc WayVR: Add config default values (Fixes #142)	2025-01-20 23:37:00 +01:00
Aleksander	b22af57000	WayVR: Add config default values (Fixes #142 )	2025-01-20 23:22:48 +01:00
galister	2bf8984ba1	fix uidev build (#141 )	2025-01-20 21:27:47 +00:00
Aleksander	3c792608e7	config_io: Support `wayvr.conf.d` directory, refactoring (#139 )	2025-01-20 14:26:17 +00:00
Aleksander	b209f79188	Merge pull request #137 from olekolek1000/wayvr_dashboard_ipc WayVR: Display removal support (implement `WvrDisplayRemove`)	2025-01-19 15:43:11 +01:00
Aleksander	80d9b02ac7	WayVR: Display removal support	2025-01-19 15:20:52 +01:00
Aleksander	244f8cfa80	Merge pull request #136 from olekolek1000/dash_button Dashboard button in the watch, Toast error messages	2025-01-19 14:12:44 +01:00
Aleksander	6c95607d44	Watch: Add "Toggle Dashboard" button by default, Toast: Show user-specific error messages in various places, WayVR: Modify example env vars	2025-01-19 00:53:59 +01:00
Aleksander	bbed686a5e	Merge pull request #135 from olekolek1000/wayvr_dashboard_ipc WayVR: Add dmabuf (backend_drm) to the compositor	2025-01-16 22:39:19 +01:00
Aleksander	83026deaab	WayVR: Add dmabuf (backend_drm) to the compositor. Fixes crash for webkitgtk apps	2025-01-16 22:27:13 +01:00
Aleksander	aa2e74f6b6	Merge pull request #134 from olekolek1000/wayvr_dashboard_ipc WayVR: Update IPC, send runtime info, update deps	2025-01-14 22:54:27 +01:00
Aleksander	d8180bb4ed	WayVR: Update IPC, send runtime info, update deps	2025-01-14 22:42:18 +01:00
Aleksander	ff150100b4	Merge pull request #132 from olekolek1000/wayvr_dashboard_ipc WayVR: IPC: Fix process launcher calling create_display two times	2025-01-12 17:04:17 +01:00
Aleksander	de6c5b8ad9	WayVR: Fix process launching calling create_display two times	2025-01-12 16:30:07 +01:00
Aleksander galister Jay Marcus Howser Joshua Vandaële	eb3087f230	Merge Staging into main (#130 ) * config: add use_passthrough * do not use ALPHA_BLEND if passthrough is off * keyboard.yaml auto_labels * OSC: Finish XSOverlay parity (#124) * osc-battery - utilise match return value to set parameter this just lets parameter be a `&str` instead of a `String`, and reduces repetition. * osc-battery - fix error where trackers were 1-indexed instead of 0-indexed * osc-battery: xsoverlay parity! add average tracker and controller battery parameters. this should now be in parity with xsoverlay's parameters. gone back to 1-indexing trackers because it's more user-friendly, so other programs can standardise more easily. * osc battery: ...that was not 1-indexed. no idea how I made that mistake but the sent tracker parameters were actually still 0-indexed. * Update Envision section (#123) add directions for appimage autostart * Add Flatpak instructions (#127) * Add Flatpak instructions fix small inconsistencies between instructions * Clarify Flatpak Steam setup for SteamVR and Monado/WiVRn users * Additional instructions * default AltLayout is None * WayVR: IPC [1]: Local socket server, handshake receiver * WayVR : IPC [2]: `ListDisplays`, `GetDisplay` commands * WayVR: IPC [3]: `ListProcesses`, `TerminateProcess` commands * WayVR: IPC [4]: Minor refactoring * WayVR: Move IPC to separate Git repository * Restore default features in Cargo.toml * WayVR: Implement `WvrDisplayCreate`, Implement `WvrProcessLaunch`, Refactoring * WayVR: Dashboard toggle support, minor refactoring * Update Cargo.toml * fix formatting for openxr_actions.json5 --------- Co-authored-by: galister <22305755+galister@users.noreply.github.com> Co-authored-by: Jay <157681441+cubee-cb@users.noreply.github.com> Co-authored-by: Marcus Howser <mhowser.git@mailbox.org> Co-authored-by: Joshua Vandaële <joshua@vandaele.software>	2025-01-11 08:46:54 +00:00
galister	ab6b5c0b46	default AltLayout is None	2025-01-04 22:05:43 +09:00
Joshua Vandaële	9b2df6be08	Add Flatpak instructions (#127 ) * Add Flatpak instructions fix small inconsistencies between instructions * Clarify Flatpak Steam setup for SteamVR and Monado/WiVRn users * Additional instructions	2025-01-02 12:52:08 +00:00
Marcus Howser	1d4f4337d0	Update Envision section (#123 ) add directions for appimage autostart	2024-12-29 08:32:17 +00:00
Jay	c6ff314e93	OSC: Finish XSOverlay parity (#124 ) * osc-battery - utilise match return value to set parameter this just lets parameter be a `&str` instead of a `String`, and reduces repetition. * osc-battery - fix error where trackers were 1-indexed instead of 0-indexed * osc-battery: xsoverlay parity! add average tracker and controller battery parameters. this should now be in parity with xsoverlay's parameters. gone back to 1-indexing trackers because it's more user-friendly, so other programs can standardise more easily. * osc battery: ...that was not 1-indexed. no idea how I made that mistake but the sent tracker parameters were actually still 0-indexed.	2024-12-29 08:21:59 +00:00
galister	1903271d05	keyboard.yaml auto_labels	2024-12-23 17:16:24 +09:00
galister	4de6116985	do not use ALPHA_BLEND if passthrough is off	2024-12-08 02:19:06 +09:00
galister	65432ebde4	config: add use_passthrough	2024-12-07 07:26:19 +01:00
cubee	a71f4de0ff	fix osc timer and give battery parameters their own timer	2024-11-24 15:13:46 +01:00
cubee	18b2e96079	make parameter String instead of &str this means parameter can be immutable if left unset at initialisation, and we can use format!() macro in the match statements. silly workarounds no more!	2024-11-24 15:13:46 +01:00
cubee	c09da86659	add parameters for device charging state	2024-11-24 15:13:46 +01:00
cubee	e818259b5b	default to -1 if a device has no battery level. this is just to make sure the unwrap() doesn't crash; -1 (or any negative value) is used as the "disconnected" value.	2024-11-24 15:13:46 +01:00
cubee	c96ead7cf0	send osc parameters based on device role, cleanup usings	2024-11-24 15:13:46 +01:00
cubee	546b38204c	use AppState to get device roles i _understand_ now! basically, i did it the "wrong" way first by modifying openxr.rs and openvr.rs to pass battery levels to osc, when really i could have just made osc get the pre-formatted device details from AppState. live and learn, i'm new to rust anyway.	2024-11-24 15:13:46 +01:00
galister	12218828d4	persist keyboard hide state across sessions	2024-11-24 17:37:35 +09:00
galister	26a872e685	bump max curvature to 180deg	2024-11-24 17:23:21 +09:00
galister	add121bd52	screen_render_down default on	2024-11-24 14:35:31 +09:00
galister	3b3138cfe9	update wlx-capture	2024-11-23 21:30:38 +09:00
galister	8d6ff1d3a7	EMEA starts at UTC-1	2024-11-23 20:07:13 +09:00
galister	51174b64d3	move timezones out of watch.yaml + sane defaults	2024-11-23 20:01:49 +09:00
galister	54737b02d3	mouse_move_interval_ms defaults to 10	2024-11-23 18:32:47 +09:00
galister	2c31d57afe	add mouse_move_interval_ms setting	2024-11-23 18:29:12 +09:00
galister	30736575be	update wlx-capture	2024-11-23 18:04:07 +09:00
galister	689fbbe5e4	mute zbus spam	2024-11-20 22:50:22 +01:00
galister	bdf02ea206	update deps, back to env_logger, fix screen transform	2024-11-20 22:50:22 +01:00
galister	5ef2e40b5f	build appimage on staging	2024-11-20 22:50:22 +01:00
galister	e23444aa89	apply pipewire transforms to screens	2024-11-20 22:50:22 +01:00
Aleksander	a3f9f7cc46	Merge pull request #106 from olekolek1000/wayvr_output WayVR: wl_output protocol support	2024-11-18 20:10:49 +01:00
Aleksander	02faf693dc	WayVR: WlOutput support	2024-11-18 19:31:01 +01:00
Aleksander	502cf5d372	WayVR: Display auto-hide support (Fixes #98 ), keyboard settings in config	2024-11-05 16:40:03 +01:00
Aleksander	d212098a98	WayVR: Add Navi33 GPU to the whitelist (7600xt)	2024-11-05 15:28:23 +01:00
galister	ced753235e	clippy	2024-11-05 03:45:22 +09:00
galister	9da1c509e3	fix font loading for 3+ byte codepoints	2024-11-05 03:41:21 +09:00
galister	058baebd0c	fix skybox appearing after closing an app in passtrhu mode	2024-11-04 21:23:30 +09:00
galister	5a060c28f2	support wivrn passthru mode	2024-11-04 21:19:21 +09:00
Aleksander	96db24d02e	WayVR: Modify readme, Various improvements - Add "Quick setup" and images in readme - Implement `click_freeze_time_ms` - Automatically show hidden display if AppClick has been triggered	2024-11-03 16:26:37 +01:00
Anon_11487	24096b7b5a	Configurable Purple laser modifier	2024-11-03 09:34:44 +01:00
Anon_11487	f941f76339	Enable CTRL modifier key with purple laser	2024-11-03 09:34:44 +01:00
Aleksander	50b30565da	Merge pull request #92 from olekolek1000/wayvr_extprocess WayVR: External process support, various tweaks and bugfixes	2024-10-27 21:41:17 +01:00
Aleksander	7e09c010db	WayVR: External process support, various tweaks and bugfixes - Support for foreign wayland clients, WayVR process is now separated into managed and external one - Add `run_compositor_at_start` global param - Add `primary` display param - Export WAYLAND_DISPLAY number into XDG_RUNTIME_DIR directory - Bugfix: Redraw event is not triggered after despawning a process - Sanitization in WayVRConfig::post_load()	2024-10-27 21:26:33 +01:00
Aleksander	66fb2fc48c	Merge pull request #91 from olekolek1000/wayvr_redraw_optim WayVR: Redraw only if needed	2024-10-26 22:09:14 +02:00
Aleksander	9195a338fd	WayVR: Redraw only if needed	2024-10-26 21:57:11 +02:00
Aleksander	cf5eabdfdf	WayVR: `shown_at_start` app param support	2024-10-26 18:44:08 +02:00
galister	7cb8e4a9d2	docs: troubleshooting details	2024-10-25 08:39:25 +00:00
Aleksander	0b1a7e8bc8	Merge pull request #89 from olekolek1000/wayvr_relativeto WayVR: `attach_to`, `pos` and `rotation` params	2024-10-24 22:54:52 +02:00
Aleksander	8d82993704	WayVR: `attach_to`, `pos` and `rotation` spawn parameters in wayvr.yaml config script	2024-10-24 22:44:37 +02:00
galister	cf03beef07	add alt_click	2024-10-22 05:55:25 +09:00
Aleksander	83bf0fff5d	WayVR: Process cleanup support, Refactoring	2024-10-21 20:46:52 +02:00
Aleksander	07d7afa96f	WayVR: WayVRDisplayList ui type, toggle display visibility and pause rendering of them	2024-10-21 20:46:52 +02:00
Aleksander	79d91e3d02	Add `libwayland-dev` and `libegl-dev` deps for CI They are required to compile with `wayvr` target.	2024-10-21 20:46:52 +02:00
Aleksander	d9dddbad11	WayVR: Initial GUI integration The format of the wayvr.yaml configuration file is subject to change at any time.	2024-10-21 20:46:52 +02:00
Aleksander	edfa77e07c	Integrate WayVR into wlx directly	2024-10-18 21:11:56 +02:00
Aleksander	f84d57dc42	Merge pull request #85 from olekolek1000/uidev_fix Fix compilation issues with uidev target or without wayland target	2024-10-17 22:58:10 +02:00
Aleksander	bc9bac8c40	Fix compilation issues with uidev target or without wayland target	2024-10-17 22:53:17 +02:00
Aleksander	9dbd1f994e	Use strongly-typed OverlayID instead of usize	2024-10-17 21:09:19 +02:00
Sefa Eyeoglu	022ae53aea	contrib: add systemd service for Monado autostart Signed-off-by: Sefa Eyeoglu <contact@scrumplex.net>	2024-10-16 20:11:44 +02:00
galister	64b3263309	readme: improve wording	2024-09-30 09:26:06 +00:00