fix drop impl for desktop-portal

adjust error handling
remove dispatch workaround
2026-03-08 04:20:01 +03:00 · 2024-07-05 00:31:16 +02:00 · 2024-07-04 23:44:32 +02:00 · 2024-07-04 22:40:05 +02:00
74 changed files with 3946 additions and 5542 deletions
--- a/.github/workflows/pre-release.yml
+++ b/.github/workflows/pre-release.yml
@@ -55,9 +55,7 @@ jobs:
        # choco install msys2
        # choco install visualstudio2022-workload-vctools
        # choco install pkgconfiglite
-        py -m venv .venv
-        .venv\Scripts\activate.ps1
-        py -m pip install gvsbuild
+        pipx install gvsbuild
        # see https://github.com/wingtk/gvsbuild/pull/1004
        Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
        Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -66,9 +66,7 @@ jobs:
        # choco install msys2
        # choco install visualstudio2022-workload-vctools
        # choco install pkgconfiglite
-        py -m venv .venv
-        .venv\Scripts\activate.ps1
-        py -m pip install gvsbuild
+        pipx install gvsbuild
        # see https://github.com/wingtk/gvsbuild/pull/1004
        Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
        Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
--- a/.github/workflows/tagged-release.yml
+++ b/.github/workflows/tagged-release.yml
@@ -51,9 +51,7 @@ jobs:
        # choco install msys2
        # choco install visualstudio2022-workload-vctools
        # choco install pkgconfiglite
-        py -m venv .venv
-        .venv\Scripts\activate.ps1
-        py -m pip install gvsbuild
+        pipx install gvsbuild
        # see https://github.com/wingtk/gvsbuild/pull/1004
        Move-Item "C:\Program Files\Git\usr\bin" "C:\Program Files\Git\usr\notbin"
        Move-Item "C:\Program Files\Git\bin" "C:\Program Files\Git\notbin"
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -98,9 +98,9 @@ dependencies = [

 [[package]]
 name = "ashpd"
-version = "0.9.1"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfe7e0dd0ac5a401dc116ed9f9119cf9decc625600474cb41f0fc0a0050abc9a"
+checksum = "dd884d7c72877a94102c3715f3b1cd09ff4fac28221add3e57cfbe25c236d093"
 dependencies = [
 "enumflags2",
 "futures-channel",
@@ -200,9 +200,9 @@ dependencies = [

 [[package]]
 name = "async-signal"
-version = "0.2.9"
+version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfb3634b73397aa844481f814fad23bbf07fdb0eabec10f2eb95e58944b1ec32"
+checksum = "794f185324c2f00e771cd9f1ae8b5ac68be2ca7abb129a87afd6e86d228bc54d"
 dependencies = [
 "async-io",
 "async-lock",
@@ -224,9 +224,9 @@ checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"

 [[package]]
 name = "async-trait"
-version = "0.1.81"
+version = "0.1.80"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e0c28dcc82d7c8ead5cb13beb15405b57b8546e93215673ff8ca0349a028107"
+checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -296,15 +296,15 @@ dependencies = [

 [[package]]
 name = "bytes"
-version = "1.6.1"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a12916984aab3fa6e39d655a33e09c0071eb36d6ab3aea5c2d78551f1df6d952"
+checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"

 [[package]]
 name = "cairo-rs"
-version = "0.20.0"
+version = "0.19.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "797fd5a634dcb0ad0d7d583df794deb0a236d88e759cd34b7da20198c6c9d145"
+checksum = "b2ac2a4d0e69036cf0062976f6efcba1aaee3e448594e6514bb2ddf87acce562"
 dependencies = [
 "bitflags 2.6.0",
 "cairo-sys-rs",
@@ -315,9 +315,9 @@ dependencies = [

 [[package]]
 name = "cairo-sys-rs"
-version = "0.20.0"
+version = "0.19.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "428290f914b9b86089f60f5d8a9f6e440508e1bcff23b25afd51502b0a2da88f"
+checksum = "fd3bb3119664efbd78b5e6c93957447944f16bdbced84c17a9f41c7829b81e64"
 dependencies = [
 "glib-sys",
 "libc",
@@ -326,9 +326,9 @@ dependencies = [

 [[package]]
 name = "cc"
-version = "1.1.6"
+version = "1.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aba8f4e9906c7ce3c73463f62a7f0c65183ada1a2d47e397cc8810827f9694f"
+checksum = "74b6a57f98764a267ff415d50a25e6e166f3831a5071af4995296ea97d210490"

 [[package]]
 name = "cfg-expr"
@@ -354,9 +354,9 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"

 [[package]]
 name = "clap"
-version = "4.5.9"
+version = "4.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64acc1846d54c1fe936a78dc189c34e28d3f5afc348403f28ecf53660b9b8462"
+checksum = "84b3edb18336f4df585bc9aa31dd99c036dfa5dc5e9a2939a722a188f3a8970d"
 dependencies = [
 "clap_builder",
 "clap_derive",
@@ -364,9 +364,9 @@ dependencies = [

 [[package]]
 name = "clap_builder"
-version = "4.5.9"
+version = "4.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fb8393d67ba2e7bfaf28a23458e4e2b543cc73a99595511eb207fdb8aede942"
+checksum = "c1c09dd5ada6c6c78075d6fd0da3f90d8080651e2d6cc8eb2f1aaa4034ced708"
 dependencies = [
 "anstream",
 "anstyle",
@@ -758,9 +758,9 @@ dependencies = [

 [[package]]
 name = "gdk-pixbuf"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28bb53ecb56857c683c9ec859908e076dd3969c7d67598bd8b1ce095d211304a"
+checksum = "624eaba126021103c7339b2e179ae4ee8cdab842daab419040710f38ed9f8699"
 dependencies = [
 "gdk-pixbuf-sys",
 "gio",
@@ -770,9 +770,9 @@ dependencies = [

 [[package]]
 name = "gdk-pixbuf-sys"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f6681a0c1330d1d3968bec1529f7172d62819ef0bdbb0d18022320654158b03"
+checksum = "4efa05a4f83c8cc50eb4d883787b919b85e5f1d8dd10b5a1df53bf5689782379"
 dependencies = [
 "gio-sys",
 "glib-sys",
@@ -783,9 +783,9 @@ dependencies = [

 [[package]]
 name = "gdk4"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b7d7237c1487ed4b300aac7744efcbf1319e12d60d7afcd6f505414bd5b5dea"
+checksum = "db265c9dd42d6a371e09e52deab3a84808427198b86ac792d75fd35c07990a07"
 dependencies = [
 "cairo-rs",
 "gdk-pixbuf",
@@ -798,9 +798,9 @@ dependencies = [

 [[package]]
 name = "gdk4-sys"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a67576c8ec012156d7f680e201a807b4432a77babb3157e0555e990ab6bcd878"
+checksum = "c9418fb4e8a67074919fe7604429c45aa74eb9df82e7ca529767c6d4e9dc66dd"
 dependencies = [
 "cairo-sys-rs",
 "gdk-pixbuf-sys",
@@ -842,9 +842,9 @@ checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"

 [[package]]
 name = "gio"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "398e3da68749fdc32783cbf7521ec3f65c9cf946db8c7774f8460af49e52c6e2"
+checksum = "4c49f117d373ffcc98a35d114db5478bc223341cff53e39a5d6feced9e2ddffe"
 dependencies = [
 "futures-channel",
 "futures-core",
@@ -860,9 +860,9 @@ dependencies = [

 [[package]]
 name = "gio-sys"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4feb96b31c32730ea3e1e89aecd2e4e37ecb1c473ad8f685e3430a159419f63"
+checksum = "2cd743ba4714d671ad6b6234e8ab2a13b42304d0e13ab7eba1dcdd78a7d6d4ef"
 dependencies = [
 "glib-sys",
 "gobject-sys",
@@ -873,9 +873,9 @@ dependencies = [

 [[package]]
 name = "glib"
-version = "0.20.0"
+version = "0.19.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fee90a615ce05be7a32932cfb8adf2c4bbb4700e80d37713c981fb24c0c56238"
+checksum = "39650279f135469465018daae0ba53357942a5212137515777d5fdca74984a44"
 dependencies = [
 "bitflags 2.6.0",
 "futures-channel",
@@ -895,18 +895,18 @@ dependencies = [

 [[package]]
 name = "glib-build-tools"
-version = "0.20.0"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7029c2651d9b5d5a3eea93ec8a1995665c6d3a69ce9bf6042ad9064d134736d8"
+checksum = "108f374fff60efd14b0d70d8916e7213aed18d7dd071ba3e9334ed2dac1dc86a"
 dependencies = [
 "gio",
 ]

 [[package]]
 name = "glib-macros"
-version = "0.20.0"
+version = "0.19.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4da558d8177c0c8c54368818b508a4244e1286fce2858cef4e547023f0cfa5ef"
+checksum = "4429b0277a14ae9751350ad9b658b1be0abb5b54faa5bcdf6e74a3372582fad7"
 dependencies = [
 "heck 0.5.0",
 "proc-macro-crate",
@@ -917,9 +917,9 @@ dependencies = [

 [[package]]
 name = "glib-sys"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4958c26e5a01c9af00dea669a97369eccbec29a8e6d125c24ea2d85ee7467b60"
+checksum = "5c2dc18d3a82b0006d470b13304fbbb3e0a9bd4884cf985a60a7ed733ac2c4a5"
 dependencies = [
 "libc",
 "system-deps",
@@ -927,9 +927,9 @@ dependencies = [

 [[package]]
 name = "gobject-sys"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6908864f5ffff15b56df7e90346863904f49b949337ed0456b9287af61903b8"
+checksum = "2e697e252d6e0416fd1d9e169bda51c0f1c926026c39ca21fbe8b1bb5c3b8b9e"
 dependencies = [
 "glib-sys",
 "libc",
@@ -938,9 +938,9 @@ dependencies = [

 [[package]]
 name = "graphene-rs"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "630e940ad5824f90221d6579043a9cd1f8bec86b4a17faaf7827d58eb16e8c1f"
+checksum = "f5fb86031d24d9ec0a2a15978fc7a65d545a2549642cf1eb7c3dda358da42bcf"
 dependencies = [
 "glib",
 "graphene-sys",
@@ -949,9 +949,9 @@ dependencies = [

 [[package]]
 name = "graphene-sys"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fb8fade7b754982f47ebbed241fd2680816fdd4598321784da10b9e1168836a"
+checksum = "2f530e0944bccba4b55065e9c69f4975ad691609191ebac16e13ab8e1f27af05"
 dependencies = [
 "glib-sys",
 "libc",
@@ -961,9 +961,9 @@ dependencies = [

 [[package]]
 name = "gsk4"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3cf2091e1af185b347b3450817d93dea6fe435df7abd4c2cd7fb5bcb4cfda8"
+checksum = "7563884bf6939f4468e5d94654945bdd9afcaf8c3ba4c5dd17b5342b747221be"
 dependencies = [
 "cairo-rs",
 "gdk4",
@@ -976,9 +976,9 @@ dependencies = [

 [[package]]
 name = "gsk4-sys"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6aa69614a26d8760c186c3690f1b0fbb917572ca23ef83137445770ceddf8cde"
+checksum = "23024bf2636c38bbd1f822f58acc9d1c25b28da896ff0f291a1a232d4272b3dc"
 dependencies = [
 "cairo-sys-rs",
 "gdk4-sys",
@@ -992,9 +992,9 @@ dependencies = [

 [[package]]
 name = "gtk4"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaffc6c743c9160514cc9b67eace364e5dc5798369fa809cdb04e035c21c5c5d"
+checksum = "b04e11319b08af11358ab543105a9e49b0c491faca35e2b8e7e36bfba8b671ab"
 dependencies = [
 "cairo-rs",
 "field-offset",
@@ -1013,9 +1013,9 @@ dependencies = [

 [[package]]
 name = "gtk4-macros"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "188211f546ce5801f6d0245c37b6249143a2cb4fa040e54829ca1e76796e9f09"
+checksum = "ec655a7ef88d8ce9592899deb8b2d0fa50bab1e6dd69182deb764e643c522408"
 dependencies = [
 "proc-macro-crate",
 "proc-macro2",
@@ -1025,9 +1025,9 @@ dependencies = [

 [[package]]
 name = "gtk4-sys"
-version = "0.9.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1114a207af8ada02cf4658a76692f4190f06f093380d5be07e3ca8b43aa7c666"
+checksum = "8c8aa86b7f85ea71d66ea88c1d4bae1cfacf51ca4856274565133838d77e57b5"
 dependencies = [
 "cairo-sys-rs",
 "gdk-pixbuf-sys",
@@ -1192,19 +1192,14 @@ dependencies = [

 [[package]]
 name = "input-capture"
-version = "0.2.0"
+version = "0.1.0"
 dependencies = [
+ "anyhow",
 "ashpd",
- "async-trait",
- "bitflags 2.6.0",
- "core-foundation",
- "core-foundation-sys",
 "core-graphics",
 "futures",
 "futures-core",
 "input-event",
- "keycode",
- "libc",
 "log",
 "memmap",
 "once_cell",
@@ -1212,21 +1207,20 @@ dependencies = [
 "tempfile",
 "thiserror",
 "tokio",
- "tokio-util",
 "wayland-client",
 "wayland-protocols",
 "wayland-protocols-wlr",
- "windows 0.58.0",
+ "windows 0.57.0",
 "x11",
 ]

 [[package]]
 name = "input-emulation"
-version = "0.2.1"
+version = "0.1.0"
 dependencies = [
+ "anyhow",
 "ashpd",
 "async-trait",
- "bitflags 2.6.0",
 "core-graphics",
 "futures",
 "input-event",
@@ -1240,20 +1234,19 @@ dependencies = [
 "wayland-protocols",
 "wayland-protocols-misc",
 "wayland-protocols-wlr",
- "windows 0.58.0",
+ "windows 0.57.0",
 "x11",
 ]

 [[package]]
 name = "input-event"
-version = "0.2.1"
+version = "0.1.0"
 dependencies = [
+ "anyhow",
 "futures-core",
 "log",
 "num_enum",
- "reis",
 "serde",
- "thiserror",
 ]

 [[package]]
@@ -1312,82 +1305,39 @@ dependencies = [

 [[package]]
 name = "lan-mouse"
-version = "0.9.1"
+version = "0.8.0"
 dependencies = [
+ "anyhow",
+ "async-channel",
 "clap",
+ "endi",
 "env_logger",
 "futures",
+ "glib-build-tools",
+ "gtk4",
 "hickory-resolver",
+ "hostname 0.4.0",
 "input-capture",
 "input-emulation",
 "input-event",
- "lan-mouse-cli",
- "lan-mouse-gtk",
- "lan-mouse-ipc",
- "lan-mouse-proto",
+ "libadwaita",
 "libc",
- "local-channel",
 "log",
 "serde",
 "serde_json",
 "slab",
 "thiserror",
 "tokio",
- "tokio-util",
 "toml",
 ]

-[[package]]
-name = "lan-mouse-cli"
-version = "0.1.0"
-dependencies = [
- "futures",
- "lan-mouse-ipc",
- "tokio",
-]
-
-[[package]]
-name = "lan-mouse-gtk"
-version = "0.1.0"
-dependencies = [
- "async-channel",
- "glib-build-tools",
- "gtk4",
- "hostname 0.4.0",
- "lan-mouse-ipc",
- "libadwaita",
- "log",
-]
-
-[[package]]
-name = "lan-mouse-ipc"
-version = "0.1.0"
-dependencies = [
- "futures",
- "log",
- "serde",
- "serde_json",
- "thiserror",
- "tokio",
- "tokio-stream",
-]
-
-[[package]]
-name = "lan-mouse-proto"
-version = "0.1.0"
-dependencies = [
- "input-event",
- "num_enum",
- "paste",
- "thiserror",
-]
-
 [[package]]
 name = "libadwaita"
-version = "0.7.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ff9c222b5c783729de45185f07b2fec2d43a7f9c63961e777d3667e20443878"
+checksum = "91b4990248b9e1ec5e72094a2ccaea70ec3809f88f6fd52192f2af306b87c5d9"
 dependencies = [
+ "gdk-pixbuf",
 "gdk4",
 "gio",
 "glib",
@@ -1399,9 +1349,9 @@ dependencies = [

 [[package]]
 name = "libadwaita-sys"
-version = "0.7.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c44d8bdbad31d6639e1f20cc9c1424f1a8e02d751fc28d44659bf743fb9eca6"
+checksum = "23a748e4e92be1265cd9e93d569c0b5dfc7814107985aa6743d670ab281ea1a8"
 dependencies = [
 "gdk4-sys",
 "gio-sys",
@@ -1426,7 +1376,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e310b3a6b5907f99202fcdb4960ff45b93735d7c7d96b760fcff8db2dc0e103d"
 dependencies = [
 "cfg-if",
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]

 [[package]]
@@ -1441,23 +1391,6 @@ version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"

-[[package]]
-name = "local-channel"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6cbc85e69b8df4b8bb8b89ec634e7189099cea8927a276b7384ce5488e53ec8"
-dependencies = [
- "futures-core",
- "futures-sink",
- "local-waker",
-]
-
-[[package]]
-name = "local-waker"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d873d7c67ce09b42110d801813efbc9364414e356be9935700d368351657487"
-
 [[package]]
 name = "lock_api"
 version = "0.4.12"
@@ -1611,9 +1544,9 @@ dependencies = [

 [[package]]
 name = "pango"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54768854025df6903061d0084fd9702a253ddfd60db7d9b751d43b76689a7f0a"
+checksum = "3f0d328648058085cfd6897c9ae4272884098a926f3a833cd50c8c73e6eccecd"
 dependencies = [
 "gio",
 "glib",
@@ -1623,9 +1556,9 @@ dependencies = [

 [[package]]
 name = "pango-sys"
-version = "0.20.0"
+version = "0.19.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b07cc57d10cee4ec661f718a6902cee18c2f4cfae08e87e5a390525946913390"
+checksum = "ff03da4fa086c0b244d4a4587d3e20622a3ecdb21daea9edf66597224c634ba0"
 dependencies = [
 "glib-sys",
 "gobject-sys",
@@ -1659,15 +1592,9 @@ dependencies = [
 "libc",
 "redox_syscall",
 "smallvec",
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]

-[[package]]
-name = "paste"
-version = "1.0.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
-
 [[package]]
 name = "percent-encoding"
 version = "2.3.1"
@@ -1750,9 +1677,9 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"

 [[package]]
 name = "quick-xml"
-version = "0.34.0"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f24d770aeca0eacb81ac29dfbc55ebcc09312fdd1f8bbecdc7e4a84e000e3b4"
+checksum = "1004a344b30a54e2ee58d66a71b32d2db2feb0a31f9a2d302bf0536f15de2a33"
 dependencies = [
 "memchr",
 ]
@@ -1798,9 +1725,9 @@ dependencies = [

 [[package]]
 name = "redox_syscall"
-version = "0.5.3"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4"
+checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
 dependencies = [
 "bitflags 2.6.0",
 ]
@@ -1909,18 +1836,18 @@ checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"

 [[package]]
 name = "serde"
-version = "1.0.204"
+version = "1.0.203"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
+checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
 dependencies = [
 "serde_derive",
 ]

 [[package]]
 name = "serde_derive"
-version = "1.0.204"
+version = "1.0.203"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
+checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2017,9 +1944,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"

 [[package]]
 name = "syn"
-version = "2.0.71"
+version = "2.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b146dcf730474b4bcd16c311627b31ede9ab149045db4d6088b3becaea046462"
+checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2028,9 +1955,9 @@ dependencies = [

 [[package]]
 name = "system-deps"
-version = "7.0.1"
+version = "6.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c81f13d9a334a6c242465140bd262fae382b752ff2011c4f7419919a9c97922"
+checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
 dependencies = [
 "cfg-expr",
 "heck 0.5.0",
@@ -2041,9 +1968,9 @@ dependencies = [

 [[package]]
 name = "target-lexicon"
-version = "0.12.15"
+version = "0.12.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4873307b7c257eddcb50c9bedf158eb669578359fb28428bef438fec8e6ba7c2"
+checksum = "e1fc403891a21bcfb7c37834ba66a547a8f402146eba7265b5a6d88059c9ff2f"

 [[package]]
 name = "tempfile"
@@ -2059,18 +1986,18 @@ dependencies = [

 [[package]]
 name = "thiserror"
-version = "1.0.63"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724"
+checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
 dependencies = [
 "thiserror-impl",
 ]

 [[package]]
 name = "thiserror-impl"
-version = "1.0.63"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
+checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2079,9 +2006,9 @@ dependencies = [

 [[package]]
 name = "tinyvec"
-version = "1.8.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938"
+checksum = "c55115c6fbe2d2bef26eb09ad74bde02d8255476fc0c7b515ef09fbb35742d82"
 dependencies = [
 "tinyvec_macros",
 ]
@@ -2094,9 +2021,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"

 [[package]]
 name = "tokio"
-version = "1.38.1"
+version = "1.38.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb2caba9f80616f438e09748d5acda951967e1ea58508ef53d9c6402485a46df"
+checksum = "ba4f4a02a7a80d6f274636f0aa95c7e383b912d41fe721a31f29e29698585a4a"
 dependencies = [
 "backtrace",
 "bytes",
@@ -2122,40 +2049,16 @@ dependencies = [
 "syn",
 ]

-[[package]]
-name = "tokio-stream"
-version = "0.1.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af"
-dependencies = [
- "futures-core",
- "pin-project-lite",
- "tokio",
-]
-
-[[package]]
-name = "tokio-util"
-version = "0.7.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1"
-dependencies = [
- "bytes",
- "futures-core",
- "futures-sink",
- "pin-project-lite",
- "tokio",
-]
-
 [[package]]
 name = "toml"
-version = "0.8.15"
+version = "0.8.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac2caab0bf757388c6c0ae23b3293fdb463fee59434529014f85e3263b995c28"
+checksum = "6f49eb2ab21d2f26bd6db7bf383edc527a7ebaee412d17af4d40fdccd442f335"
 dependencies = [
 "serde",
 "serde_spanned",
 "toml_datetime",
- "toml_edit 0.22.16",
+ "toml_edit 0.22.14",
 ]

 [[package]]
@@ -2180,9 +2083,9 @@ dependencies = [

 [[package]]
 name = "toml_edit"
-version = "0.22.16"
+version = "0.22.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "278f3d518e152219c994ce877758516bca5e118eaed6996192a774fb9fbf0788"
+checksum = "f21c7aaf97f1bd9ca9d4f9e73b0a6c74bd5afef56f2bc931943a6e1c37e04e38"
 dependencies = [
 "indexmap",
 "serde",
@@ -2304,9 +2207,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

 [[package]]
 name = "wayland-backend"
-version = "0.3.6"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f90e11ce2ca99c97b940ee83edbae9da2d56a08f9ea8158550fd77fa31722993"
+checksum = "34e9e6b6d4a2bb4e7e69433e0b35c7923b95d4dc8503a84d25ec917a4bbfdf07"
 dependencies = [
 "cc",
 "downcast-rs",
@@ -2318,9 +2221,9 @@ dependencies = [

 [[package]]
 name = "wayland-client"
-version = "0.31.5"
+version = "0.31.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e321577a0a165911bdcfb39cf029302479d7527b517ee58ab0f6ad09edf0943"
+checksum = "1e63801c85358a431f986cffa74ba9599ff571fc5774ac113ed3b490c19a1133"
 dependencies = [
 "bitflags 2.6.0",
 "rustix",
@@ -2330,9 +2233,9 @@ dependencies = [

 [[package]]
 name = "wayland-protocols"
-version = "0.32.3"
+version = "0.32.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62989625a776e827cc0f15d41444a3cea5205b963c3a25be48ae1b52d6b4daaa"
+checksum = "83d0f1056570486e26a3773ec633885124d79ae03827de05ba6c85f79904026c"
 dependencies = [
 "bitflags 2.6.0",
 "wayland-backend",
@@ -2342,9 +2245,9 @@ dependencies = [

 [[package]]
 name = "wayland-protocols-misc"
-version = "0.3.3"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfe44d48a0e51909c89da297f6b43bb814b881c78b69e254a4558a5fa8752887"
+checksum = "e76311e1866c955afbbc46ae97e57542acda1dc9b0298358263a8550b5247331"
 dependencies = [
 "bitflags 2.6.0",
 "wayland-backend",
@@ -2355,9 +2258,9 @@ dependencies = [

 [[package]]
 name = "wayland-protocols-wlr"
-version = "0.3.3"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd993de54a40a40fbe5601d9f1fbcaef0aebcc5fda447d7dc8f6dcbaae4f8953"
+checksum = "a7dab47671043d9f5397035975fe1cac639e5bca5cc0b3c32d09f01612e34d24"
 dependencies = [
 "bitflags 2.6.0",
 "wayland-backend",
@@ -2368,9 +2271,9 @@ dependencies = [

 [[package]]
 name = "wayland-scanner"
-version = "0.31.4"
+version = "0.31.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7b56f89937f1cf2ee1f1259cf2936a17a1f45d8f0aa1019fae6d470d304cfa6"
+checksum = "67da50b9f80159dec0ea4c11c13e24ef9e7574bd6ce24b01860a175010cea565"
 dependencies = [
 "proc-macro2",
 "quick-xml",
@@ -2379,9 +2282,9 @@ dependencies = [

 [[package]]
 name = "wayland-sys"
-version = "0.31.4"
+version = "0.31.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43676fe2daf68754ecf1d72026e4e6c15483198b5d24e888b74d3f22f887a148"
+checksum = "105b1842da6554f91526c14a2a2172897b7f745a805d62af4ce698706be79c12"
 dependencies = [
 "dlib",
 "log",
@@ -2423,17 +2326,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
 dependencies = [
 "windows-core 0.52.0",
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]

 [[package]]
 name = "windows"
-version = "0.58.0"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
+checksum = "12342cb4d8e3b046f3d80effd474a7a02447231330ef77d71daa6fbc40681143"
 dependencies = [
- "windows-core 0.58.0",
- "windows-targets 0.52.6",
+ "windows-core 0.57.0",
+ "windows-targets 0.52.5",
 ]

 [[package]]
@@ -2442,27 +2345,26 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]

 [[package]]
 name = "windows-core"
-version = "0.58.0"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
+checksum = "d2ed2439a290666cd67ecce2b0ffaad89c2a56b976b736e6ece670297897832d"
 dependencies = [
 "windows-implement",
 "windows-interface",
 "windows-result",
- "windows-strings",
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]

 [[package]]
 name = "windows-implement"
-version = "0.58.0"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
+checksum = "9107ddc059d5b6fbfbffdfa7a7fe3e22a226def0b2608f72e9d552763d3e1ad7"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2471,9 +2373,9 @@ dependencies = [

 [[package]]
 name = "windows-interface"
-version = "0.58.0"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
+checksum = "29bee4b38ea3cde66011baa44dba677c432a78593e202392d1e9070cf2a7fca7"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2482,21 +2384,11 @@ dependencies = [

 [[package]]
 name = "windows-result"
-version = "0.2.0"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
+checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
 dependencies = [
- "windows-targets 0.52.6",
-]
-
-[[package]]
-name = "windows-strings"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
-dependencies = [
- "windows-result",
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]

 [[package]]
@@ -2514,7 +2406,7 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets 0.52.6",
+ "windows-targets 0.52.5",
 ]

 [[package]]
@@ -2534,18 +2426,18 @@ dependencies = [

 [[package]]
 name = "windows-targets"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.6",
- "windows_aarch64_msvc 0.52.6",
- "windows_i686_gnu 0.52.6",
+ "windows_aarch64_gnullvm 0.52.5",
+ "windows_aarch64_msvc 0.52.5",
+ "windows_i686_gnu 0.52.5",
 "windows_i686_gnullvm",
- "windows_i686_msvc 0.52.6",
- "windows_x86_64_gnu 0.52.6",
- "windows_x86_64_gnullvm 0.52.6",
- "windows_x86_64_msvc 0.52.6",
+ "windows_i686_msvc 0.52.5",
+ "windows_x86_64_gnu 0.52.5",
+ "windows_x86_64_gnullvm 0.52.5",
+ "windows_x86_64_msvc 0.52.5",
 ]

 [[package]]
@@ -2556,9 +2448,9 @@ checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"

 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"

 [[package]]
 name = "windows_aarch64_msvc"
@@ -2568,9 +2460,9 @@ checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"

 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"

 [[package]]
 name = "windows_i686_gnu"
@@ -2580,15 +2472,15 @@ checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"

 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"

 [[package]]
 name = "windows_i686_gnullvm"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"

 [[package]]
 name = "windows_i686_msvc"
@@ -2598,9 +2490,9 @@ checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"

 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"

 [[package]]
 name = "windows_x86_64_gnu"
@@ -2610,9 +2502,9 @@ checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"

 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"

 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -2622,9 +2514,9 @@ checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"

 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"

 [[package]]
 name = "windows_x86_64_msvc"
@@ -2634,9 +2526,9 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"

 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.6"
+version = "0.52.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"

 [[package]]
 name = "winnow"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,63 +3,53 @@ members = [
    "input-capture",
    "input-emulation",
    "input-event",
-    "lan-mouse-ipc",
-    "lan-mouse-cli",
-    "lan-mouse-gtk",
-    "lan-mouse-proto",
 ]

 [package]
 name = "lan-mouse"
 description = "Software KVM Switch / mouse & keyboard sharing software for Local Area Networks"
-version = "0.9.1"
+version = "0.8.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
+repository = "https://github.com/ferdinandschober/lan-mouse"

 [profile.release]
 strip = true
 lto = "fat"

 [dependencies]
-input-event = { path = "input-event", version = "0.2.1" }
-input-emulation = { path = "input-emulation", version = "0.2.1", default-features = false }
-input-capture = { path = "input-capture", version = "0.2.0", default-features = false }
-lan-mouse-cli = { path = "lan-mouse-cli", version = "0.1.0" }
-lan-mouse-gtk = { path = "lan-mouse-gtk", version = "0.1.0", optional = true }
-lan-mouse-ipc = { path = "lan-mouse-ipc", version = "0.1.0" }
-lan-mouse-proto = { path = "lan-mouse-proto", version = "0.1.0" }
+input-event = { path = "input-event", version = "0.1.0" }
+input-emulation = { path = "input-emulation", version = "0.1.0", default-features = false }
+input-capture = { path = "input-capture", version = "0.1.0", default-features = false }

 hickory-resolver = "0.24.1"
 toml = "0.8"
 serde = { version = "1.0", features = ["derive"] }
+anyhow = "1.0.71"
 log = "0.4.20"
 env_logger = "0.11.3"
 serde_json = "1.0.107"
-tokio = { version = "1.32.0", features = [
-    "io-util",
-    "io-std",
-    "macros",
-    "net",
-    "process",
-    "rt",
-    "sync",
-    "signal",
-] }
+tokio = {version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
 futures = "0.3.28"
-clap = { version = "4.4.11", features = ["derive"] }
+clap = { version="4.4.11", features = ["derive"] }
+gtk = { package = "gtk4", version = "0.8.1", features = ["v4_2"], optional = true }
+adw = { package = "libadwaita", version = "0.6.0", features = ["v1_1"], optional = true }
+async-channel = { version = "2.1.1", optional = true }
+hostname = "0.4.0"
 slab = "0.4.9"
+endi = "1.1.0"
 thiserror = "1.0.61"
-tokio-util = "0.7.11"
-local-channel = "0.1.5"

 [target.'cfg(unix)'.dependencies]
 libc = "0.2.148"

+[build-dependencies]
+glib-build-tools = { version = "0.19.0", optional = true }
+
 [features]
-default = ["wayland", "x11", "xdg_desktop_portal", "libei", "gtk"]
-wayland = ["input-capture/wayland", "input-emulation/wayland"]
-x11 = ["input-capture/x11", "input-emulation/x11"]
-xdg_desktop_portal = ["input-emulation/xdg_desktop_portal"]
-libei = ["input-event/libei", "input-capture/libei", "input-emulation/libei"]
-gtk = ["dep:lan-mouse-gtk"]
+default = [ "wayland", "x11", "xdg_desktop_portal", "libei", "gtk" ]
+wayland = [ "input-capture/wayland", "input-emulation/wayland" ]
+x11 = [ "input-capture/x11", "input-emulation/x11" ]
+xdg_desktop_portal = [ "input-emulation/xdg_desktop_portal" ]
+libei = [ "input-capture/libei", "input-emulation/libei" ]
+gtk = ["dep:gtk", "dep:adw", "dep:async-channel", "dep:glib-build-tools"]
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@ Focus lies on performance and a clean, manageable implementation that can easily

 ***blazingly fast™*** because it's written in rust.

-For an alternative (with slightly different goals) you may check out [Synergy 1 Community Edition](https://github.com/symless/synergy) or [Input Leap](https://github.com/input-leap) (Synergy fork).
+For an alternative (with slightly different goals) you may check out [Input Leap](https://github.com/input-leap).


 > [!WARNING]
@@ -57,10 +57,6 @@ input capture (to send events *to* other clients) on different operating systems
 > If you are using [Wayfire](https://github.com/WayfireWM/wayfire), make sure to use a recent version (must be newer than October 23rd) and **add `shortcuts-inhibit` to the list of plugins in your wayfire config!**
 > Otherwise input capture will not work.

-> [!Important]
-> The mouse cursor will be invisible when sending input to a Windows system if
-> there is no real mouse connected to the machine.
-
 ## Installation
 ### Install via cargo
 ```sh
@@ -94,13 +90,6 @@ paru -S lan-mouse-bin
 - nixpkgs: [search.nixos.org](https://search.nixos.org/packages?channel=unstable&show=lan-mouse&from=0&size=50&sort=relevance&type=packages&query=lan-mouse)
 - flake: [README.md](./nix/README.md)

-### Building from source with Nix
-In the root of the project to build Lan Mouse, run
-```sh
-nix-build
-```
-
-You can find the executable in `result/bin/lan-mouse` .

 ### Manual Installation

@@ -123,7 +112,7 @@ sudo cp target/release/lan-mouse /usr/local/bin/

 # install app icon
 sudo mkdir -p /usr/local/share/icons/hicolor/scalable/apps
-sudo cp lan-mouse-gtk/resources/de.feschber.LanMouse.svg /usr/local/share/icons/hicolor/scalable/apps
+sudo cp resources/de.feschber.LanMouse.svg /usr/local/share/icons/hicolor/scalable/apps

 # update icon cache
 gtk-update-icon-cache /usr/local/share/icons/hicolor/
--- a/build.rs
+++ b/build.rs
@@ -1,15 +1,9 @@
-use std::process::Command;
-
 fn main() {
-    // commit hash
-    let git_describe = Command::new("git")
-        .arg("describe")
-        .arg("--always")
-        .arg("--dirty")
-        .arg("--tags")
-        .output()
-        .unwrap();
-
-    let git_describe = String::from_utf8(git_describe.stdout).unwrap();
-    println!("cargo::rustc-env=GIT_DESCRIBE={git_describe}");
+    // composite_templates
+    #[cfg(feature = "gtk")]
+    glib_build_tools::compile_resources(
+        &["resources"],
+        "resources/resources.gresource.xml",
+        "lan-mouse.gresource",
+    );
 }
--- a/default.nix
+++ b/default.nix
@@ -1,3 +0,0 @@
-{ pkgs ? import <nixpkgs> { }
-}:
-pkgs.callPackage nix/default.nix { }
--- a/flake.lock
+++ b/flake.lock
@@ -1,12 +1,30 @@
 {
  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1705309234,
+        "narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1728018373,
-        "narHash": "sha256-NOiTvBbRLIOe5F6RbHaAh6++BNjsb149fGZd1T4+KBg=",
+        "lastModified": 1716293225,
+        "narHash": "sha256-pU9ViBVE3XYb70xZx+jK6SEVphvt7xMTbm6yDIF4xPs=",
        "owner": "nixos",
        "repo": "nixpkgs",
-        "rev": "bc947f541ae55e999ffdb4013441347d83b00feb",
+        "rev": "3eaeaeb6b1e08a016380c279f8846e0bd8808916",
        "type": "github"
      },
      "original": {
@@ -24,16 +42,17 @@
    },
    "rust-overlay": {
      "inputs": {
+        "flake-utils": "flake-utils",
        "nixpkgs": [
          "nixpkgs"
        ]
      },
      "locked": {
-        "lastModified": 1728181869,
-        "narHash": "sha256-sQXHXsjIcGEoIHkB+RO6BZdrPfB+43V1TEpyoWRI3ww=",
+        "lastModified": 1716257780,
+        "narHash": "sha256-R+NjvJzKEkTVCmdrKRfPE4liX/KMGVqGUwwS5H8ET8A=",
        "owner": "oxalica",
        "repo": "rust-overlay",
-        "rev": "cd46aa3906c14790ef5cbe278d9e54f2c38f95c0",
+        "rev": "4e5e3d2c5c9b2721bd266f9e43c14e96811b89d2",
        "type": "github"
      },
      "original": {
@@ -41,6 +60,21 @@
        "repo": "rust-overlay",
        "type": "github"
      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
    }
  },
  "root": "root",
--- a/flake.nix
+++ b/flake.nix
@@ -16,7 +16,6 @@
    inherit (nixpkgs) lib;
    genSystems = lib.genAttrs [
      "aarch64-darwin"
-      "aarch64-linux"
      "x86_64-darwin"
      "x86_64-linux"
    ];
@@ -51,13 +50,10 @@
          xorg.libX11
          gtk4
          libadwaita
-          librsvg
          xorg.libXtst
-        ] ++ lib.optionals stdenv.isDarwin
-        (with darwin.apple_sdk_11_0.frameworks; [
-          CoreGraphics
-          ApplicationServices
-        ]);
+        ] ++ lib.optionals stdenv.isDarwin [
+          darwin.apple_sdk_11_0.frameworks.CoreGraphics
+        ];

        RUST_SRC_PATH = "${rust}/lib/rustlib/src/rust/library";
      };
--- a/input-capture/Cargo.toml
+++ b/input-capture/Cargo.toml
@@ -1,60 +1,37 @@
 [package]
 name = "input-capture"
 description = "cross-platform input-capture library used by lan-mouse"
-version = "0.2.0"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
+repository = "https://github.com/ferdinandschober/lan-mouse"

 [dependencies]
+anyhow = "1.0.86"
 futures = "0.3.28"
 futures-core = "0.3.30"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.2.1" }
+input-event = { path = "../input-event", version = "0.1.0" }
 memmap = "0.7"
 tempfile = "3.8"
 thiserror = "1.0.61"
-tokio = { version = "1.32.0", features = [
-    "io-util",
-    "io-std",
-    "macros",
-    "net",
-    "process",
-    "rt",
-    "sync",
-    "signal",
-] }
+tokio = { version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
 once_cell = "1.19.0"
-async-trait = "0.1.81"
-tokio-util = "0.7.11"


 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-wayland-client = { version = "0.31.1", optional = true }
-wayland-protocols = { version = "0.32.1", features = [
-    "client",
-    "staging",
-    "unstable",
-], optional = true }
-wayland-protocols-wlr = { version = "0.3.1", features = [
-    "client",
-], optional = true }
+wayland-client = { version="0.31.1", optional = true }
+wayland-protocols = { version="0.32.1", features=["client", "staging", "unstable"], optional = true }
+wayland-protocols-wlr = { version="0.3.1", features=["client"], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.9", default-features = false, features = [
-    "tokio",
-], optional = true }
-reis = { version = "0.2", features = ["tokio"], optional = true }
+ashpd = { version = "0.8", default-features = false, features = ["tokio"], optional = true }
+reis = { version = "0.2", features = [ "tokio" ], optional = true }

 [target.'cfg(target_os="macos")'.dependencies]
 core-graphics = { version = "0.23", features = ["highsierra"] }
-core-foundation = "0.9.4"
-core-foundation-sys = "0.8.6"
-libc = "0.2.155"
-keycode = "0.4.0"
-bitflags = "2.5.0"

 [target.'cfg(windows)'.dependencies]
-windows = { version = "0.58.0", features = [
+windows = {  version = "0.57.0", features = [
    "Win32_System_LibraryLoader",
    "Win32_System_Threading",
    "Win32_Foundation",
@@ -66,10 +43,6 @@ windows = { version = "0.58.0", features = [

 [features]
 default = ["wayland", "x11", "libei"]
-wayland = [
-    "dep:wayland-client",
-    "dep:wayland-protocols",
-    "dep:wayland-protocols-wlr",
-]
+wayland = ["dep:wayland-client", "dep:wayland-protocols", "dep:wayland-protocols-wlr" ]
 x11 = ["dep:x11"]
 libei = ["dep:reis", "dep:ashpd"]
--- a/input-capture/src/dummy.rs
+++ b/input-capture/src/dummy.rs
@@ -1,28 +1,18 @@
-use std::f64::consts::PI;
+use std::io;
 use std::pin::Pin;
-use std::task::{ready, Context, Poll};
-use std::time::Duration;
+use std::task::{Context, Poll};

-use async_trait::async_trait;
 use futures_core::Stream;
-use input_event::PointerEvent;
-use tokio::time::{self, Instant, Interval};

-use super::{Capture, CaptureError, CaptureEvent, Position};
+use input_event::Event;

-pub struct DummyInputCapture {
-    start: Option<Instant>,
-    interval: Interval,
-    offset: (i32, i32),
-}
+use super::{CaptureHandle, InputCapture, Position};
+
+pub struct DummyInputCapture {}

 impl DummyInputCapture {
    pub fn new() -> Self {
-        Self {
-            start: None,
-            interval: time::interval(Duration::from_millis(1)),
-            offset: (0, 0),
-        }
+        Self {}
    }
 }

@@ -32,55 +22,24 @@ impl Default for DummyInputCapture {
    }
 }

-#[async_trait]
-impl Capture for DummyInputCapture {
-    async fn create(&mut self, _pos: Position) -> Result<(), CaptureError> {
+impl InputCapture for DummyInputCapture {
+    fn create(&mut self, _handle: CaptureHandle, _pos: Position) -> io::Result<()> {
        Ok(())
    }

-    async fn destroy(&mut self, _pos: Position) -> Result<(), CaptureError> {
+    fn destroy(&mut self, _handle: CaptureHandle) -> io::Result<()> {
        Ok(())
    }

-    async fn release(&mut self) -> Result<(), CaptureError> {
-        Ok(())
-    }
-
-    async fn terminate(&mut self) -> Result<(), CaptureError> {
+    fn release(&mut self) -> io::Result<()> {
        Ok(())
    }
 }

-const FREQUENCY_HZ: f64 = 1.0;
-const RADIUS: f64 = 100.0;
-
 impl Stream for DummyInputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+    type Item = io::Result<(CaptureHandle, Event)>;

-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let current = ready!(self.interval.poll_tick(cx));
-        let event = match self.start {
-            None => {
-                self.start.replace(current);
-                CaptureEvent::Begin
-            }
-            Some(start) => {
-                let elapsed = start.elapsed();
-                let elapsed_sec_f64 = elapsed.as_secs_f64();
-                let second_fraction = elapsed_sec_f64 - elapsed_sec_f64 as u64 as f64;
-                let radians = second_fraction * 2. * PI * FREQUENCY_HZ;
-                let offset = (radians.cos() * RADIUS * 2., (radians * 2.).sin() * RADIUS);
-                let offset = (offset.0 as i32, offset.1 as i32);
-                let relative_motion = (offset.0 - self.offset.0, offset.1 - self.offset.1);
-                self.offset = offset;
-                let (dx, dy) = (relative_motion.0 as f64, relative_motion.1 as f64);
-                CaptureEvent::Input(input_event::Event::Pointer(PointerEvent::Motion {
-                    time: 0,
-                    dx,
-                    dy,
-                }))
-            }
-        };
-        Poll::Ready(Some(Ok((Position::Left, event))))
+    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        Poll::Pending
    }
 }
--- a/input-capture/src/error.rs
+++ b/input-capture/src/error.rs
@@ -1,13 +1,6 @@
+use std::fmt::Display;
 use thiserror::Error;

-#[derive(Debug, Error)]
-pub enum InputCaptureError {
-    #[error("error creating input-capture: `{0}`")]
-    Create(#[from] CaptureCreationError),
-    #[error("error while capturing input: `{0}`")]
-    Capture(#[from] CaptureError),
-}
-
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 use std::io;
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
@@ -17,118 +10,65 @@ use wayland_client::{
    ConnectError, DispatchError,
 };

-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-use ashpd::desktop::ResponseError;
-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-use reis::tokio::{EiConvertEventStreamError, HandshakeError};
-
-#[cfg(target_os = "macos")]
-use core_graphics::base::CGError;
-
-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-#[derive(Debug, Error)]
-#[error("error in libei stream: {inner:?}")]
-pub struct ReisConvertEventStreamError {
-    inner: EiConvertEventStreamError,
-}
-
-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-impl From<EiConvertEventStreamError> for ReisConvertEventStreamError {
-    fn from(e: EiConvertEventStreamError) -> Self {
-        Self { inner: e }
-    }
-}
-
-#[derive(Debug, Error)]
-pub enum CaptureError {
-    #[error("activation stream closed unexpectedly")]
-    ActivationClosed,
-    #[error("libei stream was closed")]
-    EndOfStream,
-    #[error("io error: `{0}`")]
-    Io(#[from] std::io::Error),
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    #[error("error in libei stream: `{0}`")]
-    Reis(#[from] ReisConvertEventStreamError),
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    #[error("libei handshake failed: `{0}`")]
-    Handshake(#[from] HandshakeError),
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    #[error(transparent)]
-    Portal(#[from] ashpd::Error),
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    #[error("libei disconnected - reason: `{0}`")]
-    Disconnected(String),
-    #[cfg(target_os = "macos")]
-    #[error("failed to warp mouse cursor: `{0}`")]
-    WarpCursor(CGError),
-    #[cfg(target_os = "macos")]
-    #[error("reset_mouse_position called without a connected client")]
-    ResetMouseWithoutClient,
-    #[cfg(target_os = "macos")]
-    #[error("core-graphics error: {0}")]
-    CoreGraphics(CGError),
-    #[cfg(target_os = "macos")]
-    #[error("unable to map key event: {0}")]
-    KeyMapError(i64),
-    #[cfg(target_os = "macos")]
-    #[error("Event tap disabled")]
-    EventTapDisabled,
-}
-
 #[derive(Debug, Error)]
 pub enum CaptureCreationError {
-    #[error("no backend available")]
    NoAvailableBackend,
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    #[error("error creating input-capture-portal backend: `{0}`")]
    Libei(#[from] LibeiCaptureCreationError),
    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-    #[error("error creating layer-shell capture backend: `{0}`")]
    LayerShell(#[from] LayerShellCaptureCreationError),
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-    #[error("error creating x11 capture backend: `{0}`")]
    X11(#[from] X11InputCaptureCreationError),
-    #[cfg(windows)]
-    #[error("error creating windows capture backend")]
-    Windows,
    #[cfg(target_os = "macos")]
-    #[error("error creating macos capture backend: `{0}`")]
-    MacOS(#[from] MacosCaptureCreationError),
+    Macos(#[from] MacOSInputCaptureCreationError),
+    #[cfg(windows)]
+    Windows,
 }

-impl CaptureCreationError {
-    /// request was intentionally denied by the user
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    pub(crate) fn cancelled_by_user(&self) -> bool {
-        matches!(
-            self,
-            CaptureCreationError::Libei(LibeiCaptureCreationError::Ashpd(ashpd::Error::Response(
-                ResponseError::Cancelled
-            )))
-        )
-    }
-    #[cfg(not(all(unix, feature = "libei", not(target_os = "macos"))))]
-    pub(crate) fn cancelled_by_user(&self) -> bool {
-        false
+impl Display for CaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let reason = match self {
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            CaptureCreationError::Libei(reason) => {
+                format!("error creating portal backend: {reason}")
+            }
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            CaptureCreationError::LayerShell(reason) => {
+                format!("error creating layer-shell backend: {reason}")
+            }
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            CaptureCreationError::X11(e) => format!("{e}"),
+            #[cfg(target_os = "macos")]
+            CaptureCreationError::Macos(e) => format!("{e}"),
+            #[cfg(windows)]
+            CaptureCreationError::Windows => String::new(),
+            CaptureCreationError::NoAvailableBackend => "no available backend".to_string(),
+        };
+        write!(f, "could not create input capture: {reason}")
    }
 }

 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum LibeiCaptureCreationError {
-    #[error("xdg-desktop-portal: `{0}`")]
    Ashpd(#[from] ashpd::Error),
 }

+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+impl Display for LibeiCaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LibeiCaptureCreationError::Ashpd(portal_error) => write!(f, "{portal_error}"),
+        }
+    }
+}
+
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
-#[error("{protocol} protocol not supported: {inner}")]
 pub struct WaylandBindError {
    inner: BindError,
    protocol: &'static str,
 }
-
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 impl WaylandBindError {
    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
@@ -136,41 +76,67 @@ impl WaylandBindError {
    }
 }

+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl Display for WaylandBindError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{} protocol not supported: {}",
+            self.protocol, self.inner
+        )
+    }
+}
+
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum LayerShellCaptureCreationError {
-    #[error(transparent)]
    Connect(#[from] ConnectError),
-    #[error(transparent)]
    Global(#[from] GlobalError),
-    #[error(transparent)]
    Wayland(#[from] WaylandError),
-    #[error(transparent)]
    Bind(#[from] WaylandBindError),
-    #[error(transparent)]
    Dispatch(#[from] DispatchError),
-    #[error(transparent)]
    Io(#[from] io::Error),
 }

+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl Display for LayerShellCaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LayerShellCaptureCreationError::Bind(e) => write!(f, "{e}"),
+            LayerShellCaptureCreationError::Connect(e) => {
+                write!(f, "could not connect to wayland compositor: {e}")
+            }
+            LayerShellCaptureCreationError::Global(e) => write!(f, "wayland error: {e}"),
+            LayerShellCaptureCreationError::Wayland(e) => write!(f, "wayland error: {e}"),
+            LayerShellCaptureCreationError::Dispatch(e) => {
+                write!(f, "error dispatching wayland events: {e}")
+            }
+            LayerShellCaptureCreationError::Io(e) => write!(f, "io error: {e}"),
+        }
+    }
+}
+
 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum X11InputCaptureCreationError {
-    #[error("X11 input capture is not yet implemented :(")]
+    NotImplemented,
+}
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+impl Display for X11InputCaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "X11 input capture is not yet implemented :(")
+    }
+}
+#[cfg(target_os = "macos")]
+#[derive(Debug, Error)]
+pub enum MacOSInputCaptureCreationError {
    NotImplemented,
 }

 #[cfg(target_os = "macos")]
-#[derive(Debug, Error)]
-pub enum MacosCaptureCreationError {
-    #[error("event source creation failed!")]
-    EventSourceCreation,
-    #[cfg(target_os = "macos")]
-    #[error("event tap creation failed")]
-    EventTapCreation,
-    #[error("failed to set CG Cursor property")]
-    CGCursorProperty,
-    #[cfg(target_os = "macos")]
-    #[error("failed to get display ids: {0}")]
-    ActiveDisplays(CGError),
+impl Display for MacOSInputCaptureCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "macos input capture is not yet implemented :(")
+    }
 }
--- a/input-capture/src/lib.rs
+++ b/input-capture/src/lib.rs
@@ -1,57 +1,33 @@
-use std::{
-    collections::{HashMap, HashSet, VecDeque},
-    fmt::Display,
-    mem::swap,
-    task::{ready, Poll},
-};
+use std::{fmt::Display, io};

-use async_trait::async_trait;
-use futures::StreamExt;
 use futures_core::Stream;

-use input_event::{scancode, Event, KeyboardEvent};
+use input_event::Event;

-pub use error::{CaptureCreationError, CaptureError, InputCaptureError};
+use self::error::CaptureCreationError;

 pub mod error;

 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-mod libei;
+pub mod libei;

 #[cfg(target_os = "macos")]
-mod macos;
+pub mod macos;

 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-mod wayland;
+pub mod wayland;

 #[cfg(windows)]
-mod windows;
+pub mod windows;

 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-mod x11;
+pub mod x11;

 /// fallback input capture (does not produce events)
-mod dummy;
+pub mod dummy;

 pub type CaptureHandle = u64;

-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum CaptureEvent {
-    /// capture on this capture handle is now active
-    Begin,
-    /// input event coming from capture handle
-    Input(Event),
-}
-
-impl Display for CaptureEvent {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            CaptureEvent::Begin => write!(f, "begin capture"),
-            CaptureEvent::Input(e) => write!(f, "{e}"),
-        }
-    }
-}
-
 #[derive(Debug, Clone, Copy, Eq, Hash, PartialEq)]
 pub enum Position {
    Left,
@@ -116,191 +92,40 @@ impl Display for Backend {
    }
 }

-pub struct InputCapture {
-    /// capture backend
-    capture: Box<dyn Capture>,
-    /// keys pressed by active capture
-    pressed_keys: HashSet<scancode::Linux>,
-    /// map from position to ids
-    position_map: HashMap<Position, Vec<CaptureHandle>>,
-    /// map from id to position
-    id_map: HashMap<CaptureHandle, Position>,
-    /// pending events
-    pending: VecDeque<(CaptureHandle, CaptureEvent)>,
-}
-
-impl InputCapture {
+pub trait InputCapture: Stream<Item = io::Result<(CaptureHandle, Event)>> + Unpin {
    /// create a new client with the given id
-    pub async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
-        if let Some(v) = self.position_map.get_mut(&pos) {
-            v.push(id);
-            Ok(())
-        } else {
-            self.position_map.insert(pos, vec![id]);
-            self.id_map.insert(id, pos);
-            self.capture.create(pos).await
-        }
-    }
+    fn create(&mut self, id: CaptureHandle, pos: Position) -> io::Result<()>;

    /// destroy the client with the given id, if it exists
-    pub async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError> {
-        if let Some(pos) = self.id_map.remove(&id) {
-            let destroy = if let Some(v) = self.position_map.get_mut(&pos) {
-                v.retain(|&i| i != id);
-                // we were the last id registered at this position
-                v.is_empty()
-            } else {
-                // nothing to destroy
-                false
-            };
-            if destroy {
-                self.position_map.remove(&pos);
-                self.capture.destroy(pos).await?;
-            }
-        }
-        Ok(())
-    }
+    fn destroy(&mut self, id: CaptureHandle) -> io::Result<()>;

    /// release mouse
-    pub async fn release(&mut self) -> Result<(), CaptureError> {
-        self.pressed_keys.clear();
-        self.capture.release().await
-    }
-
-    /// destroy the input capture
-    pub async fn terminate(&mut self) -> Result<(), CaptureError> {
-        self.capture.terminate().await
-    }
-
-    /// creates a new [`InputCapture`]
-    pub async fn new(backend: Option<Backend>) -> Result<Self, CaptureCreationError> {
-        let capture = create(backend).await?;
-        Ok(Self {
-            capture,
-            id_map: Default::default(),
-            pending: Default::default(),
-            position_map: Default::default(),
-            pressed_keys: HashSet::new(),
-        })
-    }
-
-    /// check whether the given keys are pressed
-    pub fn keys_pressed(&self, keys: &[scancode::Linux]) -> bool {
-        keys.iter().all(|k| self.pressed_keys.contains(k))
-    }
-
-    fn update_pressed_keys(&mut self, key: u32, state: u8) {
-        if let Ok(scancode) = scancode::Linux::try_from(key) {
-            log::debug!("key: {key}, state: {state}, scancode: {scancode:?}");
-            match state {
-                1 => self.pressed_keys.insert(scancode),
-                _ => self.pressed_keys.remove(&scancode),
-            };
-        }
-    }
+    fn release(&mut self) -> io::Result<()>;
 }

-impl Stream for InputCapture {
-    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
-
-    fn poll_next(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        if let Some(e) = self.pending.pop_front() {
-            return Poll::Ready(Some(Ok(e)));
-        }
-
-        // ready
-        let event = ready!(self.capture.poll_next_unpin(cx));
-
-        // stream closed
-        let event = match event {
-            Some(e) => e,
-            None => return Poll::Ready(None),
-        };
-
-        // error occurred
-        let (pos, event) = match event {
-            Ok(e) => e,
-            Err(e) => return Poll::Ready(Some(Err(e))),
-        };
-
-        // handle key presses
-        if let CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key, state, .. })) = event {
-            self.update_pressed_keys(key, state);
-        }
-
-        let len = self
-            .position_map
-            .get(&pos)
-            .map(|ids| ids.len())
-            .unwrap_or(0);
-
-        match len {
-            0 => Poll::Pending,
-            1 => Poll::Ready(Some(Ok((
-                self.position_map.get(&pos).expect("no id")[0],
-                event,
-            )))),
-            _ => {
-                let mut position_map = HashMap::new();
-                swap(&mut self.position_map, &mut position_map);
-                {
-                    for &id in position_map.get(&pos).expect("position") {
-                        self.pending.push_back((id, event));
-                    }
-                }
-                swap(&mut self.position_map, &mut position_map);
-
-                Poll::Ready(Some(Ok(self.pending.pop_front().expect("event"))))
-            }
-        }
-    }
-}
-
-#[async_trait]
-trait Capture: Stream<Item = Result<(Position, CaptureEvent), CaptureError>> + Unpin {
-    /// create a new client with the given id
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError>;
-
-    /// destroy the client with the given id, if it exists
-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError>;
-
-    /// release mouse
-    async fn release(&mut self) -> Result<(), CaptureError>;
-
-    /// destroy the input capture
-    async fn terminate(&mut self) -> Result<(), CaptureError>;
-}
-
-async fn create_backend(
+pub async fn create_backend(
    backend: Backend,
-) -> Result<
-    Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
-    CaptureCreationError,
-> {
+) -> Result<Box<dyn InputCapture<Item = io::Result<(CaptureHandle, Event)>>>, CaptureCreationError>
+{
    match backend {
        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
        Backend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-        Backend::LayerShell => Ok(Box::new(wayland::LayerShellInputCapture::new()?)),
+        Backend::LayerShell => Ok(Box::new(wayland::WaylandInputCapture::new()?)),
        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
        Backend::X11 => Ok(Box::new(x11::X11InputCapture::new()?)),
        #[cfg(windows)]
        Backend::Windows => Ok(Box::new(windows::WindowsInputCapture::new())),
        #[cfg(target_os = "macos")]
-        Backend::MacOs => Ok(Box::new(macos::MacOSInputCapture::new().await?)),
+        Backend::MacOs => Ok(Box::new(macos::MacOSInputCapture::new()?)),
        Backend::Dummy => Ok(Box::new(dummy::DummyInputCapture::new())),
    }
 }

-async fn create(
+pub async fn create(
    backend: Option<Backend>,
-) -> Result<
-    Box<dyn Capture<Item = Result<(Position, CaptureEvent), CaptureError>>>,
-    CaptureCreationError,
-> {
+) -> Result<Box<dyn InputCapture<Item = io::Result<(CaptureHandle, Event)>>>, CaptureCreationError>
+{
    if let Some(backend) = backend {
        let b = create_backend(backend).await;
        if b.is_ok() {
@@ -320,13 +145,13 @@ async fn create(
        Backend::Windows,
        #[cfg(target_os = "macos")]
        Backend::MacOs,
+        Backend::Dummy,
    ] {
        match create_backend(backend).await {
            Ok(b) => {
                log::info!("using capture backend: {backend}");
                return Ok(b);
            }
-            Err(e) if e.cancelled_by_user() => return Err(e),
            Err(e) => log::warn!("{backend} input capture backend unavailable: {e}"),
        }
    }
--- a/input-capture/src/libei.rs
+++ b/input-capture/src/libei.rs
--- a/input-capture/src/macos.rs
+++ b/input-capture/src/macos.rs
@@ -1,618 +1,35 @@
-use super::{error::MacosCaptureCreationError, Capture, CaptureError, CaptureEvent, Position};
-use async_trait::async_trait;
-use bitflags::bitflags;
-use core_foundation::base::{kCFAllocatorDefault, CFRelease};
-use core_foundation::date::CFTimeInterval;
-use core_foundation::number::{kCFBooleanTrue, CFBooleanRef};
-use core_foundation::runloop::{kCFRunLoopCommonModes, CFRunLoop, CFRunLoopSource};
-use core_foundation::string::{kCFStringEncodingUTF8, CFStringCreateWithCString, CFStringRef};
-use core_graphics::base::{kCGErrorSuccess, CGError};
-use core_graphics::display::{CGDisplay, CGPoint};
-use core_graphics::event::{
-    CGEvent, CGEventFlags, CGEventTap, CGEventTapLocation, CGEventTapOptions, CGEventTapPlacement,
-    CGEventTapProxy, CGEventType, EventField,
-};
-use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
+use crate::{error::MacOSInputCaptureCreationError, CaptureHandle, InputCapture, Position};
 use futures_core::Stream;
-use input_event::{Event, KeyboardEvent, PointerEvent, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT};
-use keycode::{KeyMap, KeyMapping};
-use libc::c_void;
-use once_cell::unsync::Lazy;
-use std::collections::HashSet;
-use std::ffi::{c_char, CString};
-use std::pin::Pin;
-use std::sync::Arc;
-use std::task::{ready, Context, Poll};
-use std::thread::{self};
-use tokio::sync::mpsc::{self, Receiver, Sender};
-use tokio::sync::{oneshot, Mutex};
+use input_event::Event;
+use std::task::{Context, Poll};
+use std::{io, pin::Pin};

-#[derive(Debug, Default)]
-struct Bounds {
-    xmin: f64,
-    xmax: f64,
-    ymin: f64,
-    ymax: f64,
-}
-
-#[derive(Debug)]
-struct InputCaptureState {
-    active_clients: Lazy<HashSet<Position>>,
-    current_pos: Option<Position>,
-    bounds: Bounds,
-}
-
-#[derive(Debug)]
-enum ProducerEvent {
-    Release,
-    Create(Position),
-    Destroy(Position),
-    Grab(Position),
-    EventTapDisabled,
-}
-
-impl InputCaptureState {
-    fn new() -> Result<Self, MacosCaptureCreationError> {
-        let mut res = Self {
-            active_clients: Lazy::new(HashSet::new),
-            current_pos: None,
-            bounds: Bounds::default(),
-        };
-        res.update_bounds()?;
-        Ok(res)
-    }
-
-    fn crossed(&mut self, event: &CGEvent) -> Option<Position> {
-        let location = event.location();
-        let relative_x = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_X);
-        let relative_y = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_Y);
-
-        for &position in self.active_clients.iter() {
-            if (position == Position::Left && (location.x + relative_x) <= self.bounds.xmin)
-                || (position == Position::Right && (location.x + relative_x) >= self.bounds.xmax)
-                || (position == Position::Top && (location.y + relative_y) <= self.bounds.ymin)
-                || (position == Position::Bottom && (location.y + relative_y) >= self.bounds.ymax)
-            {
-                log::debug!("Crossed barrier into position: {position:?}");
-                return Some(position);
-            }
-        }
-        None
-    }
-
-    // Get the max bounds of all displays
-    fn update_bounds(&mut self) -> Result<(), MacosCaptureCreationError> {
-        let active_ids =
-            CGDisplay::active_displays().map_err(MacosCaptureCreationError::ActiveDisplays)?;
-        active_ids.iter().for_each(|d| {
-            let bounds = CGDisplay::new(*d).bounds();
-            self.bounds.xmin = self.bounds.xmin.min(bounds.origin.x);
-            self.bounds.xmax = self.bounds.xmax.max(bounds.origin.x + bounds.size.width);
-            self.bounds.ymin = self.bounds.ymin.min(bounds.origin.y);
-            self.bounds.ymax = self.bounds.ymax.max(bounds.origin.y + bounds.size.height);
-        });
-
-        log::debug!("Updated displays bounds: {0:?}", self.bounds);
-        Ok(())
-    }
-
-    // We can't disable mouse movement when in a client so we need to reset the cursor position
-    // to the edge of the screen, the cursor will be hidden but we dont want it to appear in a
-    // random location when we exit the client
-    fn reset_mouse_position(&self, event: &CGEvent) -> Result<(), CaptureError> {
-        if let Some(pos) = self.current_pos {
-            let location = event.location();
-            let edge_offset = 1.0;
-
-            // After the cursor is warped no event is produced but the next event
-            // will carry the delta from the warp so only half the delta is needed to move the cursor
-            let delta_y = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_Y) / 2.0;
-            let delta_x = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_X) / 2.0;
-
-            let mut new_x = location.x + delta_x;
-            let mut new_y = location.y + delta_y;
-
-            match pos {
-                Position::Left => {
-                    new_x = self.bounds.xmin + edge_offset;
-                }
-                Position::Right => {
-                    new_x = self.bounds.xmax - edge_offset;
-                }
-                Position::Top => {
-                    new_y = self.bounds.ymin + edge_offset;
-                }
-                Position::Bottom => {
-                    new_y = self.bounds.ymax - edge_offset;
-                }
-            }
-            let new_pos = CGPoint::new(new_x, new_y);
-
-            log::trace!("Resetting cursor position to: {new_x}, {new_y}");
-
-            return CGDisplay::warp_mouse_cursor_position(new_pos)
-                .map_err(CaptureError::WarpCursor);
-        }
-
-        Err(CaptureError::ResetMouseWithoutClient)
-    }
-
-    async fn handle_producer_event(
-        &mut self,
-        producer_event: ProducerEvent,
-    ) -> Result<(), CaptureError> {
-        log::debug!("handling event: {producer_event:?}");
-        match producer_event {
-            ProducerEvent::Release => {
-                if self.current_pos.is_some() {
-                    CGDisplay::show_cursor(&CGDisplay::main())
-                        .map_err(CaptureError::CoreGraphics)?;
-                    self.current_pos = None;
-                }
-            }
-            ProducerEvent::Grab(pos) => {
-                if self.current_pos.is_none() {
-                    CGDisplay::hide_cursor(&CGDisplay::main())
-                        .map_err(CaptureError::CoreGraphics)?;
-                    self.current_pos = Some(pos);
-                }
-            }
-            ProducerEvent::Create(p) => {
-                self.active_clients.insert(p);
-            }
-            ProducerEvent::Destroy(p) => {
-                if let Some(current) = self.current_pos {
-                    if current == p {
-                        CGDisplay::show_cursor(&CGDisplay::main())
-                            .map_err(CaptureError::CoreGraphics)?;
-                        self.current_pos = None;
-                    };
-                }
-                self.active_clients.remove(&p);
-            }
-            ProducerEvent::EventTapDisabled => return Err(CaptureError::EventTapDisabled),
-        };
-        Ok(())
-    }
-}
-
-fn get_events(
-    ev_type: &CGEventType,
-    ev: &CGEvent,
-    result: &mut Vec<CaptureEvent>,
-) -> Result<(), CaptureError> {
-    fn map_pointer_event(ev: &CGEvent) -> PointerEvent {
-        PointerEvent::Motion {
-            time: 0,
-            dx: ev.get_double_value_field(EventField::MOUSE_EVENT_DELTA_X),
-            dy: ev.get_double_value_field(EventField::MOUSE_EVENT_DELTA_Y),
-        }
-    }
-
-    fn map_key(ev: &CGEvent) -> Result<u32, CaptureError> {
-        let code = ev.get_integer_value_field(EventField::KEYBOARD_EVENT_KEYCODE);
-        match KeyMap::from_key_mapping(KeyMapping::Mac(code as u16)) {
-            Ok(k) => Ok(k.evdev as u32),
-            Err(()) => Err(CaptureError::KeyMapError(code)),
-        }
-    }
-
-    match ev_type {
-        CGEventType::KeyDown => {
-            let k = map_key(ev)?;
-            result.push(CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key {
-                time: 0,
-                key: k,
-                state: 1,
-            })));
-        }
-        CGEventType::KeyUp => {
-            let k = map_key(ev)?;
-            result.push(CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key {
-                time: 0,
-                key: k,
-                state: 0,
-            })));
-        }
-        CGEventType::FlagsChanged => {
-            let mut mods = XMods::empty();
-            let mut mods_locked = XMods::empty();
-            let cg_flags = ev.get_flags();
-
-            if cg_flags.contains(CGEventFlags::CGEventFlagShift) {
-                mods |= XMods::ShiftMask;
-            }
-            if cg_flags.contains(CGEventFlags::CGEventFlagControl) {
-                mods |= XMods::ControlMask;
-            }
-            if cg_flags.contains(CGEventFlags::CGEventFlagAlternate) {
-                mods |= XMods::Mod1Mask;
-            }
-            if cg_flags.contains(CGEventFlags::CGEventFlagCommand) {
-                mods |= XMods::Mod4Mask;
-            }
-            if cg_flags.contains(CGEventFlags::CGEventFlagAlphaShift) {
-                mods |= XMods::LockMask;
-                mods_locked |= XMods::LockMask;
-            }
-
-            let modifier_event = KeyboardEvent::Modifiers {
-                depressed: mods.bits(),
-                latched: 0,
-                locked: mods_locked.bits(),
-                group: 0,
-            };
-
-            result.push(CaptureEvent::Input(Event::Keyboard(modifier_event)));
-        }
-        CGEventType::MouseMoved => {
-            result.push(CaptureEvent::Input(Event::Pointer(map_pointer_event(ev))))
-        }
-        CGEventType::LeftMouseDragged => {
-            result.push(CaptureEvent::Input(Event::Pointer(map_pointer_event(ev))))
-        }
-        CGEventType::RightMouseDragged => {
-            result.push(CaptureEvent::Input(Event::Pointer(map_pointer_event(ev))))
-        }
-        CGEventType::OtherMouseDragged => {
-            result.push(CaptureEvent::Input(Event::Pointer(map_pointer_event(ev))))
-        }
-        CGEventType::LeftMouseDown => {
-            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
-                time: 0,
-                button: BTN_LEFT,
-                state: 1,
-            })))
-        }
-        CGEventType::LeftMouseUp => {
-            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
-                time: 0,
-                button: BTN_LEFT,
-                state: 0,
-            })))
-        }
-        CGEventType::RightMouseDown => {
-            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
-                time: 0,
-                button: BTN_RIGHT,
-                state: 1,
-            })))
-        }
-        CGEventType::RightMouseUp => {
-            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
-                time: 0,
-                button: BTN_RIGHT,
-                state: 0,
-            })))
-        }
-        CGEventType::OtherMouseDown => {
-            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
-                time: 0,
-                button: BTN_MIDDLE,
-                state: 1,
-            })))
-        }
-        CGEventType::OtherMouseUp => {
-            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
-                time: 0,
-                button: BTN_MIDDLE,
-                state: 0,
-            })))
-        }
-        CGEventType::ScrollWheel => {
-            let v = ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_POINT_DELTA_AXIS_1);
-            let h = ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_POINT_DELTA_AXIS_2);
-            if v != 0 {
-                result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
-                    time: 0,
-                    axis: 0, // Vertical
-                    value: v as f64,
-                })));
-            }
-            if h != 0 {
-                result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
-                    time: 0,
-                    axis: 1, // Horizontal
-                    value: h as f64,
-                })));
-            }
-        }
-        _ => (),
-    }
-    Ok(())
-}
-
-fn create_event_tap<'a>(
-    client_state: Arc<Mutex<InputCaptureState>>,
-    notify_tx: Sender<ProducerEvent>,
-    event_tx: Sender<(Position, CaptureEvent)>,
-) -> Result<CGEventTap<'a>, MacosCaptureCreationError> {
-    let cg_events_of_interest: Vec<CGEventType> = vec![
-        CGEventType::LeftMouseDown,
-        CGEventType::LeftMouseUp,
-        CGEventType::RightMouseDown,
-        CGEventType::RightMouseUp,
-        CGEventType::OtherMouseDown,
-        CGEventType::OtherMouseUp,
-        CGEventType::MouseMoved,
-        CGEventType::LeftMouseDragged,
-        CGEventType::RightMouseDragged,
-        CGEventType::OtherMouseDragged,
-        CGEventType::ScrollWheel,
-        CGEventType::KeyDown,
-        CGEventType::KeyUp,
-        CGEventType::FlagsChanged,
-    ];
-
-    let event_tap_callback =
-        move |_proxy: CGEventTapProxy, event_type: CGEventType, cg_ev: &CGEvent| {
-            log::trace!("Got event from tap: {event_type:?}");
-            let mut state = client_state.blocking_lock();
-            let mut pos = None;
-            let mut res_events = vec![];
-
-            if matches!(
-                event_type,
-                CGEventType::TapDisabledByTimeout | CGEventType::TapDisabledByUserInput
-            ) {
-                log::error!("CGEventTap disabled");
-                notify_tx
-                    .blocking_send(ProducerEvent::EventTapDisabled)
-                    .unwrap_or_else(|e| {
-                        log::error!("Failed to send notification: {e}");
-                    });
-            }
-
-            // Are we in a client?
-            if let Some(current_pos) = state.current_pos {
-                pos = Some(current_pos);
-                get_events(&event_type, cg_ev, &mut res_events).unwrap_or_else(|e| {
-                    log::error!("Failed to get events: {e}");
-                });
-
-                // Keep (hidden) cursor at the edge of the screen
-                if matches!(event_type, CGEventType::MouseMoved) {
-                    state.reset_mouse_position(cg_ev).unwrap_or_else(|e| {
-                        log::error!("Failed to reset mouse position: {e}");
-                    })
-                }
-            }
-            // Did we cross a barrier?
-            else if matches!(event_type, CGEventType::MouseMoved) {
-                if let Some(new_pos) = state.crossed(cg_ev) {
-                    pos = Some(new_pos);
-                    res_events.push(CaptureEvent::Begin);
-                    notify_tx
-                        .blocking_send(ProducerEvent::Grab(new_pos))
-                        .expect("Failed to send notification");
-                }
-            }
-
-            if let Some(pos) = pos {
-                res_events.iter().for_each(|e| {
-                    event_tx
-                        .blocking_send((pos, *e))
-                        .expect("Failed to send event");
-                });
-                // Returning None should stop the event from being processed
-                // but core fundation still returns the event
-                cg_ev.set_type(CGEventType::Null);
-            }
-            Some(cg_ev.to_owned())
-        };
-
-    let tap = CGEventTap::new(
-        CGEventTapLocation::Session,
-        CGEventTapPlacement::HeadInsertEventTap,
-        CGEventTapOptions::Default,
-        cg_events_of_interest,
-        event_tap_callback,
-    )
-    .map_err(|_| MacosCaptureCreationError::EventTapCreation)?;
-
-    let tap_source: CFRunLoopSource = tap
-        .mach_port
-        .create_runloop_source(0)
-        .expect("Failed creating loop source");
-
-    unsafe {
-        CFRunLoop::get_current().add_source(&tap_source, kCFRunLoopCommonModes);
-    }
-
-    Ok(tap)
-}
-
-fn event_tap_thread(
-    client_state: Arc<Mutex<InputCaptureState>>,
-    event_tx: Sender<(Position, CaptureEvent)>,
-    notify_tx: Sender<ProducerEvent>,
-    ready: std::sync::mpsc::Sender<Result<(), MacosCaptureCreationError>>,
-    exit: oneshot::Sender<Result<(), &'static str>>,
-) {
-    let _tap = match create_event_tap(client_state, notify_tx, event_tx) {
-        Err(e) => {
-            ready.send(Err(e)).expect("channel closed");
-            return;
-        }
-        Ok(tap) => {
-            ready.send(Ok(())).expect("channel closed");
-            tap
-        }
-    };
-    CFRunLoop::run_current();
-
-    let _ = exit.send(Err("tap thread exited"));
-}
-
-pub struct MacOSInputCapture {
-    event_rx: Receiver<(Position, CaptureEvent)>,
-    notify_tx: Sender<ProducerEvent>,
-}
+pub struct MacOSInputCapture;

 impl MacOSInputCapture {
-    pub async fn new() -> Result<Self, MacosCaptureCreationError> {
-        let state = Arc::new(Mutex::new(InputCaptureState::new()?));
-        let (event_tx, event_rx) = mpsc::channel(32);
-        let (notify_tx, mut notify_rx) = mpsc::channel(32);
-        let (ready_tx, ready_rx) = std::sync::mpsc::channel();
-        let (tap_exit_tx, mut tap_exit_rx) = oneshot::channel();
-
-        unsafe {
-            configure_cf_settings()?;
-        }
-
-        log::info!("Enabling CGEvent tap");
-        let event_tap_thread_state = state.clone();
-        let event_tap_notify = notify_tx.clone();
-        thread::spawn(move || {
-            event_tap_thread(
-                event_tap_thread_state,
-                event_tx,
-                event_tap_notify,
-                ready_tx,
-                tap_exit_tx,
-            )
-        });
-
-        // wait for event tap creation result
-        ready_rx.recv().expect("channel closed")?;
-
-        let _tap_task: tokio::task::JoinHandle<()> = tokio::task::spawn_local(async move {
-            loop {
-                tokio::select! {
-                    producer_event = notify_rx.recv() => {
-                        let producer_event = producer_event.expect("channel closed");
-                        let mut state = state.lock().await;
-                        state.handle_producer_event(producer_event).await.unwrap_or_else(|e| {
-                            log::error!("Failed to handle producer event: {e}");
-                        })
-                    }
-
-                    res = &mut tap_exit_rx => {
-                        if let Err(e) = res.expect("channel closed") {
-                            log::error!("Tap thread failed: {:?}", e);
-                            break;
-                        }
-                    }
-                }
-            }
-        });
-
-        Ok(Self {
-            event_rx,
-            notify_tx,
-        })
-    }
-}
-
-#[async_trait]
-impl Capture for MacOSInputCapture {
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
-        let notify_tx = self.notify_tx.clone();
-        tokio::task::spawn_local(async move {
-            log::debug!("creating capture, {pos}");
-            let _ = notify_tx.send(ProducerEvent::Create(pos)).await;
-            log::debug!("done !");
-        });
-        Ok(())
-    }
-
-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
-        let notify_tx = self.notify_tx.clone();
-        tokio::task::spawn_local(async move {
-            log::debug!("destroying capture {pos}");
-            let _ = notify_tx.send(ProducerEvent::Destroy(pos)).await;
-            log::debug!("done !");
-        });
-        Ok(())
-    }
-
-    async fn release(&mut self) -> Result<(), CaptureError> {
-        let notify_tx = self.notify_tx.clone();
-        tokio::task::spawn_local(async move {
-            log::debug!("notifying Release");
-            let _ = notify_tx.send(ProducerEvent::Release).await;
-        });
-        Ok(())
-    }
-
-    async fn terminate(&mut self) -> Result<(), CaptureError> {
-        Ok(())
+    pub fn new() -> std::result::Result<Self, MacOSInputCaptureCreationError> {
+        Err(MacOSInputCaptureCreationError::NotImplemented)
    }
 }

 impl Stream for MacOSInputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+    type Item = io::Result<(CaptureHandle, Event)>;

-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        match ready!(self.event_rx.poll_recv(cx)) {
-            None => Poll::Ready(None),
-            Some(e) => Poll::Ready(Some(Ok(e))),
-        }
+    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        Poll::Pending
    }
 }

-type CGSConnectionID = u32;
-
-#[link(name = "ApplicationServices", kind = "framework")]
-extern "C" {
-    fn CGSSetConnectionProperty(
-        cid: CGSConnectionID,
-        targetCID: CGSConnectionID,
-        key: CFStringRef,
-        value: CFBooleanRef,
-    ) -> CGError;
-    fn _CGSDefaultConnection() -> CGSConnectionID;
-}
-
-extern "C" {
-    fn CGEventSourceSetLocalEventsSuppressionInterval(
-        event_source: CGEventSource,
-        seconds: CFTimeInterval,
-    );
-}
-
-unsafe fn configure_cf_settings() -> Result<(), MacosCaptureCreationError> {
-    // When we warp the cursor using CGWarpMouseCursorPosition local events are suppressed for a short time
-    // this leeds to the cursor not flowing when crossing back from a clinet, set this to to 0 stops the warp
-    // from working, set a low value by trial and error, 0.05s seems good. 0.25s is the default
-    let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
-        .map_err(|_| MacosCaptureCreationError::EventSourceCreation)?;
-    CGEventSourceSetLocalEventsSuppressionInterval(event_source, 0.05);
-
-    // This is a private settings that allows the cursor to be hidden while in the background.
-    // It is used by Barrier and other apps.
-    let key = CString::new("SetsCursorInBackground").unwrap();
-    let cf_key = CFStringCreateWithCString(
-        kCFAllocatorDefault,
-        key.as_ptr() as *const c_char,
-        kCFStringEncodingUTF8,
-    );
-    if CGSSetConnectionProperty(
-        _CGSDefaultConnection(),
-        _CGSDefaultConnection(),
-        cf_key,
-        kCFBooleanTrue,
-    ) != kCGErrorSuccess
-    {
-        return Err(MacosCaptureCreationError::CGCursorProperty);
+impl InputCapture for MacOSInputCapture {
+    fn create(&mut self, _id: CaptureHandle, _pos: Position) -> io::Result<()> {
+        Ok(())
    }
-    CFRelease(cf_key as *const c_void);
-    Ok(())
-}

-// From X11/X.h
-bitflags! {
-    #[repr(C)]
-    #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-    struct XMods: u32 {
-        const ShiftMask = (1<<0);
-        const LockMask = (1<<1);
-        const ControlMask = (1<<2);
-        const Mod1Mask = (1<<3);
-        const Mod2Mask = (1<<4);
-        const Mod3Mask = (1<<5);
-        const Mod4Mask = (1<<6);
-        const Mod5Mask = (1<<7);
+    fn destroy(&mut self, _id: CaptureHandle) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn release(&mut self) -> io::Result<()> {
+        Ok(())
    }
 }
--- a/input-capture/src/wayland.rs
+++ b/input-capture/src/wayland.rs
@@ -1,10 +1,10 @@
-use async_trait::async_trait;
 use futures_core::Stream;
+use memmap::MmapOptions;
 use std::{
    collections::VecDeque,
    env,
    io::{self, ErrorKind},
-    os::fd::{AsFd, RawFd},
+    os::fd::{AsFd, OwnedFd, RawFd},
    pin::Pin,
    task::{ready, Context, Poll},
 };
@@ -13,8 +13,8 @@ use tokio::io::unix::AsyncFd;
 use std::{
    fs::File,
    io::{BufWriter, Write},
-    os::unix::prelude::AsRawFd,
-    sync::Arc,
+    os::unix::prelude::{AsRawFd, FromRawFd},
+    rc::Rc,
 };

 use wayland_protocols::{
@@ -58,20 +58,20 @@ use wayland_client::{
    Connection, Dispatch, DispatchError, EventQueue, QueueHandle, WEnum,
 };

-use input_event::{Event, KeyboardEvent, PointerEvent};
+use tempfile;

-use crate::{CaptureError, CaptureEvent};
+use input_event::{Event, KeyboardEvent, PointerEvent};

 use super::{
    error::{LayerShellCaptureCreationError, WaylandBindError},
-    Capture, Position,
+    CaptureHandle, InputCapture, Position,
 };

 struct Globals {
    compositor: wl_compositor::WlCompositor,
    pointer_constraints: ZwpPointerConstraintsV1,
    relative_pointer_manager: ZwpRelativePointerManagerV1,
-    shortcut_inhibit_manager: Option<ZwpKeyboardShortcutsInhibitManagerV1>,
+    shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1,
    seat: wl_seat::WlSeat,
    shm: wl_shm::WlShm,
    layer_shell: ZwlrLayerShellV1,
@@ -102,13 +102,13 @@ struct State {
    pointer_lock: Option<ZwpLockedPointerV1>,
    rel_pointer: Option<ZwpRelativePointerV1>,
    shortcut_inhibitor: Option<ZwpKeyboardShortcutsInhibitorV1>,
-    active_windows: Vec<Arc<Window>>,
-    focused: Option<Arc<Window>>,
+    client_for_window: Vec<(Rc<Window>, CaptureHandle)>,
+    focused: Option<(Rc<Window>, CaptureHandle)>,
    g: Globals,
-    wayland_fd: RawFd,
+    wayland_fd: OwnedFd,
    read_guard: Option<ReadEventsGuard>,
    qh: QueueHandle<Self>,
-    pending_events: VecDeque<(Position, CaptureEvent)>,
+    pending_events: VecDeque<(CaptureHandle, Event)>,
    output_info: Vec<(WlOutput, OutputInfo)>,
    scroll_discrete_pending: bool,
 }
@@ -120,11 +120,11 @@ struct Inner {

 impl AsRawFd for Inner {
    fn as_raw_fd(&self) -> RawFd {
-        self.state.wayland_fd
+        self.state.wayland_fd.as_raw_fd()
    }
 }

-pub struct LayerShellInputCapture(AsyncFd<Inner>);
+pub struct WaylandInputCapture(AsyncFd<Inner>);

 struct Window {
    buffer: wl_buffer::WlBuffer,
@@ -256,7 +256,7 @@ fn draw(f: &mut File, (width, height): (u32, u32)) {
    }
 }

-impl LayerShellInputCapture {
+impl WaylandInputCapture {
    pub fn new() -> std::result::Result<Self, LayerShellCaptureCreationError> {
        let conn = Connection::connect_to_env()?;
        let (g, mut queue) = registry_queue_init::<State>(&conn)?;
@@ -285,18 +285,9 @@ impl LayerShellInputCapture {
        let relative_pointer_manager: ZwpRelativePointerManagerV1 = g
            .bind(&qh, 1..=1, ())
            .map_err(|e| WaylandBindError::new(e, "zwp_relative_pointer_manager_v1"))?;
-        let shortcut_inhibit_manager: Result<
-            ZwpKeyboardShortcutsInhibitManagerV1,
-            WaylandBindError,
-        > = g
+        let shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1 = g
            .bind(&qh, 1..=1, ())
-            .map_err(|e| WaylandBindError::new(e, "zwp_keyboard_shortcuts_inhibit_manager_v1"));
-        // layer-shell backend still works without this protocol so we make it an optional dependency
-        if let Err(e) = &shortcut_inhibit_manager {
-            log::warn!("shortcut_inhibit_manager not supported: {e}\nkeybinds handled by the compositor will not be passed
-                to the client");
-        }
-        let shortcut_inhibit_manager = shortcut_inhibit_manager.ok();
+            .map_err(|e| WaylandBindError::new(e, "zwp_keyboard_shortcuts_inhibit_manager_v1"))?;
        let outputs = vec![];

        let g = Globals {
@@ -314,7 +305,10 @@ impl LayerShellInputCapture {
        // flush outgoing events
        queue.flush()?;

-        let wayland_fd = queue.as_fd().as_raw_fd();
+        // prepare reading wayland events
+        let read_guard = queue.prepare_read().unwrap(); // there can not yet be events to dispatch
+        let wayland_fd = read_guard.connection_fd().try_clone_to_owned().unwrap();
+        std::mem::drop(read_guard);

        let mut state = State {
            pointer: None,
@@ -323,7 +317,7 @@ impl LayerShellInputCapture {
            pointer_lock: None,
            rel_pointer: None,
            shortcut_inhibitor: None,
-            active_windows: Vec::new(),
+            client_for_window: Vec::new(),
            focused: None,
            qh,
            wayland_fd,
@@ -370,18 +364,23 @@ impl LayerShellInputCapture {

        let inner = AsyncFd::new(Inner { queue, state })?;

-        Ok(LayerShellInputCapture(inner))
+        Ok(WaylandInputCapture(inner))
    }

-    fn add_client(&mut self, pos: Position) {
-        self.0.get_mut().state.add_client(pos);
+    fn add_client(&mut self, handle: CaptureHandle, pos: Position) {
+        self.0.get_mut().state.add_client(handle, pos);
    }

-    fn delete_client(&mut self, pos: Position) {
+    fn delete_client(&mut self, handle: CaptureHandle) {
        let inner = self.0.get_mut();
        // remove all windows corresponding to this client
-        while let Some(i) = inner.state.active_windows.iter().position(|w| w.pos == pos) {
-            inner.state.active_windows.remove(i);
+        while let Some(i) = inner
+            .state
+            .client_for_window
+            .iter()
+            .position(|(_, c)| *c == handle)
+        {
+            inner.state.client_for_window.remove(i);
            inner.state.focused = None;
        }
    }
@@ -395,7 +394,7 @@ impl State {
        serial: u32,
        qh: &QueueHandle<State>,
    ) {
-        let window = self.focused.as_ref().unwrap();
+        let (window, _) = self.focused.as_ref().unwrap();

        // hide the cursor
        pointer.set_cursor(serial, None, 0, 0);
@@ -428,17 +427,19 @@ impl State {
        }

        // capture modifier keys
-        if let Some(shortcut_inhibit_manager) = &self.g.shortcut_inhibit_manager {
-            if self.shortcut_inhibitor.is_none() {
-                self.shortcut_inhibitor =
-                    Some(shortcut_inhibit_manager.inhibit_shortcuts(surface, &self.g.seat, qh, ()));
-            }
+        if self.shortcut_inhibitor.is_none() {
+            self.shortcut_inhibitor = Some(self.g.shortcut_inhibit_manager.inhibit_shortcuts(
+                surface,
+                &self.g.seat,
+                qh,
+                (),
+            ));
        }
    }

    fn ungrab(&mut self) {
        // get focused client
-        let window = match self.focused.as_ref() {
+        let (window, _client) = match self.focused.as_ref() {
            Some(focused) => focused,
            None => return,
        };
@@ -468,23 +469,27 @@ impl State {
        }
    }

-    fn add_client(&mut self, pos: Position) {
+    fn add_client(&mut self, client: CaptureHandle, pos: Position) {
        let outputs = get_output_configuration(self, pos);

        log::debug!("outputs: {outputs:?}");
        outputs.iter().for_each(|(o, i)| {
            let window = Window::new(self, &self.qh, o, pos, i.size);
-            let window = Arc::new(window);
-            self.active_windows.push(window);
+            let window = Rc::new(window);
+            self.client_for_window.push((window, client));
        });
    }

    fn update_windows(&mut self) {
        log::debug!("updating windows");
        log::debug!("output info: {:?}", self.output_info);
-        let clients: Vec<_> = self.active_windows.drain(..).map(|w| w.pos).collect();
-        for pos in clients {
-            self.add_client(pos);
+        let clients: Vec<_> = self
+            .client_for_window
+            .drain(..)
+            .map(|(w, c)| (c, w.pos))
+            .collect();
+        for (client, pos) in clients {
+            self.add_client(client, pos);
        }
    }
 }
@@ -556,34 +561,28 @@ impl Inner {
    }
 }

-#[async_trait]
-impl Capture for LayerShellInputCapture {
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
-        self.add_client(pos);
+impl InputCapture for WaylandInputCapture {
+    fn create(&mut self, handle: CaptureHandle, pos: Position) -> io::Result<()> {
+        self.add_client(handle, pos);
        let inner = self.0.get_mut();
-        Ok(inner.flush_events()?)
+        inner.flush_events()
+    }
+    fn destroy(&mut self, handle: CaptureHandle) -> io::Result<()> {
+        self.delete_client(handle);
+        let inner = self.0.get_mut();
+        inner.flush_events()
    }

-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
-        self.delete_client(pos);
-        let inner = self.0.get_mut();
-        Ok(inner.flush_events()?)
-    }
-
-    async fn release(&mut self) -> Result<(), CaptureError> {
+    fn release(&mut self) -> io::Result<()> {
        log::debug!("releasing pointer");
        let inner = self.0.get_mut();
        inner.state.ungrab();
-        Ok(inner.flush_events()?)
-    }
-
-    async fn terminate(&mut self) -> Result<(), CaptureError> {
-        Ok(())
+        inner.flush_events()
    }
 }

-impl Stream for LayerShellInputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+impl Stream for WaylandInputCapture {
+    type Item = io::Result<(CaptureHandle, Event)>;

    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        if let Some(event) = self.0.get_mut().state.pending_events.pop_front() {
@@ -601,7 +600,7 @@ impl Stream for LayerShellInputCapture {
                    // prepare next read
                    match inner.prepare_read() {
                        Ok(_) => {}
-                        Err(e) => return Poll::Ready(Some(Err(e.into()))),
+                        Err(e) => return Poll::Ready(Some(Err(e))),
                    }
                }

@@ -611,14 +610,14 @@ impl Stream for LayerShellInputCapture {
                // flush outgoing events
                if let Err(e) = inner.flush_events() {
                    if e.kind() != ErrorKind::WouldBlock {
-                        return Poll::Ready(Some(Err(e.into())));
+                        return Poll::Ready(Some(Err(e)));
                    }
                }

                // prepare for the next read
                match inner.prepare_read() {
                    Ok(_) => {}
-                    Err(e) => return Poll::Ready(Some(Err(e.into()))),
+                    Err(e) => return Poll::Ready(Some(Err(e))),
                }
            }

@@ -676,20 +675,23 @@ impl Dispatch<WlPointer, ()> for State {
            } => {
                // get client corresponding to the focused surface
                {
-                    if let Some(window) = app.active_windows.iter().find(|w| w.surface == surface) {
-                        app.focused = Some(window.clone());
+                    if let Some((window, client)) = app
+                        .client_for_window
+                        .iter()
+                        .find(|(w, _c)| w.surface == surface)
+                    {
+                        app.focused = Some((window.clone(), *client));
                        app.grab(&surface, pointer, serial, qh);
                    } else {
                        return;
                    }
                }
-                let pos = app
-                    .active_windows
+                let (_, client) = app
+                    .client_for_window
                    .iter()
-                    .find(|w| w.surface == surface)
-                    .map(|w| w.pos)
+                    .find(|(w, _c)| w.surface == surface)
                    .unwrap();
-                app.pending_events.push_back((pos, CaptureEvent::Begin));
+                app.pending_events.push_back((*client, Event::Enter()));
            }
            wl_pointer::Event::Leave { .. } => {
                /* There are rare cases, where when a window is opened in
@@ -710,18 +712,18 @@ impl Dispatch<WlPointer, ()> for State {
                button,
                state,
            } => {
-                let window = app.focused.as_ref().unwrap();
+                let (_, client) = app.focused.as_ref().unwrap();
                app.pending_events.push_back((
-                    window.pos,
-                    CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
+                    *client,
+                    Event::Pointer(PointerEvent::Button {
                        time,
                        button,
                        state: u32::from(state),
-                    })),
+                    }),
                ));
            }
            wl_pointer::Event::Axis { time, axis, value } => {
-                let window = app.focused.as_ref().unwrap();
+                let (_, client) = app.focused.as_ref().unwrap();
                if app.scroll_discrete_pending {
                    // each axisvalue120 event is coupled with
                    // a corresponding axis event, which needs to
@@ -729,24 +731,24 @@ impl Dispatch<WlPointer, ()> for State {
                    app.scroll_discrete_pending = false;
                } else {
                    app.pending_events.push_back((
-                        window.pos,
-                        CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
+                        *client,
+                        Event::Pointer(PointerEvent::Axis {
                            time,
                            axis: u32::from(axis) as u8,
                            value,
-                        })),
+                        }),
                    ));
                }
            }
            wl_pointer::Event::AxisValue120 { axis, value120 } => {
-                let window = app.focused.as_ref().unwrap();
+                let (_, client) = app.focused.as_ref().unwrap();
                app.scroll_discrete_pending = true;
                app.pending_events.push_back((
-                    window.pos,
-                    CaptureEvent::Input(Event::Pointer(PointerEvent::AxisDiscrete120 {
+                    *client,
+                    Event::Pointer(PointerEvent::AxisDiscrete120 {
                        axis: u32::from(axis) as u8,
                        value: value120,
-                    })),
+                    }),
                ));
            }
            wl_pointer::Event::Frame {} => {
@@ -768,7 +770,10 @@ impl Dispatch<WlKeyboard, ()> for State {
        _: &Connection,
        _: &QueueHandle<Self>,
    ) {
-        let window = &app.focused;
+        let (_window, client) = match &app.focused {
+            Some(focused) => (Some(&focused.0), Some(&focused.1)),
+            None => (None, None),
+        };
        match event {
            wl_keyboard::Event::Key {
                serial: _,
@@ -776,14 +781,14 @@ impl Dispatch<WlKeyboard, ()> for State {
                key,
                state,
            } => {
-                if let Some(window) = window {
+                if let Some(client) = client {
                    app.pending_events.push_back((
-                        window.pos,
-                        CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key {
+                        *client,
+                        Event::Keyboard(KeyboardEvent::Key {
                            time,
                            key,
                            state: u32::from(state) as u8,
-                        })),
+                        }),
                    ));
                }
            }
@@ -794,18 +799,27 @@ impl Dispatch<WlKeyboard, ()> for State {
                mods_locked,
                group,
            } => {
-                if let Some(window) = window {
+                if let Some(client) = client {
                    app.pending_events.push_back((
-                        window.pos,
-                        CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Modifiers {
-                            depressed: mods_depressed,
-                            latched: mods_latched,
-                            locked: mods_locked,
+                        *client,
+                        Event::Keyboard(KeyboardEvent::Modifiers {
+                            mods_depressed,
+                            mods_latched,
+                            mods_locked,
                            group,
-                        })),
+                        }),
                    ));
                }
            }
+            wl_keyboard::Event::Keymap {
+                format: _,
+                fd,
+                size: _,
+            } => {
+                let fd = unsafe { &File::from_raw_fd(fd.as_raw_fd()) };
+                let _mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };
+                // TODO keymap
+            }
            _ => (),
        }
    }
@@ -823,16 +837,21 @@ impl Dispatch<ZwpRelativePointerV1, ()> for State {
        if let zwp_relative_pointer_v1::Event::RelativeMotion {
            utime_hi,
            utime_lo,
-            dx_unaccel: dx,
-            dy_unaccel: dy,
-            ..
+            dx: _,
+            dy: _,
+            dx_unaccel: surface_x,
+            dy_unaccel: surface_y,
        } = event
        {
-            if let Some(window) = &app.focused {
+            if let Some((_window, client)) = &app.focused {
                let time = (((utime_hi as u64) << 32 | utime_lo as u64) / 1000) as u32;
                app.pending_events.push_back((
-                    window.pos,
-                    CaptureEvent::Input(Event::Pointer(PointerEvent::Motion { time, dx, dy })),
+                    *client,
+                    Event::Pointer(PointerEvent::Motion {
+                        time,
+                        relative_x: surface_x,
+                        relative_y: surface_y,
+                    }),
                ));
            }
        }
@@ -849,10 +868,10 @@ impl Dispatch<ZwlrLayerSurfaceV1, ()> for State {
        _: &QueueHandle<Self>,
    ) {
        if let zwlr_layer_surface_v1::Event::Configure { serial, .. } = event {
-            if let Some(window) = app
-                .active_windows
+            if let Some((window, _client)) = app
+                .client_for_window
                .iter()
-                .find(|w| &w.layer_surface == layer_surface)
+                .find(|(w, _c)| &w.layer_surface == layer_surface)
            {
                // client corresponding to the layer_surface
                let surface = &window.surface;
--- a/input-capture/src/windows.rs
+++ b/input-capture/src/windows.rs
@@ -1,17 +1,17 @@
-use async_trait::async_trait;
+use anyhow::Result;
 use core::task::{Context, Poll};
 use futures::Stream;
 use once_cell::unsync::Lazy;

-use std::collections::HashSet;
+use std::collections::HashMap;
 use std::ptr::{addr_of, addr_of_mut};

 use futures::executor::block_on;
 use std::default::Default;
-use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
+use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::{mpsc, Mutex};
 use std::task::ready;
-use std::{pin::Pin, thread};
+use std::{io, pin::Pin, thread};
 use tokio::sync::mpsc::{channel, Receiver, Sender};
 use windows::core::{w, PCWSTR};
 use windows::Win32::Foundation::{FALSE, HINSTANCE, HWND, LPARAM, LRESULT, RECT, WPARAM};
@@ -37,15 +37,15 @@ use input_event::{
    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
 };

-use super::{Capture, CaptureError, CaptureEvent, Position};
+use super::{CaptureHandle, InputCapture, Position};

 enum Request {
-    Create(Position),
-    Destroy(Position),
+    Create(CaptureHandle, Position),
+    Destroy(CaptureHandle),
 }

 pub struct WindowsInputCapture {
-    event_rx: Receiver<(Position, CaptureEvent)>,
+    event_rx: Receiver<(CaptureHandle, Event)>,
    msg_thread: Option<std::thread::JoinHandle<()>>,
 }

@@ -63,44 +63,38 @@ unsafe fn signal_message_thread(event_type: EventType) {
    }
 }

-#[async_trait]
-impl Capture for WindowsInputCapture {
-    async fn create(&mut self, pos: Position) -> Result<(), CaptureError> {
+impl InputCapture for WindowsInputCapture {
+    fn create(&mut self, handle: CaptureHandle, pos: Position) -> io::Result<()> {
        unsafe {
            {
                let mut requests = REQUEST_BUFFER.lock().unwrap();
-                requests.push(Request::Create(pos));
+                requests.push(Request::Create(handle, pos));
+            }
+            signal_message_thread(EventType::Request);
+        }
+        Ok(())
+    }
+    fn destroy(&mut self, handle: CaptureHandle) -> io::Result<()> {
+        unsafe {
+            {
+                let mut requests = REQUEST_BUFFER.lock().unwrap();
+                requests.push(Request::Destroy(handle));
            }
            signal_message_thread(EventType::Request);
        }
        Ok(())
    }

-    async fn destroy(&mut self, pos: Position) -> Result<(), CaptureError> {
-        unsafe {
-            {
-                let mut requests = REQUEST_BUFFER.lock().unwrap();
-                requests.push(Request::Destroy(pos));
-            }
-            signal_message_thread(EventType::Request);
-        }
-        Ok(())
-    }
-
-    async fn release(&mut self) -> Result<(), CaptureError> {
+    fn release(&mut self) -> io::Result<()> {
        unsafe { signal_message_thread(EventType::Release) };
        Ok(())
    }
-
-    async fn terminate(&mut self) -> Result<(), CaptureError> {
-        Ok(())
-    }
 }

 static mut REQUEST_BUFFER: Mutex<Vec<Request>> = Mutex::new(Vec::new());
-static mut ACTIVE_CLIENT: Option<Position> = None;
-static mut CLIENTS: Lazy<HashSet<Position>> = Lazy::new(HashSet::new);
-static mut EVENT_TX: Option<Sender<(Position, CaptureEvent)>> = None;
+static mut ACTIVE_CLIENT: Option<CaptureHandle> = None;
+static mut CLIENT_FOR_POS: Lazy<HashMap<Position, CaptureHandle>> = Lazy::new(HashMap::new);
+static mut EVENT_TX: Option<Sender<(CaptureHandle, Event)>> = None;
 static mut EVENT_THREAD_ID: AtomicU32 = AtomicU32::new(0);
 unsafe fn set_event_tid(tid: u32) {
    EVENT_THREAD_ID.store(tid, Ordering::SeqCst);
@@ -151,8 +145,11 @@ fn to_mouse_event(wparam: WPARAM, lparam: LPARAM) -> Option<PointerEvent> {
            let (x, y) = (mouse_low_level.pt.x, mouse_low_level.pt.y);
            let (ex, ey) = ENTRY_POINT;
            let (dx, dy) = (x - ex, y - ey);
-            let (dx, dy) = (dx as f64, dy as f64);
-            Some(PointerEvent::Motion { time: 0, dx, dy })
+            Some(PointerEvent::Motion {
+                time: 0,
+                relative_x: dx as f64,
+                relative_y: dy as f64,
+            })
        },
        WPARAM(p) if p == WM_MOUSEWHEEL as usize => Some(PointerEvent::AxisDiscrete120 {
            axis: 0,
@@ -249,7 +246,7 @@ fn clamp_to_display_bounds(prev_point: (i32, i32), point: (i32, i32)) -> (i32, i
    (x.clamp(min_x, max_x), y.clamp(min_y, max_y))
 }

-unsafe fn send_blocking(event: CaptureEvent) {
+unsafe fn send_blocking(event: Event) {
    if let Some(active) = ACTIVE_CLIENT {
        block_on(async move {
            let _ = EVENT_TX.as_ref().unwrap().send((active, event)).await;
@@ -281,17 +278,17 @@ unsafe fn check_client_activation(wparam: WPARAM, lparam: LPARAM) -> bool {
    };

    /* check if a client is registered for the barrier */
-    if !CLIENTS.contains(&pos) {
+    let Some(client) = CLIENT_FOR_POS.get(&pos) else {
        return ret;
-    }
+    };

    /* update active client and entry point */
-    ACTIVE_CLIENT.replace(pos);
+    ACTIVE_CLIENT.replace(*client);
    ENTRY_POINT = clamp_to_display_bounds(prev_pos, curr_pos);

    /* notify main thread */
    log::debug!("ENTERED @ {prev_pos:?} -> {curr_pos:?}");
-    send_blocking(CaptureEvent::Begin);
+    send_blocking(Event::Enter());

    ret
 }
@@ -305,7 +302,7 @@ unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
    }

    /* get active client if any */
-    let Some(pos) = ACTIVE_CLIENT else {
+    let Some(client) = ACTIVE_CLIENT else {
        return LRESULT(1);
    };

@@ -313,7 +310,7 @@ unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
    let Some(pointer_event) = to_mouse_event(wparam, lparam) else {
        return LRESULT(1);
    };
-    let event = (pos, CaptureEvent::Input(Event::Pointer(pointer_event)));
+    let event = (client, Event::Pointer(pointer_event));

    /* notify mainthread (drop events if sending too fast) */
    if let Err(e) = EVENT_TX.as_ref().unwrap().try_send(event) {
@@ -334,7 +331,7 @@ unsafe extern "system" fn kybrd_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
    let Some(key_event) = to_key_event(wparam, lparam) else {
        return LRESULT(1);
    };
-    let event = (client, CaptureEvent::Input(Event::Keyboard(key_event)));
+    let event = (client, Event::Keyboard(key_event));

    if let Err(e) = EVENT_TX.as_ref().unwrap().try_send(event) {
        log::warn!("e: {e}");
@@ -493,8 +490,6 @@ fn get_msg() -> Option<MSG> {
    }
 }

-static WINDOW_CLASS_REGISTERED: AtomicBool = AtomicBool::new(false);
-
 fn message_thread(ready_tx: mpsc::Sender<()>) {
    unsafe {
        set_event_tid(GetCurrentThreadId());
@@ -515,19 +510,13 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
            ..Default::default()
        };

-        if WINDOW_CLASS_REGISTERED
-            .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
-            .is_ok()
-        {
-            /* register window class if not yet done so */
-            let ret = RegisterClassW(&window_class);
-            if ret == 0 {
-                panic!("RegisterClassW");
-            }
+        let ret = RegisterClassW(&window_class);
+        if ret == 0 {
+            panic!("RegisterClassW");
        }

        /* window is used ro receive WM_DISPLAYCHANGE messages */
-        CreateWindowExW(
+        let ret = CreateWindowExW(
            Default::default(),
            w!("lan-mouse-message-window-class"),
            w!("lan-mouse-msg-window"),
@@ -540,8 +529,10 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
            HMENU::default(),
            instance,
            None,
-        )
-        .expect("CreateWindowExW");
+        );
+        if ret.0 == 0 {
+            panic!("CreateWindowExW");
+        }

        /* run message loop */
        loop {
@@ -549,7 +540,7 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
            let Some(msg) = get_msg() else {
                break;
            };
-            if msg.hwnd.0.is_null() {
+            if msg.hwnd.0 == 0 {
                /* messages sent via PostThreadMessage */
                match msg.wParam.0 {
                    x if x == EventType::Exit as usize => break,
@@ -583,16 +574,23 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {

 fn update_clients(request: Request) {
    match request {
-        Request::Create(pos) => {
-            unsafe { CLIENTS.insert(pos) };
+        Request::Create(handle, pos) => {
+            unsafe { CLIENT_FOR_POS.insert(pos, handle) };
        }
-        Request::Destroy(pos) => unsafe {
-            if let Some(active_pos) = ACTIVE_CLIENT {
-                if pos == active_pos {
-                    let _ = ACTIVE_CLIENT.take();
+        Request::Destroy(handle) => unsafe {
+            for pos in [
+                Position::Left,
+                Position::Right,
+                Position::Top,
+                Position::Bottom,
+            ] {
+                if ACTIVE_CLIENT == Some(handle) {
+                    ACTIVE_CLIENT.take();
+                }
+                if CLIENT_FOR_POS.get(&pos).copied() == Some(handle) {
+                    CLIENT_FOR_POS.remove(&pos);
                }
            }
-            CLIENTS.remove(&pos);
        },
    }
 }
@@ -615,7 +613,7 @@ impl WindowsInputCapture {
 }

 impl Stream for WindowsInputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+    type Item = io::Result<(CaptureHandle, Event)>;
    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        match ready!(self.event_rx.poll_recv(cx)) {
            None => Poll::Ready(None),
--- a/input-capture/src/x11.rs
+++ b/input-capture/src/x11.rs
@@ -1,9 +1,13 @@
+use std::io;
 use std::task::Poll;

-use async_trait::async_trait;
 use futures_core::Stream;

-use super::{error::X11InputCaptureCreationError, Capture, CaptureError, CaptureEvent, Position};
+use super::InputCapture;
+use input_event::Event;
+
+use super::error::X11InputCaptureCreationError;
+use super::{CaptureHandle, Position};

 pub struct X11InputCapture {}

@@ -13,27 +17,22 @@ impl X11InputCapture {
    }
 }

-#[async_trait]
-impl Capture for X11InputCapture {
-    async fn create(&mut self, _pos: Position) -> Result<(), CaptureError> {
+impl InputCapture for X11InputCapture {
+    fn create(&mut self, _id: CaptureHandle, _pos: Position) -> io::Result<()> {
        Ok(())
    }

-    async fn destroy(&mut self, _pos: Position) -> Result<(), CaptureError> {
+    fn destroy(&mut self, _id: CaptureHandle) -> io::Result<()> {
        Ok(())
    }

-    async fn release(&mut self) -> Result<(), CaptureError> {
-        Ok(())
-    }
-
-    async fn terminate(&mut self) -> Result<(), CaptureError> {
+    fn release(&mut self) -> io::Result<()> {
        Ok(())
    }
 }

 impl Stream for X11InputCapture {
-    type Item = Result<(Position, CaptureEvent), CaptureError>;
+    type Item = io::Result<(CaptureHandle, Event)>;

    fn poll_next(
        self: std::pin::Pin<&mut Self>,
--- a/input-emulation/Cargo.toml
+++ b/input-emulation/Cargo.toml
@@ -1,55 +1,36 @@
 [package]
 name = "input-emulation"
 description = "cross-platform input emulation library used by lan-mouse"
-version = "0.2.1"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
+repository = "https://github.com/ferdinandschober/lan-mouse"

 [dependencies]
+anyhow = "1.0.86"
 async-trait = "0.1.80"
 futures = "0.3.28"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.2.1" }
+input-event = { path = "../input-event", version = "0.1.0" }
 thiserror = "1.0.61"
-tokio = { version = "1.32.0", features = [
-    "io-util",
-    "io-std",
-    "macros",
-    "net",
-    "process",
-    "rt",
-    "sync",
-    "signal",
-] }
+tokio = { version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
 once_cell = "1.19.0"

 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-wayland-client = { version = "0.31.1", optional = true }
-wayland-protocols = { version = "0.32.1", features = [
-    "client",
-    "staging",
-    "unstable",
-], optional = true }
-wayland-protocols-wlr = { version = "0.3.1", features = [
-    "client",
-], optional = true }
-wayland-protocols-misc = { version = "0.3.1", features = [
-    "client",
-], optional = true }
+wayland-client = { version="0.31.1", optional = true }
+wayland-protocols = { version="0.32.1", features=["client", "staging", "unstable"], optional = true }
+wayland-protocols-wlr = { version="0.3.1", features=["client"], optional = true }
+wayland-protocols-misc = { version="0.3.1", features=["client"], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.9", default-features = false, features = [
-    "tokio",
-], optional = true }
-reis = { version = "0.2", features = ["tokio"], optional = true }
+ashpd = { version = "0.8", default-features = false, features = ["tokio"], optional = true }
+reis = { version = "0.2", features = [ "tokio" ], optional = true }

 [target.'cfg(target_os="macos")'.dependencies]
-bitflags = "2.5.0"
 core-graphics = { version = "0.23", features = ["highsierra"] }
 keycode = "0.4.0"

 [target.'cfg(windows)'.dependencies]
-windows = { version = "0.58.0", features = [
+windows = {  version = "0.57.0", features = [
    "Win32_System_LibraryLoader",
    "Win32_System_Threading",
    "Win32_Foundation",
@@ -61,12 +42,7 @@ windows = { version = "0.58.0", features = [

 [features]
 default = ["wayland", "x11", "xdg_desktop_portal", "libei"]
-wayland = [
-    "dep:wayland-client",
-    "dep:wayland-protocols",
-    "dep:wayland-protocols-wlr",
-    "dep:wayland-protocols-misc",
-]
+wayland = ["dep:wayland-client", "dep:wayland-protocols", "dep:wayland-protocols-wlr", "dep:wayland-protocols-misc" ]
 x11 = ["dep:x11"]
 xdg_desktop_portal = ["dep:ashpd"]
 libei = ["dep:reis", "dep:ashpd"]
--- a/input-emulation/src/dummy.rs
+++ b/input-emulation/src/dummy.rs
@@ -3,19 +3,19 @@ use input_event::Event;

 use crate::error::EmulationError;

-use super::{Emulation, EmulationHandle};
+use super::{EmulationHandle, InputEmulation};

 #[derive(Default)]
-pub(crate) struct DummyEmulation;
+pub struct DummyEmulation;

 impl DummyEmulation {
-    pub(crate) fn new() -> Self {
+    pub fn new() -> Self {
        Self {}
    }
 }

 #[async_trait]
-impl Emulation for DummyEmulation {
+impl InputEmulation for DummyEmulation {
    async fn consume(
        &mut self,
        event: Event,
@@ -26,7 +26,4 @@ impl Emulation for DummyEmulation {
    }
    async fn create(&mut self, _: EmulationHandle) {}
    async fn destroy(&mut self, _: EmulationHandle) {}
-    async fn terminate(&mut self) {
-        /* nothing to do */
-    }
 }
--- a/input-emulation/src/error.rs
+++ b/input-emulation/src/error.rs
@@ -1,18 +1,6 @@
-#[derive(Debug, Error)]
-pub enum InputEmulationError {
-    #[error("error creating input-emulation: `{0}`")]
-    Create(#[from] EmulationCreationError),
-    #[error("error emulating input: `{0}`")]
-    Emulate(#[from] EmulationError),
-}
+use std::{fmt::Display, io};

-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-use ashpd::{desktop::ResponseError, Error::Response};
-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-use reis::tokio::EiConvertEventStreamError;
-use std::io;
 use thiserror::Error;
-
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 use wayland_client::{
    backend::WaylandError,
@@ -23,30 +11,11 @@ use wayland_client::{
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use reis::tokio::HandshakeError;

-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-#[derive(Debug, Error)]
-#[error("error in libei stream: {inner:?}")]
-pub struct ReisConvertStreamError {
-    inner: EiConvertEventStreamError,
-}
-
-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-impl From<EiConvertEventStreamError> for ReisConvertStreamError {
-    fn from(e: EiConvertEventStreamError) -> Self {
-        Self { inner: e }
-    }
-}
-
 #[derive(Debug, Error)]
 pub enum EmulationError {
-    #[error("event stream closed")]
-    EndOfStream,
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
    #[error("libei error flushing events: `{0}`")]
    Libei(#[from] reis::event::Error),
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    #[error("")]
-    LibeiConvertStream(#[from] ReisConvertStreamError),
    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
    #[error("wayland error: `{0}`")]
    Wayland(#[from] wayland_client::backend::WaylandError),
@@ -64,77 +33,58 @@ pub enum EmulationError {
 #[derive(Debug, Error)]
 pub enum EmulationCreationError {
    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-    #[error("wlroots backend: `{0}`")]
    Wlroots(#[from] WlrootsEmulationCreationError),
    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    #[error("libei backend: `{0}`")]
    Libei(#[from] LibeiEmulationCreationError),
    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-    #[error("xdg-desktop-portal: `{0}`")]
    Xdp(#[from] XdpEmulationCreationError),
    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-    #[error("x11: `{0}`")]
    X11(#[from] X11EmulationCreationError),
    #[cfg(target_os = "macos")]
-    #[error("macos: `{0}`")]
    MacOs(#[from] MacOSEmulationCreationError),
    #[cfg(windows)]
-    #[error("windows: `{0}`")]
    Windows(#[from] WindowsEmulationCreationError),
-    #[error("capture error")]
    NoAvailableBackend,
 }

-impl EmulationCreationError {
-    /// request was intentionally denied by the user
-    pub(crate) fn cancelled_by_user(&self) -> bool {
-        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-        if matches!(
-            self,
-            EmulationCreationError::Libei(LibeiEmulationCreationError::Ashpd(Response(
-                ResponseError::Cancelled,
-            )))
-        ) {
-            return true;
-        }
-        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-        if matches!(
-            self,
-            EmulationCreationError::Xdp(XdpEmulationCreationError::Ashpd(Response(
-                ResponseError::Cancelled,
-            )))
-        ) {
-            return true;
-        }
-        false
+impl Display for EmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let reason = match self {
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            EmulationCreationError::Wlroots(e) => format!("wlroots backend: {e}"),
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            EmulationCreationError::Libei(e) => format!("libei backend: {e}"),
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            EmulationCreationError::Xdp(e) => format!("desktop portal backend: {e}"),
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            EmulationCreationError::X11(e) => format!("x11 backend: {e}"),
+            #[cfg(target_os = "macos")]
+            EmulationCreationError::MacOs(e) => format!("macos backend: {e}"),
+            #[cfg(windows)]
+            EmulationCreationError::Windows(e) => format!("windows backend: {e}"),
+            EmulationCreationError::NoAvailableBackend => "no backend available".to_string(),
+        };
+        write!(f, "could not create input emulation backend: {reason}")
    }
 }

 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum WlrootsEmulationCreationError {
-    #[error(transparent)]
    Connect(#[from] ConnectError),
-    #[error(transparent)]
    Global(#[from] GlobalError),
-    #[error(transparent)]
    Wayland(#[from] WaylandError),
-    #[error(transparent)]
    Bind(#[from] WaylandBindError),
-    #[error(transparent)]
    Dispatch(#[from] DispatchError),
-    #[error(transparent)]
    Io(#[from] std::io::Error),
 }

 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
-#[error("wayland protocol \"{protocol}\" not supported: {inner}")]
 pub struct WaylandBindError {
    inner: BindError,
    protocol: &'static str,
 }
-
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 impl WaylandBindError {
    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
@@ -142,38 +92,101 @@ impl WaylandBindError {
    }
 }

+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl Display for WaylandBindError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{} protocol not supported: {}",
+            self.protocol, self.inner
+        )
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl Display for WlrootsEmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            WlrootsEmulationCreationError::Bind(e) => write!(f, "{e}"),
+            WlrootsEmulationCreationError::Connect(e) => {
+                write!(f, "could not connect to wayland compositor: {e}")
+            }
+            WlrootsEmulationCreationError::Global(e) => write!(f, "wayland error: {e}"),
+            WlrootsEmulationCreationError::Wayland(e) => write!(f, "wayland error: {e}"),
+            WlrootsEmulationCreationError::Dispatch(e) => {
+                write!(f, "error dispatching wayland events: {e}")
+            }
+            WlrootsEmulationCreationError::Io(e) => write!(f, "io error: {e}"),
+        }
+    }
+}
+
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum LibeiEmulationCreationError {
-    #[error(transparent)]
    Ashpd(#[from] ashpd::Error),
-    #[error(transparent)]
    Io(#[from] std::io::Error),
-    #[error(transparent)]
    Handshake(#[from] HandshakeError),
 }

+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+impl Display for LibeiEmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LibeiEmulationCreationError::Ashpd(e) => write!(f, "xdg-desktop-portal: {e}"),
+            LibeiEmulationCreationError::Io(e) => write!(f, "io error: {e}"),
+            LibeiEmulationCreationError::Handshake(e) => write!(f, "error in libei handshake: {e}"),
+        }
+    }
+}
+
 #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum XdpEmulationCreationError {
-    #[error(transparent)]
    Ashpd(#[from] ashpd::Error),
 }

+#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+impl Display for XdpEmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            XdpEmulationCreationError::Ashpd(e) => write!(f, "portal error: {e}"),
+        }
+    }
+}
+
 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum X11EmulationCreationError {
-    #[error("could not open display")]
    OpenDisplay,
 }

+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+impl Display for X11EmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            X11EmulationCreationError::OpenDisplay => write!(f, "could not open display!"),
+        }
+    }
+}
+
 #[cfg(target_os = "macos")]
 #[derive(Debug, Error)]
 pub enum MacOSEmulationCreationError {
-    #[error("could not create event source")]
    EventSourceCreation,
 }

+#[cfg(target_os = "macos")]
+impl Display for MacOSEmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            MacOSEmulationCreationError::EventSourceCreation => {
+                write!(f, "could not create event source")
+            }
+        }
+    }
+}
+
 #[cfg(windows)]
 #[derive(Debug, Error)]
 pub enum WindowsEmulationCreationError {}
--- a/input-emulation/src/lib.rs
+++ b/input-emulation/src/lib.rs
@@ -1,34 +1,34 @@
 use async_trait::async_trait;
-use std::{
-    collections::{HashMap, HashSet},
-    fmt::Display,
-};
+use error::EmulationError;
+use std::fmt::Display;

-use input_event::{Event, KeyboardEvent};
+use input_event::Event;

-pub use self::error::{EmulationCreationError, EmulationError, InputEmulationError};
+use anyhow::Result;
+
+use self::error::EmulationCreationError;

 #[cfg(windows)]
-mod windows;
+pub mod windows;

 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-mod x11;
+pub mod x11;

 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-mod wlroots;
+pub mod wlroots;

 #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-mod xdg_desktop_portal;
+pub mod xdg_desktop_portal;

 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-mod libei;
+pub mod libei;

 #[cfg(target_os = "macos")]
-mod macos;
+pub mod macos;

 /// fallback input emulation (logs events)
-mod dummy;
-mod error;
+pub mod dummy;
+pub mod error;

 pub type EmulationHandle = u64;

@@ -69,166 +69,8 @@ impl Display for Backend {
    }
 }

-pub struct InputEmulation {
-    emulation: Box<dyn Emulation>,
-    handles: HashSet<EmulationHandle>,
-    pressed_keys: HashMap<EmulationHandle, HashSet<u32>>,
-}
-
-impl InputEmulation {
-    async fn with_backend(backend: Backend) -> Result<InputEmulation, EmulationCreationError> {
-        let emulation: Box<dyn Emulation> = match backend {
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-            Backend::Wlroots => Box::new(wlroots::WlrootsEmulation::new()?),
-            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-            Backend::Libei => Box::new(libei::LibeiEmulation::new().await?),
-            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-            Backend::X11 => Box::new(x11::X11Emulation::new()?),
-            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-            Backend::Xdp => Box::new(xdg_desktop_portal::DesktopPortalEmulation::new().await?),
-            #[cfg(windows)]
-            Backend::Windows => Box::new(windows::WindowsEmulation::new()?),
-            #[cfg(target_os = "macos")]
-            Backend::MacOs => Box::new(macos::MacOSEmulation::new()?),
-            Backend::Dummy => Box::new(dummy::DummyEmulation::new()),
-        };
-        Ok(Self {
-            emulation,
-            handles: HashSet::new(),
-            pressed_keys: HashMap::new(),
-        })
-    }
-
-    pub async fn new(backend: Option<Backend>) -> Result<InputEmulation, EmulationCreationError> {
-        if let Some(backend) = backend {
-            let b = Self::with_backend(backend).await;
-            if b.is_ok() {
-                log::info!("using emulation backend: {backend}");
-            }
-            return b;
-        }
-
-        for backend in [
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-            Backend::Wlroots,
-            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-            Backend::Libei,
-            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-            Backend::Xdp,
-            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-            Backend::X11,
-            #[cfg(windows)]
-            Backend::Windows,
-            #[cfg(target_os = "macos")]
-            Backend::MacOs,
-            Backend::Dummy,
-        ] {
-            match Self::with_backend(backend).await {
-                Ok(b) => {
-                    log::info!("using emulation backend: {backend}");
-                    return Ok(b);
-                }
-                Err(e) if e.cancelled_by_user() => return Err(e),
-                Err(e) => log::warn!("{e}"),
-            }
-        }
-
-        Err(EmulationCreationError::NoAvailableBackend)
-    }
-
-    pub async fn consume(
-        &mut self,
-        event: Event,
-        handle: EmulationHandle,
-    ) -> Result<(), EmulationError> {
-        match event {
-            Event::Keyboard(KeyboardEvent::Key { key, state, .. }) => {
-                // prevent double pressed / released keys
-                if self.update_pressed_keys(handle, key, state) {
-                    self.emulation.consume(event, handle).await?;
-                }
-                Ok(())
-            }
-            _ => self.emulation.consume(event, handle).await,
-        }
-    }
-
-    pub async fn create(&mut self, handle: EmulationHandle) -> bool {
-        if self.handles.insert(handle) {
-            self.pressed_keys.insert(handle, HashSet::new());
-            self.emulation.create(handle).await;
-            true
-        } else {
-            false
-        }
-    }
-
-    pub async fn destroy(&mut self, handle: EmulationHandle) {
-        let _ = self.release_keys(handle).await;
-        if self.handles.remove(&handle) {
-            self.pressed_keys.remove(&handle);
-            self.emulation.destroy(handle).await
-        }
-    }
-
-    pub async fn terminate(&mut self) {
-        for handle in self.handles.iter().cloned().collect::<Vec<_>>() {
-            self.destroy(handle).await
-        }
-        self.emulation.terminate().await
-    }
-
-    pub async fn release_keys(&mut self, handle: EmulationHandle) -> Result<(), EmulationError> {
-        if let Some(keys) = self.pressed_keys.get_mut(&handle) {
-            let keys = keys.drain().collect::<Vec<_>>();
-            for key in keys {
-                let event = Event::Keyboard(KeyboardEvent::Key {
-                    time: 0,
-                    key,
-                    state: 0,
-                });
-                self.emulation.consume(event, handle).await?;
-                if let Ok(key) = input_event::scancode::Linux::try_from(key) {
-                    log::warn!("releasing stuck key: {key:?}");
-                }
-            }
-        }
-
-        let event = Event::Keyboard(KeyboardEvent::Modifiers {
-            depressed: 0,
-            latched: 0,
-            locked: 0,
-            group: 0,
-        });
-        self.emulation.consume(event, handle).await?;
-        Ok(())
-    }
-
-    pub fn has_pressed_keys(&self, handle: EmulationHandle) -> bool {
-        self.pressed_keys
-            .get(&handle)
-            .is_some_and(|p| !p.is_empty())
-    }
-
-    /// update the pressed_keys for the given handle
-    /// returns whether the event should be processed
-    fn update_pressed_keys(&mut self, handle: EmulationHandle, key: u32, state: u8) -> bool {
-        let Some(pressed_keys) = self.pressed_keys.get_mut(&handle) else {
-            return false;
-        };
-
-        if state == 0 {
-            // currently pressed => can release
-            pressed_keys.remove(&key)
-        } else {
-            // currently not pressed => can press
-            pressed_keys.insert(key)
-        }
-    }
-}
-
 #[async_trait]
-trait Emulation: Send {
+pub trait InputEmulation: Send {
    async fn consume(
        &mut self,
        event: Event,
@@ -236,5 +78,64 @@ trait Emulation: Send {
    ) -> Result<(), EmulationError>;
    async fn create(&mut self, handle: EmulationHandle);
    async fn destroy(&mut self, handle: EmulationHandle);
-    async fn terminate(&mut self);
+}
+
+pub async fn create_backend(
+    backend: Backend,
+) -> Result<Box<dyn InputEmulation>, EmulationCreationError> {
+    match backend {
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Backend::Wlroots => Ok(Box::new(wlroots::WlrootsEmulation::new()?)),
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        Backend::Libei => Ok(Box::new(libei::LibeiEmulation::new().await?)),
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        Backend::X11 => Ok(Box::new(x11::X11Emulation::new()?)),
+        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+        Backend::Xdp => Ok(Box::new(
+            xdg_desktop_portal::DesktopPortalEmulation::new().await?,
+        )),
+        #[cfg(windows)]
+        Backend::Windows => Ok(Box::new(windows::WindowsEmulation::new()?)),
+        #[cfg(target_os = "macos")]
+        Backend::MacOs => Ok(Box::new(macos::MacOSEmulation::new()?)),
+        Backend::Dummy => Ok(Box::new(dummy::DummyEmulation::new())),
+    }
+}
+
+pub async fn create(
+    backend: Option<Backend>,
+) -> Result<Box<dyn InputEmulation>, EmulationCreationError> {
+    if let Some(backend) = backend {
+        let b = create_backend(backend).await;
+        if b.is_ok() {
+            log::info!("using emulation backend: {backend}");
+        }
+        return b;
+    }
+
+    for backend in [
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Backend::Wlroots,
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        Backend::Libei,
+        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+        Backend::Xdp,
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        Backend::X11,
+        #[cfg(windows)]
+        Backend::Windows,
+        #[cfg(target_os = "macos")]
+        Backend::MacOs,
+        Backend::Dummy,
+    ] {
+        match create_backend(backend).await {
+            Ok(b) => {
+                log::info!("using emulation backend: {backend}");
+                return Ok(b);
+            }
+            Err(e) => log::warn!("{e}"),
+        }
+    }
+
+    Err(EmulationCreationError::NoAvailableBackend)
 }
--- a/input-emulation/src/libei.rs
+++ b/input-emulation/src/libei.rs
@@ -1,12 +1,13 @@
-use futures::{future, StreamExt};
+use anyhow::{anyhow, Result};
+use futures::StreamExt;
 use once_cell::sync::Lazy;
 use std::{
    collections::HashMap,
    io,
    os::{fd::OwnedFd, unix::net::UnixStream},
    sync::{
-        atomic::{AtomicBool, AtomicU32, Ordering},
-        Arc, Mutex, RwLock,
+        atomic::{AtomicU32, Ordering},
+        Arc, RwLock,
    },
    time::{SystemTime, UNIX_EPOCH},
 };
@@ -15,7 +16,7 @@ use tokio::task::JoinHandle;
 use ashpd::{
    desktop::{
        remote_desktop::{DeviceType, RemoteDesktop},
-        PersistMode, Session,
+        ResponseError,
    },
    WindowIdentifier,
 };
@@ -32,9 +33,9 @@ use reis::{

 use input_event::{Event, KeyboardEvent, PointerEvent};

-use crate::error::{EmulationError, ReisConvertStreamError};
+use crate::error::EmulationError;

-use super::{error::LibeiEmulationCreationError, Emulation, EmulationHandle};
+use super::{error::LibeiEmulationCreationError, EmulationHandle, InputEmulation};

 static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
    let mut m = HashMap::new();
@@ -60,50 +61,51 @@ struct Devices {
    keyboard: Arc<RwLock<Option<(ei::Device, ei::Keyboard)>>>,
 }

-pub(crate) struct LibeiEmulation<'a> {
+pub struct LibeiEmulation {
    context: ei::Context,
    devices: Devices,
-    ei_task: JoinHandle<()>,
-    error: Arc<Mutex<Option<EmulationError>>>,
-    libei_error: Arc<AtomicBool>,
    serial: AtomicU32,
-    _remote_desktop: RemoteDesktop<'a>,
-    session: Session<'a, RemoteDesktop<'a>>,
+    ei_task: JoinHandle<Result<()>>,
 }

-async fn get_ei_fd<'a>(
-) -> Result<(RemoteDesktop<'a>, Session<'a, RemoteDesktop<'a>>, OwnedFd), ashpd::Error> {
-    let remote_desktop = RemoteDesktop::new().await?;
+async fn get_ei_fd() -> Result<OwnedFd, ashpd::Error> {
+    let proxy = RemoteDesktop::new().await?;

-    log::debug!("creating session ...");
-    let session = remote_desktop.create_session().await?;
+    // retry when user presses the cancel button
+    let (session, _) = loop {
+        log::debug!("creating session ...");
+        let session = proxy.create_session().await?;

-    log::debug!("selecting devices ...");
-    remote_desktop
-        .select_devices(
-            &session,
-            DeviceType::Keyboard | DeviceType::Pointer,
-            None,
-            PersistMode::ExplicitlyRevoked,
-        )
-        .await?;
+        log::debug!("selecting devices ...");
+        proxy
+            .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
+            .await?;

-    log::info!("requesting permission for input emulation");
-    let _devices = remote_desktop
-        .start(&session, &WindowIdentifier::default())
-        .await?
-        .response()?;
+        log::info!("requesting permission for input emulation");
+        match proxy
+            .start(&session, &WindowIdentifier::default())
+            .await?
+            .response()
+        {
+            Ok(d) => break (session, d),
+            Err(ashpd::Error::Response(ResponseError::Cancelled)) => {
+                log::warn!("request cancelled!");
+                continue;
+            }
+            e => e?,
+        };
+    };

-    let fd = remote_desktop.connect_to_eis(&session).await?;
-    Ok((remote_desktop, session, fd))
+    proxy.connect_to_eis(&session).await
 }

-impl<'a> LibeiEmulation<'a> {
-    pub(crate) async fn new() -> Result<Self, LibeiEmulationCreationError> {
-        let (_remote_desktop, session, eifd) = get_ei_fd().await?;
+impl LibeiEmulation {
+    pub async fn new() -> Result<Self, LibeiEmulationCreationError> {
+        let eifd = get_ei_fd().await?;
        let stream = UnixStream::from(eifd);
        stream.set_nonblocking(true)?;
        let context = ei::Context::new(stream)?;
+        context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
        let mut events = EiEventStream::new(context.clone())?;
        let handshake = ei_handshake(
            &mut events,
@@ -114,40 +116,28 @@ impl<'a> LibeiEmulation<'a> {
        .await?;
        let events = EiConvertEventStream::new(events, handshake.serial);
        let devices = Devices::default();
-        let libei_error = Arc::new(AtomicBool::default());
-        let error = Arc::new(Mutex::new(None));
-        let ei_handler = ei_task(
-            events,
-            context.clone(),
-            devices.clone(),
-            libei_error.clone(),
-            error.clone(),
-        );
-        let ei_task = tokio::task::spawn_local(ei_handler);
+        let ei_task =
+            tokio::task::spawn_local(ei_event_handler(events, context.clone(), devices.clone()));

        let serial = AtomicU32::new(handshake.serial);

        Ok(Self {
-            context,
-            devices,
-            ei_task,
-            error,
-            libei_error,
            serial,
-            _remote_desktop,
-            session,
+            context,
+            ei_task,
+            devices,
        })
    }
 }

-impl<'a> Drop for LibeiEmulation<'a> {
+impl Drop for LibeiEmulation {
    fn drop(&mut self) {
        self.ei_task.abort();
    }
 }

 #[async_trait]
-impl<'a> Emulation for LibeiEmulation<'a> {
+impl InputEmulation for LibeiEmulation {
    async fn consume(
        &mut self,
        event: Event,
@@ -157,18 +147,16 @@ impl<'a> Emulation for LibeiEmulation<'a> {
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_micros() as u64;
-        if self.libei_error.load(Ordering::SeqCst) {
-            // don't break sending additional events but signal error
-            if let Some(e) = self.error.lock().unwrap().take() {
-                return Err(e);
-            }
-        }
        match event {
            Event::Pointer(p) => match p {
-                PointerEvent::Motion { time: _, dx, dy } => {
+                PointerEvent::Motion {
+                    time: _,
+                    relative_x,
+                    relative_y,
+                } => {
                    let pointer_device = self.devices.pointer.read().unwrap();
                    if let Some((d, p)) = pointer_device.as_ref() {
-                        p.motion_relative(dx as f32, dy as f32);
+                        p.motion_relative(relative_x as f32, relative_y as f32);
                        d.frame(self.serial.load(Ordering::SeqCst), now);
                    }
                }
@@ -213,6 +201,7 @@ impl<'a> Emulation for LibeiEmulation<'a> {
                        d.frame(self.serial.load(Ordering::SeqCst), now);
                    }
                }
+                PointerEvent::Frame {} => {}
            },
            Event::Keyboard(k) => match k {
                KeyboardEvent::Key {
@@ -234,6 +223,7 @@ impl<'a> Emulation for LibeiEmulation<'a> {
                }
                KeyboardEvent::Modifiers { .. } => {}
            },
+            _ => {}
        }
        self.context
            .flush()
@@ -243,44 +233,19 @@ impl<'a> Emulation for LibeiEmulation<'a> {

    async fn create(&mut self, _: EmulationHandle) {}
    async fn destroy(&mut self, _: EmulationHandle) {}
-
-    async fn terminate(&mut self) {
-        let _ = self.session.close().await;
-        self.ei_task.abort();
-    }
-}
-
-async fn ei_task(
-    mut events: EiConvertEventStream,
-    context: ei::Context,
-    devices: Devices,
-    libei_error: Arc<AtomicBool>,
-    error: Arc<Mutex<Option<EmulationError>>>,
-) {
-    loop {
-        match ei_event_handler(&mut events, &context, &devices).await {
-            Ok(()) => {}
-            Err(e) => {
-                libei_error.store(true, Ordering::SeqCst);
-                error.lock().unwrap().replace(e);
-                // wait for termination -> otherwise we will loop forever
-                future::pending::<()>().await;
-            }
-        }
-    }
 }

 async fn ei_event_handler(
-    events: &mut EiConvertEventStream,
-    context: &ei::Context,
-    devices: &Devices,
-) -> Result<(), EmulationError> {
+    mut events: EiConvertEventStream,
+    context: ei::Context,
+    devices: Devices,
+) -> Result<()> {
    loop {
        let event = events
            .next()
            .await
-            .ok_or(EmulationError::EndOfStream)?
-            .map_err(ReisConvertStreamError::from)?;
+            .ok_or(anyhow!("ei stream closed"))?
+            .map_err(|e| anyhow!("libei error: {e:?}"))?;
        const CAPABILITIES: &[DeviceCapability] = &[
            DeviceCapability::Pointer,
            DeviceCapability::PointerAbsolute,
@@ -293,7 +258,7 @@ async fn ei_event_handler(
        match event {
            EiEvent::Disconnected(e) => {
                log::debug!("ei disconnected: {e:?}");
-                return Err(EmulationError::EndOfStream);
+                break;
            }
            EiEvent::SeatAdded(e) => {
                e.seat().bind_capabilities(CAPABILITIES);
@@ -365,6 +330,7 @@ async fn ei_event_handler(
            // EiEvent::TouchMotion(_) => { },
            _ => unreachable!("unexpected ei event"),
        }
-        context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
+        context.flush()?;
    }
+    Ok(())
 }
--- a/input-emulation/src/macos.rs
+++ b/input-emulation/src/macos.rs
@@ -1,35 +1,25 @@
-use super::{error::EmulationError, Emulation, EmulationHandle};
+use super::{error::EmulationError, EmulationHandle, InputEmulation};
 use async_trait::async_trait;
-use bitflags::bitflags;
-use core_graphics::base::CGFloat;
-use core_graphics::display::{
-    CGDirectDisplayID, CGDisplayBounds, CGGetDisplaysWithRect, CGPoint, CGRect, CGSize,
-};
+use core_graphics::display::{CGDisplayBounds, CGMainDisplayID, CGPoint};
 use core_graphics::event::{
-    CGEvent, CGEventFlags, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField,
-    ScrollEventUnit,
+    CGEvent, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField, ScrollEventUnit,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
-use input_event::{scancode, Event, KeyboardEvent, PointerEvent};
+use input_event::{Event, KeyboardEvent, PointerEvent};
 use keycode::{KeyMap, KeyMapping};
-use std::cell::Cell;
 use std::ops::{Index, IndexMut};
-use std::rc::Rc;
-use std::sync::Arc;
 use std::time::Duration;
-use tokio::{sync::Notify, task::JoinHandle};
+use tokio::task::AbortHandle;

 use super::error::MacOSEmulationCreationError;

 const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
 const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);

-pub(crate) struct MacOSEmulation {
-    event_source: CGEventSource,
-    repeat_task: Option<JoinHandle<()>>,
+pub struct MacOSEmulation {
+    pub event_source: CGEventSource,
+    repeat_task: Option<AbortHandle>,
    button_state: ButtonState,
-    modifier_state: Rc<Cell<XMods>>,
-    notify_repeat_task: Arc<Notify>,
 }

 struct ButtonState {
@@ -63,7 +53,7 @@ impl IndexMut<CGMouseButton> for ButtonState {
 unsafe impl Send for MacOSEmulation {}

 impl MacOSEmulation {
-    pub(crate) fn new() -> Result<Self, MacOSEmulationCreationError> {
+    pub fn new() -> Result<Self, MacOSEmulationCreationError> {
        let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
            .map_err(|_| MacOSEmulationCreationError::EventSourceCreation)?;
        let button_state = ButtonState {
@@ -75,8 +65,6 @@ impl MacOSEmulation {
            event_source,
            button_state,
            repeat_task: None,
-            notify_repeat_task: Arc::new(Notify::new()),
-            modifier_state: Rc::new(Cell::new(XMods::empty())),
        })
    }

@@ -88,40 +76,25 @@ impl MacOSEmulation {
    async fn spawn_repeat_task(&mut self, key: u16) {
        // there can only be one repeating key and it's
        // always the last to be pressed
-        self.cancel_repeat_task().await;
+        self.kill_repeat_task();
        let event_source = self.event_source.clone();
-        let notify = self.notify_repeat_task.clone();
-        let modifiers = self.modifier_state.clone();
        let repeat_task = tokio::task::spawn_local(async move {
-            let stop = tokio::select! {
-                _ = tokio::time::sleep(DEFAULT_REPEAT_DELAY) => false,
-                _ = notify.notified() => true,
-            };
-            if !stop {
-                loop {
-                    key_event(event_source.clone(), key, 1, modifiers.get());
-                    tokio::select! {
-                        _ = tokio::time::sleep(DEFAULT_REPEAT_INTERVAL) => {},
-                        _ = notify.notified() => break,
-                    }
-                }
+            tokio::time::sleep(DEFAULT_REPEAT_DELAY).await;
+            loop {
+                key_event(event_source.clone(), key, 1);
+                tokio::time::sleep(DEFAULT_REPEAT_INTERVAL).await;
            }
-            // release key when cancelled
-            update_modifiers(&modifiers, key as u32, 0);
-            key_event(event_source.clone(), key, 0, modifiers.get());
        });
-        self.repeat_task = Some(repeat_task);
+        self.repeat_task = Some(repeat_task.abort_handle());
    }
-
-    async fn cancel_repeat_task(&mut self) {
+    fn kill_repeat_task(&mut self) {
        if let Some(task) = self.repeat_task.take() {
-            self.notify_repeat_task.notify_waiters();
-            let _ = task.await;
+            task.abort();
        }
    }
 }

-fn key_event(event_source: CGEventSource, key: u16, state: u8, modifiers: XMods) {
+fn key_event(event_source: CGEventSource, key: u16, state: u8) {
    let event = match CGEvent::new_keyboard_event(event_source, key, state != 0) {
        Ok(e) => e,
        Err(_) => {
@@ -129,96 +102,11 @@ fn key_event(event_source: CGEventSource, key: u16, state: u8, modifiers: XMods)
            return;
        }
    };
-    event.set_flags(to_cgevent_flags(modifiers));
    event.post(CGEventTapLocation::HID);
-    log::trace!("key event: {key} {state}");
-}
-
-fn modifier_event(event_source: CGEventSource, depressed: XMods) {
-    let Ok(event) = CGEvent::new(event_source) else {
-        log::warn!("could not create CGEvent");
-        return;
-    };
-    let flags = to_cgevent_flags(depressed);
-    event.set_type(CGEventType::FlagsChanged);
-    event.set_flags(flags);
-    event.post(CGEventTapLocation::HID);
-    log::trace!("modifiers updated: {depressed:?}");
-}
-
-fn get_display_at_point(x: CGFloat, y: CGFloat) -> Option<CGDirectDisplayID> {
-    let mut displays: [CGDirectDisplayID; 16] = [0; 16];
-    let mut display_count: u32 = 0;
-    let rect = CGRect::new(&CGPoint::new(x, y), &CGSize::new(0.0, 0.0));
-
-    let error = unsafe {
-        CGGetDisplaysWithRect(
-            rect,
-            1,
-            displays.as_mut_ptr(),
-            &mut display_count as *mut u32,
-        )
-    };
-
-    if error != 0 {
-        log::warn!("error getting displays at point ({}, {}): {}", x, y, error);
-        return Option::None;
-    }
-
-    if display_count == 0 {
-        log::debug!("no displays found at point ({}, {})", x, y);
-        return Option::None;
-    }
-
-    return displays.first().copied();
-}
-
-fn get_display_bounds(display: CGDirectDisplayID) -> (CGFloat, CGFloat, CGFloat, CGFloat) {
-    unsafe {
-        let bounds = CGDisplayBounds(display);
-        let min_x = bounds.origin.x;
-        let max_x = bounds.origin.x + bounds.size.width;
-        let min_y = bounds.origin.y;
-        let max_y = bounds.origin.y + bounds.size.height;
-        (min_x as f64, min_y as f64, max_x as f64, max_y as f64)
-    }
-}
-
-fn clamp_to_screen_space(
-    current_x: CGFloat,
-    current_y: CGFloat,
-    dx: CGFloat,
-    dy: CGFloat,
-) -> (CGFloat, CGFloat) {
-    // Check which display the mouse is currently on
-    // Determine what the location of the mouse would be after applying the move
-    // Get the display at the new location
-    // If the point is not on a display
-    //   Clamp the mouse to the current display
-    // Else If the point is on a display
-    //   Clamp the mouse to the new display
-    let current_display = match get_display_at_point(current_x, current_y) {
-        Some(display) => display,
-        None => {
-            log::warn!("could not get current display!");
-            return (current_x, current_y);
-        }
-    };
-
-    let new_x = current_x + dx;
-    let new_y = current_y + dy;
-
-    let final_display = get_display_at_point(new_x, new_y).unwrap_or(current_display);
-    let (min_x, min_y, max_x, max_y) = get_display_bounds(final_display);
-
-    (
-        new_x.clamp(min_x, max_x - 1.),
-        new_y.clamp(min_y, max_y - 1.),
-    )
 }

 #[async_trait]
-impl Emulation for MacOSEmulation {
+impl InputEmulation for MacOSEmulation {
    async fn consume(
        &mut self,
        event: Event,
@@ -226,7 +114,21 @@ impl Emulation for MacOSEmulation {
    ) -> Result<(), EmulationError> {
        match event {
            Event::Pointer(pointer_event) => match pointer_event {
-                PointerEvent::Motion { time: _, dx, dy } => {
+                PointerEvent::Motion {
+                    time: _,
+                    relative_x,
+                    relative_y,
+                } => {
+                    // FIXME secondary displays?
+                    let (min_x, min_y, max_x, max_y) = unsafe {
+                        let display = CGMainDisplayID();
+                        let bounds = CGDisplayBounds(display);
+                        let min_x = bounds.origin.x;
+                        let max_x = bounds.origin.x + bounds.size.width;
+                        let min_y = bounds.origin.y;
+                        let max_y = bounds.origin.y + bounds.size.height;
+                        (min_x as f64, min_y as f64, max_x as f64, max_y as f64)
+                    };
                    let mut mouse_location = match self.get_mouse_location() {
                        Some(l) => l,
                        None => {
@@ -235,11 +137,8 @@ impl Emulation for MacOSEmulation {
                        }
                    };

-                    let (new_mouse_x, new_mouse_y) =
-                        clamp_to_screen_space(mouse_location.x, mouse_location.y, dx, dy);
-
-                    mouse_location.x = new_mouse_x;
-                    mouse_location.y = new_mouse_y;
+                    mouse_location.x = (mouse_location.x + relative_x).clamp(min_x, max_x - 1.);
+                    mouse_location.y = (mouse_location.y + relative_y).clamp(min_y, max_y - 1.);

                    let mut event_type = CGEventType::MouseMoved;
                    if self.button_state.left {
@@ -261,8 +160,14 @@ impl Emulation for MacOSEmulation {
                            return Ok(());
                        }
                    };
-                    event.set_integer_value_field(EventField::MOUSE_EVENT_DELTA_X, dx as i64);
-                    event.set_integer_value_field(EventField::MOUSE_EVENT_DELTA_Y, dy as i64);
+                    event.set_integer_value_field(
+                        EventField::MOUSE_EVENT_DELTA_X,
+                        relative_x as i64,
+                    );
+                    event.set_integer_value_field(
+                        EventField::MOUSE_EVENT_DELTA_Y,
+                        relative_y as i64,
+                    );
                    event.post(CGEventTapLocation::HID);
                }
                PointerEvent::Button {
@@ -367,6 +272,7 @@ impl Emulation for MacOSEmulation {
                    };
                    event.post(CGEventTapLocation::HID);
                }
+                PointerEvent::Frame { .. } => {}
            },
            Event::Keyboard(keyboard_event) => match keyboard_event {
                KeyboardEvent::Key {
@@ -384,26 +290,13 @@ impl Emulation for MacOSEmulation {
                    match state {
                        // pressed
                        1 => self.spawn_repeat_task(code).await,
-                        _ => self.cancel_repeat_task().await,
+                        _ => self.kill_repeat_task(),
                    }
-                    update_modifiers(&self.modifier_state, key, state);
-                    key_event(
-                        self.event_source.clone(),
-                        code,
-                        state,
-                        self.modifier_state.get(),
-                    );
-                }
-                KeyboardEvent::Modifiers {
-                    depressed,
-                    latched,
-                    locked,
-                    group,
-                } => {
-                    set_modifiers(&self.modifier_state, depressed, latched, locked, group);
-                    modifier_event(self.event_source.clone(), self.modifier_state.get());
+                    key_event(self.event_source.clone(), code, state)
                }
+                KeyboardEvent::Modifiers { .. } => {}
            },
+            _ => (),
        }
        // FIXME
        Ok(())
@@ -412,84 +305,4 @@ impl Emulation for MacOSEmulation {
    async fn create(&mut self, _handle: EmulationHandle) {}

    async fn destroy(&mut self, _handle: EmulationHandle) {}
-
-    async fn terminate(&mut self) {}
-}
-
-fn update_modifiers(modifiers: &Cell<XMods>, key: u32, state: u8) -> bool {
-    if let Ok(key) = scancode::Linux::try_from(key) {
-        let mask = match key {
-            scancode::Linux::KeyLeftShift | scancode::Linux::KeyRightShift => XMods::ShiftMask,
-            scancode::Linux::KeyCapsLock => XMods::LockMask,
-            scancode::Linux::KeyLeftCtrl | scancode::Linux::KeyRightCtrl => XMods::ControlMask,
-            scancode::Linux::KeyLeftAlt | scancode::Linux::KeyRightalt => XMods::Mod1Mask,
-            scancode::Linux::KeyLeftMeta | scancode::Linux::KeyRightmeta => XMods::Mod4Mask,
-            _ => XMods::empty(),
-        };
-        // unchanged
-        if mask.is_empty() {
-            return false;
-        }
-        let mut mods = modifiers.get();
-        match state {
-            1 => mods.insert(mask),
-            _ => mods.remove(mask),
-        }
-        modifiers.set(mods);
-        true
-    } else {
-        false
-    }
-}
-
-fn set_modifiers(
-    active_modifiers: &Cell<XMods>,
-    depressed: u32,
-    latched: u32,
-    locked: u32,
-    group: u32,
-) {
-    let depressed = XMods::from_bits(depressed).unwrap_or_default();
-    let _latched = XMods::from_bits(latched).unwrap_or_default();
-    let _locked = XMods::from_bits(locked).unwrap_or_default();
-    let _group = XMods::from_bits(group).unwrap_or_default();
-
-    // we only care about the depressed modifiers for now
-    active_modifiers.replace(depressed);
-}
-
-fn to_cgevent_flags(depressed: XMods) -> CGEventFlags {
-    let mut flags = CGEventFlags::empty();
-    if depressed.contains(XMods::ShiftMask) {
-        flags |= CGEventFlags::CGEventFlagShift;
-    }
-    if depressed.contains(XMods::LockMask) {
-        flags |= CGEventFlags::CGEventFlagAlphaShift;
-    }
-    if depressed.contains(XMods::ControlMask) {
-        flags |= CGEventFlags::CGEventFlagControl;
-    }
-    if depressed.contains(XMods::Mod1Mask) {
-        flags |= CGEventFlags::CGEventFlagAlternate;
-    }
-    if depressed.contains(XMods::Mod4Mask) {
-        flags |= CGEventFlags::CGEventFlagCommand;
-    }
-    flags
-}
-
-// From X11/X.h
-bitflags! {
-    #[repr(C)]
-    #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-    struct XMods: u32 {
-        const ShiftMask = (1<<0);
-        const LockMask = (1<<1);
-        const ControlMask = (1<<2);
-        const Mod1Mask = (1<<3);
-        const Mod2Mask = (1<<4);
-        const Mod3Mask = (1<<5);
-        const Mod4Mask = (1<<6);
-        const Mod5Mask = (1<<7);
-    }
 }
--- a/input-emulation/src/windows.rs
+++ b/input-emulation/src/windows.rs
@@ -19,28 +19,32 @@ use windows::Win32::UI::Input::KeyboardAndMouse::{
 };
 use windows::Win32::UI::WindowsAndMessaging::{XBUTTON1, XBUTTON2};

-use super::{Emulation, EmulationHandle};
+use super::{EmulationHandle, InputEmulation};

 const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
 const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);

-pub(crate) struct WindowsEmulation {
+pub struct WindowsEmulation {
    repeat_task: Option<AbortHandle>,
 }

 impl WindowsEmulation {
-    pub(crate) fn new() -> Result<Self, WindowsEmulationCreationError> {
+    pub fn new() -> Result<Self, WindowsEmulationCreationError> {
        Ok(Self { repeat_task: None })
    }
 }

 #[async_trait]
-impl Emulation for WindowsEmulation {
+impl InputEmulation for WindowsEmulation {
    async fn consume(&mut self, event: Event, _: EmulationHandle) -> Result<(), EmulationError> {
        match event {
            Event::Pointer(pointer_event) => match pointer_event {
-                PointerEvent::Motion { time: _, dx, dy } => {
-                    rel_mouse(dx as i32, dy as i32);
+                PointerEvent::Motion {
+                    time: _,
+                    relative_x,
+                    relative_y,
+                } => {
+                    rel_mouse(relative_x as i32, relative_y as i32);
                }
                PointerEvent::Button {
                    time: _,
@@ -53,6 +57,7 @@ impl Emulation for WindowsEmulation {
                    value,
                } => scroll(axis, value as i32),
                PointerEvent::AxisDiscrete120 { axis, value } => scroll(axis, value),
+                PointerEvent::Frame {} => {}
            },
            Event::Keyboard(keyboard_event) => match keyboard_event {
                KeyboardEvent::Key {
@@ -70,6 +75,7 @@ impl Emulation for WindowsEmulation {
                }
                KeyboardEvent::Modifiers { .. } => {}
            },
+            _ => {}
        }
        // FIXME
        Ok(())
@@ -78,8 +84,6 @@ impl Emulation for WindowsEmulation {
    async fn create(&mut self, _handle: EmulationHandle) {}

    async fn destroy(&mut self, _handle: EmulationHandle) {}
-
-    async fn terminate(&mut self) {}
 }

 impl WindowsEmulation {
--- a/input-emulation/src/wlroots.rs
+++ b/input-emulation/src/wlroots.rs
@@ -1,6 +1,6 @@
 use crate::error::EmulationError;

-use super::{error::WlrootsEmulationCreationError, Emulation};
+use super::{error::WlrootsEmulationCreationError, InputEmulation};
 use async_trait::async_trait;
 use std::collections::HashMap;
 use std::io;
@@ -50,7 +50,7 @@ pub(crate) struct WlrootsEmulation {
 }

 impl WlrootsEmulation {
-    pub(crate) fn new() -> Result<Self, WlrootsEmulationCreationError> {
+    pub fn new() -> Result<Self, WlrootsEmulationCreationError> {
        let conn = Connection::connect_to_env()?;
        let (globals, queue) = registry_queue_init::<State>(&conn)?;
        let qh = queue.handle();
@@ -116,7 +116,7 @@ impl State {
 }

 #[async_trait]
-impl Emulation for WlrootsEmulation {
+impl InputEmulation for WlrootsEmulation {
    async fn consume(
        &mut self,
        event: Event,
@@ -165,9 +165,6 @@ impl Emulation for WlrootsEmulation {
            log::error!("{}", e);
        }
    }
-    async fn terminate(&mut self) {
-        /* nothing to do */
-    }
 }

 struct VirtualInput {
@@ -180,7 +177,11 @@ impl VirtualInput {
        match event {
            Event::Pointer(e) => {
                match e {
-                    PointerEvent::Motion { time, dx, dy } => self.pointer.motion(time, dx, dy),
+                    PointerEvent::Motion {
+                        time,
+                        relative_x,
+                        relative_y,
+                    } => self.pointer.motion(time, relative_x, relative_y),
                    PointerEvent::Button {
                        time,
                        button,
@@ -200,6 +201,7 @@ impl VirtualInput {
                            .axis_discrete(0, axis, value as f64 / 6., value / 120);
                        self.pointer.frame();
                    }
+                    PointerEvent::Frame {} => self.pointer.frame(),
                }
                self.pointer.frame();
            }
@@ -208,15 +210,16 @@ impl VirtualInput {
                    self.keyboard.key(time, key, state as u32);
                }
                KeyboardEvent::Modifiers {
-                    depressed: mods_depressed,
-                    latched: mods_latched,
-                    locked: mods_locked,
+                    mods_depressed,
+                    mods_latched,
+                    mods_locked,
                    group,
                } => {
                    self.keyboard
                        .modifiers(mods_depressed, mods_latched, mods_locked, group);
                }
            },
+            _ => {}
        }
        Ok(())
    }
--- a/input-emulation/src/x11.rs
+++ b/input-emulation/src/x11.rs
@@ -11,16 +11,16 @@ use input_event::{

 use crate::error::EmulationError;

-use super::{error::X11EmulationCreationError, Emulation, EmulationHandle};
+use super::{error::X11EmulationCreationError, EmulationHandle, InputEmulation};

-pub(crate) struct X11Emulation {
+pub struct X11Emulation {
    display: *mut xlib::Display,
 }

 unsafe impl Send for X11Emulation {}

 impl X11Emulation {
-    pub(crate) fn new() -> Result<Self, X11EmulationCreationError> {
+    pub fn new() -> Result<Self, X11EmulationCreationError> {
        let display = unsafe {
            match xlib::XOpenDisplay(ptr::null()) {
                d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => {
@@ -99,12 +99,16 @@ impl Drop for X11Emulation {
 }

 #[async_trait]
-impl Emulation for X11Emulation {
+impl InputEmulation for X11Emulation {
    async fn consume(&mut self, event: Event, _: EmulationHandle) -> Result<(), EmulationError> {
        match event {
            Event::Pointer(pointer_event) => match pointer_event {
-                PointerEvent::Motion { time: _, dx, dy } => {
-                    self.relative_motion(dx as i32, dy as i32);
+                PointerEvent::Motion {
+                    time: _,
+                    relative_x,
+                    relative_y,
+                } => {
+                    self.relative_motion(relative_x as i32, relative_y as i32);
                }
                PointerEvent::Button {
                    time: _,
@@ -123,6 +127,7 @@ impl Emulation for X11Emulation {
                PointerEvent::AxisDiscrete120 { axis, value } => {
                    self.emulate_scroll(axis, value as f64);
                }
+                PointerEvent::Frame {} => {}
            },
            Event::Keyboard(KeyboardEvent::Key {
                time: _,
@@ -147,8 +152,4 @@ impl Emulation for X11Emulation {
    async fn destroy(&mut self, _: EmulationHandle) {
        // for our purposes it does not matter what client sent the event
    }
-
-    async fn terminate(&mut self) {
-        /* nothing to do */
-    }
 }
--- a/input-emulation/src/xdg_desktop_portal.rs
+++ b/input-emulation/src/xdg_desktop_portal.rs
@@ -1,7 +1,8 @@
+use anyhow::Result;
 use ashpd::{
    desktop::{
        remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
-        PersistMode, Session,
+        ResponseError, Session,
    },
    zbus::AsyncDrop,
    WindowIdentifier,
@@ -16,37 +17,42 @@ use input_event::{

 use crate::error::EmulationError;

-use super::{error::XdpEmulationCreationError, Emulation, EmulationHandle};
+use super::{error::XdpEmulationCreationError, EmulationHandle, InputEmulation};

-pub(crate) struct DesktopPortalEmulation<'a> {
+pub struct DesktopPortalEmulation<'a> {
    proxy: RemoteDesktop<'a>,
-    session: Session<'a, RemoteDesktop<'a>>,
+    session: Session<'a>,
 }

 impl<'a> DesktopPortalEmulation<'a> {
-    pub(crate) async fn new() -> Result<DesktopPortalEmulation<'a>, XdpEmulationCreationError> {
+    pub async fn new() -> Result<DesktopPortalEmulation<'a>, XdpEmulationCreationError> {
        log::debug!("connecting to org.freedesktop.portal.RemoteDesktop portal ...");
        let proxy = RemoteDesktop::new().await?;

        // retry when user presses the cancel button
-        log::debug!("creating session ...");
-        let session = proxy.create_session().await?;
+        let (session, _) = loop {
+            log::debug!("creating session ...");
+            let session = proxy.create_session().await?;

-        log::debug!("selecting devices ...");
-        proxy
-            .select_devices(
-                &session,
-                DeviceType::Keyboard | DeviceType::Pointer,
-                None,
-                PersistMode::ExplicitlyRevoked,
-            )
-            .await?;
+            log::debug!("selecting devices ...");
+            proxy
+                .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
+                .await?;

-        log::info!("requesting permission for input emulation");
-        let _devices = proxy
-            .start(&session, &WindowIdentifier::default())
-            .await?
-            .response()?;
+            log::info!("requesting permission for input emulation");
+            match proxy
+                .start(&session, &WindowIdentifier::default())
+                .await?
+                .response()
+            {
+                Ok(d) => break (session, d),
+                Err(ashpd::Error::Response(ResponseError::Cancelled)) => {
+                    log::warn!("request cancelled!");
+                    continue;
+                }
+                e => e?,
+            };
+        };

        log::debug!("started session");
        let session = session;
@@ -56,7 +62,7 @@ impl<'a> DesktopPortalEmulation<'a> {
 }

 #[async_trait]
-impl<'a> Emulation for DesktopPortalEmulation<'a> {
+impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
    async fn consume(
        &mut self,
        event: input_event::Event,
@@ -64,9 +70,13 @@ impl<'a> Emulation for DesktopPortalEmulation<'a> {
    ) -> Result<(), EmulationError> {
        match event {
            Pointer(p) => match p {
-                PointerEvent::Motion { time: _, dx, dy } => {
+                PointerEvent::Motion {
+                    time: _,
+                    relative_x,
+                    relative_y,
+                } => {
                    self.proxy
-                        .notify_pointer_motion(&self.session, dx, dy)
+                        .notify_pointer_motion(&self.session, relative_x, relative_y)
                        .await?;
                }
                PointerEvent::Button {
@@ -88,7 +98,7 @@ impl<'a> Emulation for DesktopPortalEmulation<'a> {
                        _ => Axis::Horizontal,
                    };
                    self.proxy
-                        .notify_pointer_axis_discrete(&self.session, axis, value / 120)
+                        .notify_pointer_axis_discrete(&self.session, axis, value)
                        .await?;
                }
                PointerEvent::Axis {
@@ -108,6 +118,7 @@ impl<'a> Emulation for DesktopPortalEmulation<'a> {
                        .notify_pointer_axis(&self.session, dx, dy, true)
                        .await?;
                }
+                PointerEvent::Frame {} => {}
            },
            Keyboard(k) => {
                match k {
@@ -129,20 +140,13 @@ impl<'a> Emulation for DesktopPortalEmulation<'a> {
                    }
                }
            }
+            _ => {}
        }
        Ok(())
    }

    async fn create(&mut self, _client: EmulationHandle) {}
    async fn destroy(&mut self, _client: EmulationHandle) {}
-    async fn terminate(&mut self) {
-        if let Err(e) = self.session.close().await {
-            log::warn!("session.close(): {e}");
-        };
-        if let Err(e) = self.session.receive_closed().await {
-            log::warn!("session.receive_closed(): {e}");
-        };
-    }
 }

 impl<'a> AsyncDrop for DesktopPortalEmulation<'a> {
--- a/input-event/Cargo.toml
+++ b/input-event/Cargo.toml
@@ -1,21 +1,14 @@
 [package]
 name = "input-event"
 description = "cross-platform input-event types for input-capture / input-emulation"
-version = "0.2.1"
+version = "0.1.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
+repository = "https://github.com/ferdinandschober/lan-mouse"

 [dependencies]
+anyhow = "1.0.86"
 futures-core = "0.3.30"
 log = "0.4.22"
 num_enum = "0.7.2"
 serde = { version = "1.0", features = ["derive"] }
-thiserror = "1.0.61"
-
-[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-reis = { version = "0.2.0", optional = true }
-
-[features]
-default = ["libei"]
-libei = ["dep:reis"]
--- a/input-event/src/error.rs
+++ b/input-event/src/error.rs
@@ -1 +0,0 @@
-
--- a/input-event/src/lib.rs
+++ b/input-event/src/lib.rs
@@ -1,11 +1,11 @@
-use std::fmt::{self, Display};
+use anyhow::{anyhow, Result};
+use std::{
+    error::Error,
+    fmt::{self, Display},
+};

-pub mod error;
 pub mod scancode;

-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-mod libei;
-
 // FIXME
 pub const BTN_LEFT: u32 = 0x110;
 pub const BTN_RIGHT: u32 = 0x111;
@@ -15,25 +15,39 @@ pub const BTN_FORWARD: u32 = 0x114;

 #[derive(Debug, PartialEq, Clone, Copy)]
 pub enum PointerEvent {
-    /// relative motion event
-    Motion { time: u32, dx: f64, dy: f64 },
-    /// mouse button event
-    Button { time: u32, button: u32, state: u32 },
-    /// axis event, scroll event for touchpads
-    Axis { time: u32, axis: u8, value: f64 },
-    /// discrete axis event, scroll event for mice - 120 = one scroll tick
-    AxisDiscrete120 { axis: u8, value: i32 },
+    Motion {
+        time: u32,
+        relative_x: f64,
+        relative_y: f64,
+    },
+    Button {
+        time: u32,
+        button: u32,
+        state: u32,
+    },
+    Axis {
+        time: u32,
+        axis: u8,
+        value: f64,
+    },
+    AxisDiscrete120 {
+        axis: u8,
+        value: i32,
+    },
+    Frame {},
 }

 #[derive(Debug, PartialEq, Clone, Copy)]
 pub enum KeyboardEvent {
-    /// a key press / release event
-    Key { time: u32, key: u32, state: u8 },
-    /// modifiers changed state
+    Key {
+        time: u32,
+        key: u32,
+        state: u8,
+    },
    Modifiers {
-        depressed: u32,
-        latched: u32,
-        locked: u32,
+        mods_depressed: u32,
+        mods_latched: u32,
+        mods_locked: u32,
        group: u32,
    },
 }
@@ -44,12 +58,33 @@ pub enum Event {
    Pointer(PointerEvent),
    /// keyboard events (key / modifiers)
    Keyboard(KeyboardEvent),
+    /// enter event: request to enter a client.
+    /// The client must release the pointer if it is grabbed
+    /// and reply with a leave event, as soon as its ready to
+    /// receive events
+    Enter(),
+    /// leave event: this client is now ready to receive events and will
+    /// not send any events after until it sends an enter event
+    Leave(),
+    /// ping a client, to see if it is still alive. A client that does
+    /// not respond with a pong event will be assumed to be offline.
+    Ping(),
+    /// response to a ping event: this event signals that a client
+    /// is still alive but must otherwise be ignored
+    Pong(),
+    /// explicit disconnect request. The client will no longer
+    /// send events until the next Enter event. All of its keys should be released.
+    Disconnect(),
 }

 impl Display for PointerEvent {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
-            PointerEvent::Motion { time: _, dx, dy } => write!(f, "motion({dx},{dy})"),
+            PointerEvent::Motion {
+                time: _,
+                relative_x,
+                relative_y,
+            } => write!(f, "motion({relative_x},{relative_y})"),
            PointerEvent::Button {
                time: _,
                button,
@@ -77,6 +112,7 @@ impl Display for PointerEvent {
            PointerEvent::AxisDiscrete120 { axis, value } => {
                write!(f, "scroll-120 ({axis}, {value})")
            }
+            PointerEvent::Frame {} => write!(f, "frame()"),
        }
    }
 }
@@ -97,9 +133,9 @@ impl Display for KeyboardEvent {
                }
            }
            KeyboardEvent::Modifiers {
-                depressed: mods_depressed,
-                latched: mods_latched,
-                locked: mods_locked,
+                mods_depressed,
+                mods_latched,
+                mods_locked,
                group,
            } => write!(
                f,
@@ -114,6 +150,438 @@ impl Display for Event {
        match self {
            Event::Pointer(p) => write!(f, "{}", p),
            Event::Keyboard(k) => write!(f, "{}", k),
+            Event::Enter() => write!(f, "enter"),
+            Event::Leave() => write!(f, "leave"),
+            Event::Ping() => write!(f, "ping"),
+            Event::Pong() => write!(f, "pong"),
+            Event::Disconnect() => write!(f, "disconnect"),
+        }
+    }
+}
+
+impl Event {
+    fn event_type(&self) -> EventType {
+        match self {
+            Self::Pointer(_) => EventType::Pointer,
+            Self::Keyboard(_) => EventType::Keyboard,
+            Self::Enter() => EventType::Enter,
+            Self::Leave() => EventType::Leave,
+            Self::Ping() => EventType::Ping,
+            Self::Pong() => EventType::Pong,
+            Self::Disconnect() => EventType::Disconnect,
+        }
+    }
+}
+
+impl PointerEvent {
+    fn event_type(&self) -> PointerEventType {
+        match self {
+            Self::Motion { .. } => PointerEventType::Motion,
+            Self::Button { .. } => PointerEventType::Button,
+            Self::Axis { .. } => PointerEventType::Axis,
+            Self::AxisDiscrete120 { .. } => PointerEventType::AxisDiscrete120,
+            Self::Frame { .. } => PointerEventType::Frame,
+        }
+    }
+}
+
+impl KeyboardEvent {
+    fn event_type(&self) -> KeyboardEventType {
+        match self {
+            KeyboardEvent::Key { .. } => KeyboardEventType::Key,
+            KeyboardEvent::Modifiers { .. } => KeyboardEventType::Modifiers,
+        }
+    }
+}
+
+enum PointerEventType {
+    Motion,
+    Button,
+    Axis,
+    AxisDiscrete120,
+    Frame,
+}
+enum KeyboardEventType {
+    Key,
+    Modifiers,
+}
+enum EventType {
+    Pointer,
+    Keyboard,
+    Enter,
+    Leave,
+    Ping,
+    Pong,
+    Disconnect,
+}
+
+impl TryFrom<u8> for PointerEventType {
+    type Error = anyhow::Error;
+
+    fn try_from(value: u8) -> Result<Self> {
+        match value {
+            x if x == Self::Motion as u8 => Ok(Self::Motion),
+            x if x == Self::Button as u8 => Ok(Self::Button),
+            x if x == Self::Axis as u8 => Ok(Self::Axis),
+            x if x == Self::AxisDiscrete120 as u8 => Ok(Self::AxisDiscrete120),
+            x if x == Self::Frame as u8 => Ok(Self::Frame),
+            _ => Err(anyhow!(ProtocolError {
+                msg: format!("invalid pointer event type {}", value),
+            })),
+        }
+    }
+}
+
+impl TryFrom<u8> for KeyboardEventType {
+    type Error = anyhow::Error;
+
+    fn try_from(value: u8) -> Result<Self> {
+        match value {
+            x if x == Self::Key as u8 => Ok(Self::Key),
+            x if x == Self::Modifiers as u8 => Ok(Self::Modifiers),
+            _ => Err(anyhow!(ProtocolError {
+                msg: format!("invalid keyboard event type {}", value),
+            })),
+        }
+    }
+}
+
+impl From<&Event> for Vec<u8> {
+    fn from(event: &Event) -> Self {
+        let event_id = vec![event.event_type() as u8];
+        let event_data = match event {
+            Event::Pointer(p) => p.into(),
+            Event::Keyboard(k) => k.into(),
+            Event::Enter() => vec![],
+            Event::Leave() => vec![],
+            Event::Ping() => vec![],
+            Event::Pong() => vec![],
+            Event::Disconnect() => vec![],
+        };
+        [event_id, event_data].concat()
+    }
+}
+
+#[derive(Debug)]
+struct ProtocolError {
+    msg: String,
+}
+
+impl fmt::Display for ProtocolError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Protocol violation: {}", self.msg)
+    }
+}
+impl Error for ProtocolError {}
+
+impl TryFrom<Vec<u8>> for Event {
+    type Error = anyhow::Error;
+
+    fn try_from(value: Vec<u8>) -> Result<Self> {
+        let event_id = u8::from_be_bytes(value[..1].try_into()?);
+        match event_id {
+            i if i == (EventType::Pointer as u8) => Ok(Event::Pointer(value.try_into()?)),
+            i if i == (EventType::Keyboard as u8) => Ok(Event::Keyboard(value.try_into()?)),
+            i if i == (EventType::Enter as u8) => Ok(Event::Enter()),
+            i if i == (EventType::Leave as u8) => Ok(Event::Leave()),
+            i if i == (EventType::Ping as u8) => Ok(Event::Ping()),
+            i if i == (EventType::Pong as u8) => Ok(Event::Pong()),
+            i if i == (EventType::Disconnect as u8) => Ok(Event::Disconnect()),
+            _ => Err(anyhow!(ProtocolError {
+                msg: format!("invalid event_id {}", event_id),
+            })),
+        }
+    }
+}
+
+impl From<&PointerEvent> for Vec<u8> {
+    fn from(event: &PointerEvent) -> Self {
+        let id = vec![event.event_type() as u8];
+        let data = match event {
+            PointerEvent::Motion {
+                time,
+                relative_x,
+                relative_y,
+            } => {
+                let time = time.to_be_bytes();
+                let relative_x = relative_x.to_be_bytes();
+                let relative_y = relative_y.to_be_bytes();
+                [&time[..], &relative_x[..], &relative_y[..]].concat()
+            }
+            PointerEvent::Button {
+                time,
+                button,
+                state,
+            } => {
+                let time = time.to_be_bytes();
+                let button = button.to_be_bytes();
+                let state = state.to_be_bytes();
+                [&time[..], &button[..], &state[..]].concat()
+            }
+            PointerEvent::Axis { time, axis, value } => {
+                let time = time.to_be_bytes();
+                let axis = axis.to_be_bytes();
+                let value = value.to_be_bytes();
+                [&time[..], &axis[..], &value[..]].concat()
+            }
+            PointerEvent::AxisDiscrete120 { axis, value } => {
+                let axis = axis.to_be_bytes();
+                let value = value.to_be_bytes();
+                [&axis[..], &value[..]].concat()
+            }
+            PointerEvent::Frame {} => {
+                vec![]
+            }
+        };
+        [id, data].concat()
+    }
+}
+
+impl TryFrom<Vec<u8>> for PointerEvent {
+    type Error = anyhow::Error;
+
+    fn try_from(data: Vec<u8>) -> Result<Self> {
+        match data.get(1) {
+            Some(id) => {
+                let event_type = match id.to_owned().try_into() {
+                    Ok(event_type) => event_type,
+                    Err(e) => return Err(e),
+                };
+                match event_type {
+                    PointerEventType::Motion => {
+                        let time = match data.get(2..6) {
+                            Some(d) => u32::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 4 Bytes at index 2".into(),
+                                }))
+                            }
+                        };
+                        let relative_x = match data.get(6..14) {
+                            Some(d) => f64::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 8 Bytes at index 6".into(),
+                                }))
+                            }
+                        };
+                        let relative_y = match data.get(14..22) {
+                            Some(d) => f64::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 8 Bytes at index 14".into(),
+                                }))
+                            }
+                        };
+                        Ok(Self::Motion {
+                            time,
+                            relative_x,
+                            relative_y,
+                        })
+                    }
+                    PointerEventType::Button => {
+                        let time = match data.get(2..6) {
+                            Some(d) => u32::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 4 Bytes at index 2".into(),
+                                }))
+                            }
+                        };
+                        let button = match data.get(6..10) {
+                            Some(d) => u32::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 4 Bytes at index 10".into(),
+                                }))
+                            }
+                        };
+                        let state = match data.get(10..14) {
+                            Some(d) => u32::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 4 Bytes at index 14".into(),
+                                }))
+                            }
+                        };
+                        Ok(Self::Button {
+                            time,
+                            button,
+                            state,
+                        })
+                    }
+                    PointerEventType::Axis => {
+                        let time = match data.get(2..6) {
+                            Some(d) => u32::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 4 Bytes at index 2".into(),
+                                }))
+                            }
+                        };
+                        let axis = match data.get(6) {
+                            Some(d) => *d,
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 1 Byte at index 6".into(),
+                                }));
+                            }
+                        };
+                        let value = match data.get(7..15) {
+                            Some(d) => f64::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 8 Bytes at index 7".into(),
+                                }));
+                            }
+                        };
+                        Ok(Self::Axis { time, axis, value })
+                    }
+                    PointerEventType::AxisDiscrete120 => {
+                        let axis = match data.get(2) {
+                            Some(d) => *d,
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 1 Byte at index 2".into(),
+                                }));
+                            }
+                        };
+                        let value = match data.get(3..7) {
+                            Some(d) => i32::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 4 Bytes at index 3".into(),
+                                }));
+                            }
+                        };
+                        Ok(Self::AxisDiscrete120 { axis, value })
+                    }
+                    PointerEventType::Frame => Ok(Self::Frame {}),
+                }
+            }
+            None => Err(anyhow!(ProtocolError {
+                msg: "Expected an element at index 0".into(),
+            })),
+        }
+    }
+}
+
+impl From<&KeyboardEvent> for Vec<u8> {
+    fn from(event: &KeyboardEvent) -> Self {
+        let id = vec![event.event_type() as u8];
+        let data = match event {
+            KeyboardEvent::Key { time, key, state } => {
+                let time = time.to_be_bytes();
+                let key = key.to_be_bytes();
+                let state = state.to_be_bytes();
+                [&time[..], &key[..], &state[..]].concat()
+            }
+            KeyboardEvent::Modifiers {
+                mods_depressed,
+                mods_latched,
+                mods_locked,
+                group,
+            } => {
+                let mods_depressed = mods_depressed.to_be_bytes();
+                let mods_latched = mods_latched.to_be_bytes();
+                let mods_locked = mods_locked.to_be_bytes();
+                let group = group.to_be_bytes();
+                [
+                    &mods_depressed[..],
+                    &mods_latched[..],
+                    &mods_locked[..],
+                    &group[..],
+                ]
+                .concat()
+            }
+        };
+        [id, data].concat()
+    }
+}
+
+impl TryFrom<Vec<u8>> for KeyboardEvent {
+    type Error = anyhow::Error;
+
+    fn try_from(data: Vec<u8>) -> Result<Self> {
+        match data.get(1) {
+            Some(id) => {
+                let event_type = match id.to_owned().try_into() {
+                    Ok(event_type) => event_type,
+                    Err(e) => return Err(e),
+                };
+                match event_type {
+                    KeyboardEventType::Key => {
+                        let time = match data.get(2..6) {
+                            Some(d) => u32::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 4 Bytes at index 6".into(),
+                                }))
+                            }
+                        };
+                        let key = match data.get(6..10) {
+                            Some(d) => u32::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 4 Bytes at index 10".into(),
+                                }))
+                            }
+                        };
+                        let state = match data.get(10) {
+                            Some(d) => *d,
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 1 Bytes at index 14".into(),
+                                }))
+                            }
+                        };
+                        Ok(KeyboardEvent::Key { time, key, state })
+                    }
+                    KeyboardEventType::Modifiers => {
+                        let mods_depressed = match data.get(2..6) {
+                            Some(d) => u32::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 4 Bytes at index 6".into(),
+                                }))
+                            }
+                        };
+                        let mods_latched = match data.get(6..10) {
+                            Some(d) => u32::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 4 Bytes at index 10".into(),
+                                }))
+                            }
+                        };
+                        let mods_locked = match data.get(10..14) {
+                            Some(d) => u32::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 4 Bytes at index 14".into(),
+                                }))
+                            }
+                        };
+                        let group = match data.get(14..18) {
+                            Some(d) => u32::from_be_bytes(d.try_into()?),
+                            None => {
+                                return Err(anyhow!(ProtocolError {
+                                    msg: "Expected 4 Bytes at index 18".into(),
+                                }))
+                            }
+                        };
+                        Ok(KeyboardEvent::Modifiers {
+                            mods_depressed,
+                            mods_latched,
+                            mods_locked,
+                            group,
+                        })
+                    }
+                }
+            }
+            None => Err(anyhow!(ProtocolError {
+                msg: "Expected an element at index 0".into(),
+            })),
        }
    }
 }
--- a/input-event/src/libei.rs
+++ b/input-event/src/libei.rs
@@ -1,146 +0,0 @@
-use reis::{
-    ei::{button::ButtonState, keyboard::KeyState},
-    event::EiEvent,
-};
-
-use crate::{Event, KeyboardEvent, PointerEvent};
-
-impl Event {
-    pub fn from_ei_event(ei_event: EiEvent) -> impl Iterator<Item = Self> {
-        to_input_events(ei_event).into_iter()
-    }
-}
-
-enum Events {
-    None,
-    One(Event),
-    Two(Event, Event),
-}
-
-impl Events {
-    fn into_iter(self) -> impl Iterator<Item = Event> {
-        EventIterator::new(self)
-    }
-}
-
-struct EventIterator {
-    events: [Option<Event>; 2],
-    pos: usize,
-}
-
-impl EventIterator {
-    fn new(events: Events) -> Self {
-        let events = match events {
-            Events::None => [None, None],
-            Events::One(e) => [Some(e), None],
-            Events::Two(e, f) => [Some(e), Some(f)],
-        };
-        Self { events, pos: 0 }
-    }
-}
-
-impl Iterator for EventIterator {
-    type Item = Event;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let res = if self.pos >= self.events.len() {
-            None
-        } else {
-            self.events[self.pos]
-        };
-        self.pos += 1;
-        res
-    }
-}
-
-fn to_input_events(ei_event: EiEvent) -> Events {
-    match ei_event {
-        EiEvent::KeyboardModifiers(mods) => {
-            let modifier_event = KeyboardEvent::Modifiers {
-                depressed: mods.depressed,
-                latched: mods.latched,
-                locked: mods.locked,
-                group: mods.group,
-            };
-            Events::One(Event::Keyboard(modifier_event))
-        }
-        EiEvent::Frame(_) => Events::None, /* FIXME */
-        EiEvent::PointerMotion(motion) => {
-            let motion_event = PointerEvent::Motion {
-                time: motion.time as u32,
-                dx: motion.dx as f64,
-                dy: motion.dy as f64,
-            };
-            Events::One(Event::Pointer(motion_event))
-        }
-        EiEvent::PointerMotionAbsolute(_) => Events::None,
-        EiEvent::Button(button) => {
-            let button_event = PointerEvent::Button {
-                time: button.time as u32,
-                button: button.button,
-                state: match button.state {
-                    ButtonState::Released => 0,
-                    ButtonState::Press => 1,
-                },
-            };
-            Events::One(Event::Pointer(button_event))
-        }
-        EiEvent::ScrollDelta(delta) => {
-            let dy = Event::Pointer(PointerEvent::Axis {
-                time: 0,
-                axis: 0,
-                value: delta.dy as f64,
-            });
-            let dx = Event::Pointer(PointerEvent::Axis {
-                time: 0,
-                axis: 1,
-                value: delta.dx as f64,
-            });
-            if delta.dy != 0. && delta.dx != 0. {
-                Events::Two(dy, dx)
-            } else if delta.dy != 0. {
-                Events::One(dy)
-            } else if delta.dx != 0. {
-                Events::One(dx)
-            } else {
-                Events::None
-            }
-        }
-        EiEvent::ScrollStop(_) => Events::None,   /* TODO */
-        EiEvent::ScrollCancel(_) => Events::None, /* TODO */
-        EiEvent::ScrollDiscrete(scroll) => {
-            let dy = Event::Pointer(PointerEvent::AxisDiscrete120 {
-                axis: 0,
-                value: scroll.discrete_dy,
-            });
-            let dx = Event::Pointer(PointerEvent::AxisDiscrete120 {
-                axis: 1,
-                value: scroll.discrete_dx,
-            });
-            if scroll.discrete_dy != 0 && scroll.discrete_dx != 0 {
-                Events::Two(dy, dx)
-            } else if scroll.discrete_dy != 0 {
-                Events::One(dy)
-            } else if scroll.discrete_dx != 0 {
-                Events::One(dx)
-            } else {
-                Events::None
-            }
-        }
-        EiEvent::KeyboardKey(key) => {
-            let key_event = KeyboardEvent::Key {
-                key: key.key,
-                state: match key.state {
-                    KeyState::Press => 1,
-                    KeyState::Released => 0,
-                },
-                time: key.time as u32,
-            };
-            Events::One(Event::Keyboard(key_event))
-        }
-        EiEvent::TouchDown(_) => Events::None,   /* TODO */
-        EiEvent::TouchUp(_) => Events::None,     /* TODO */
-        EiEvent::TouchMotion(_) => Events::None, /* TODO */
-        _ => Events::None,
-    }
-}
--- a/lan-mouse-cli/Cargo.toml
+++ b/lan-mouse-cli/Cargo.toml
@@ -1,18 +0,0 @@
-[package]
-name = "lan-mouse-cli"
-description = "CLI Frontend for lan-mouse"
-version = "0.1.0"
-edition = "2021"
-license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
-
-[dependencies]
-futures = "0.3.30"
-lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.1.0" }
-tokio = { version = "1.32.0", features = [
-    "io-util",
-    "io-std",
-    "macros",
-    "net",
-    "rt",
-] }
--- a/lan-mouse-gtk/Cargo.toml
+++ b/lan-mouse-gtk/Cargo.toml
@@ -1,18 +0,0 @@
-[package]
-name = "lan-mouse-gtk"
-description = "GTK4 / Libadwaita Frontend for lan-mouse"
-version = "0.1.0"
-edition = "2021"
-license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
-
-[dependencies]
-gtk = { package = "gtk4", version = "0.9.0", features = ["v4_2"] }
-adw = { package = "libadwaita", version = "0.7.0", features = ["v1_1"] }
-async-channel = { version = "2.1.1" }
-hostname = "0.4.0"
-log = "0.4.20"
-lan-mouse-ipc = { path = "../lan-mouse-ipc", version = "0.1.0" }
-
-[build-dependencies]
-glib-build-tools = { version = "0.20.0" }
--- a/lan-mouse-gtk/build.rs
+++ b/lan-mouse-gtk/build.rs
@@ -1,8 +0,0 @@
-fn main() {
-    // composite_templates
-    glib_build_tools::compile_resources(
-        &["resources"],
-        "resources/resources.gresource.xml",
-        "lan-mouse.gresource",
-    );
-}
--- a/lan-mouse-gtk/resources/window.ui
+++ b/lan-mouse-gtk/resources/window.ui
@@ -1,227 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<interface>
-  <requires lib="gtk" version="4.0"/>
-  <requires lib="libadwaita" version="1.0"/>
-  <menu id="main-menu">
-    <item>
-      <attribute name="label" translatable="yes">_Close window</attribute>
-      <attribute name="action">window.close</attribute>
-    </item>
-  </menu>
-  <template class="LanMouseWindow" parent="AdwApplicationWindow">
-    <property name="width-request">600</property>
-    <property name="height-request">700</property>
-    <property name="title" translatable="yes">Lan Mouse</property>
-    <property name="show-menubar">True</property>
-    <property name="content">
-      <object class="GtkBox">
-        <property name="orientation">vertical</property>
-        <child type="top">
-          <object class="AdwHeaderBar">
-            <child type ="end">
-              <object class="GtkMenuButton">
-                <property name="icon-name">open-menu-symbolic</property>
-                <property name="menu-model">main-menu</property>
-              </object>
-            </child>
-            <style>
-              <class name="flat"/>
-            </style>
-          </object>
-        </child>
-        <child>
-          <object class="AdwToastOverlay" id="toast_overlay">
-            <child>
-              <object class="AdwStatusPage">
-                <property name="title" translatable="yes">Lan Mouse</property>
-                <property name="description" translatable="yes">easily use your mouse and keyboard on multiple computers</property>
-                <property name="icon-name">de.feschber.LanMouse</property>
-                <property name="child">
-                  <object class="AdwClamp">
-                  <property name="maximum-size">600</property>
-                  <property name="tightening-threshold">0</property>
-                  <property name="child">
-                    <object class="GtkBox">
-                    <property name="orientation">vertical</property>
-                    <property name="spacing">12</property>
-                    <child>
-                      <object class="AdwPreferencesGroup" id="capture_emulation_group">
-                      <property name="title" translatable="yes">Capture / Emulation Status</property>
-                        <child>
-                          <object class="AdwActionRow" id="capture_status_row">
-                            <property name="title">input capture is disabled</property>
-                            <property name="subtitle">required for outgoing and incoming connections</property>
-                            <property name="icon-name">dialog-warning-symbolic</property>
-                            <child>
-                              <object class="GtkButton" id="input_capture_button">
-                                <property name="child">
-                                  <object class="AdwButtonContent">
-                                    <property name="icon-name">object-rotate-right-symbolic</property>
-                                    <property name="label" translatable="yes">Reenable</property>
-                                  </object>
-                                </property>
-                                <signal name="clicked" handler="handle_capture" swapped="true"/>
-                                <property name="valign">center</property>
-                                <style>
-                                  <class name="circular"/>
-                                  <class name="flat"/>
-                                </style>
-                              </object>
-                            </child>
-                            <style>
-                              <class name="warning"/>
-                            </style>
-                          </object>
-                        </child>
-                        <child>
-                          <object class="AdwActionRow" id="emulation_status_row">
-                            <property name="title">input emulation is disabled</property>
-                            <property name="subtitle">required for incoming connections</property>
-                            <property name="icon-name">dialog-warning-symbolic</property>
-                            <child>
-                              <object class="GtkButton" id="input_emulation_button">
-                                <property name="child">
-                                  <object class="AdwButtonContent">
-                                    <property name="icon-name">object-rotate-right-symbolic</property>
-                                    <property name="label" translatable="yes">Reenable</property>
-                                  </object>
-                                </property>
-                                <property name="valign">center</property>
-                                <signal name="clicked" handler="handle_emulation" swapped="true"/>
-                                <style>
-                                  <class name="circular"/>
-                                  <class name="flat"/>
-                                </style>
-                              </object>
-                            </child>
-                            <child>
-                            </child>
-                            <style>
-                              <class name="warning"/>
-                            </style>
-                          </object>
-                        </child>
-                      </object>
-                    </child>
-                    <child>
-                      <object class="AdwPreferencesGroup">
-                        <property name="title" translatable="yes">General</property>
-                        <!--
-                        <child>
-                          <object class="AdwActionRow">
-                            <property name="title" translatable="yes">enable</property>
-                            <child type="suffix">
-                              <object class="GtkSwitch">
-                                <property name="valign">center</property>
-                                <property name="tooltip-text" translatable="yes">enable</property>
-                              </object>
-                            </child>
-                          </object>
-                        </child>
-                        -->
-                        <child>
-                          <object class="AdwActionRow">
-                            <property name="title">port</property>
-                            <child>
-                              <object class="GtkEntry" id="port_entry">
-                                <property name="max-width-chars">5</property>
-                                <signal name="activate" handler="handle_port_edit_apply" swapped="true"/>
-                                <signal name="changed" handler="handle_port_changed" swapped="true"/>
-                                <!-- <signal name="delete-text" handler="handle_port_changed" swapped="true"/> -->
-                                <!-- <property name="title" translatable="yes">port</property> -->
-                                <property name="placeholder-text">4242</property>
-                                <property name="width-chars">5</property>
-                                <property name="xalign">0.5</property>
-                                <property name="valign">center</property>
-                                <!-- <property name="show-apply-button">True</property> -->
-                                <property name="input-purpose">GTK_INPUT_PURPOSE_DIGITS</property>
-                              </object>
-                            </child>
-                            <child>
-                              <object class="GtkButton" id="port_edit_apply">
-                                <signal name="clicked" handler="handle_port_edit_apply" swapped="true"/>
-                                <property name="icon-name">object-select-symbolic</property>
-                                <property name="valign">center</property>
-                                <property name="visible">false</property>
-                                <property name="name">port-edit-apply</property>
-                                <style><class name="success"/></style>
-                              </object>
-                            </child>
-                            <child>
-                              <object class="GtkButton" id="port_edit_cancel">
-                                <signal name="clicked" handler="handle_port_edit_cancel" swapped="true"/>
-                                <property name="icon-name">process-stop-symbolic</property>
-                                <property name="valign">center</property>
-                                <property name="visible">false</property>
-                                <property name="name">port-edit-cancel</property>
-                                <style><class name="error"/></style>
-                              </object>
-                            </child>
-                          </object>
-                        </child>
-                        <child>
-                          <object class="AdwActionRow">
-                            <property name="title">hostname</property>
-                            <child>
-                              <object class="GtkLabel" id="hostname_label">
-                                <property name="label">&lt;span font_style=&quot;italic&quot; font_weight=&quot;light&quot; foreground=&quot;darkgrey&quot;&gt;could not determine hostname&lt;/span&gt;</property>
-                                <property name="use-markup">true</property>
-                                <property name="valign">center</property>
-                              </object>
-                            </child>
-                            <child>
-                              <object class="GtkButton" id="copy-hostname-button">
-                                <property name="icon-name">edit-copy-symbolic</property>
-                                <property name="valign">center</property>
-                                <signal name="clicked" handler="handle_copy_hostname" swapped="true"/>
-                              </object>
-                            </child>
-                          </object>
-                        </child>
-                      </object>
-                    </child>
-                    <child>
-                      <object class="AdwPreferencesGroup">
-                        <property name="title" translatable="yes">Connections</property>
-                        <property name="header-suffix">
-                          <object class="GtkButton">
-                            <signal name="clicked" handler="handle_add_client_pressed" swapped="true"/>
-                            <property name="child">
-                              <object class="AdwButtonContent">
-                                <property name="icon-name">list-add-symbolic</property>
-                                <property name="label" translatable="yes">Add</property>
-                              </object>
-                            </property>
-                          <style>
-                            <class name="flat"/>
-                          </style>
-                          </object>
-                        </property>
-                        <child>
-                          <object class="GtkListBox" id="client_list">
-                            <property name="selection-mode">none</property>
-                            <child type="placeholder">
-                              <object class="AdwActionRow" id="client_placeholder">
-                                <property name="title">No connections!</property>
-                                <property name="subtitle">add a new client via the + button</property>
-                              </object>
-                            </child>
-                            <style>
-                              <class name="boxed-list" />
-                            </style>
-                          </object>
-                        </child>
-                      </object>
-                    </child>
-                    </object>
-                  </property>
-                  </object>
-                </property>
-              </object>
-            </child>
-          </object>
-        </child>
-      </object>
-    </property>
-  </template>
-</interface>
--- a/lan-mouse-gtk/src/lib.rs
+++ b/lan-mouse-gtk/src/lib.rs
@@ -1,141 +0,0 @@
-mod client_object;
-mod client_row;
-mod window;
-
-use std::{env, process, str};
-
-use window::Window;
-
-use lan_mouse_ipc::{FrontendEvent, FrontendRequest};
-
-use adw::Application;
-use gtk::{
-    gdk::Display, glib::clone, prelude::*, subclass::prelude::ObjectSubclassIsExt, IconTheme,
-};
-use gtk::{gio, glib, prelude::ApplicationExt};
-
-use self::client_object::ClientObject;
-
-pub fn run() -> glib::ExitCode {
-    log::debug!("running gtk frontend");
-    #[cfg(windows)]
-    let ret = std::thread::Builder::new()
-        .stack_size(8 * 1024 * 1024) // https://gitlab.gnome.org/GNOME/gtk/-/commit/52dbb3f372b2c3ea339e879689c1de535ba2c2c3 -> caused crash on windows
-        .name("gtk".into())
-        .spawn(gtk_main)
-        .unwrap()
-        .join()
-        .unwrap();
-    #[cfg(not(windows))]
-    let ret = gtk_main();
-
-    if ret == glib::ExitCode::FAILURE {
-        log::error!("frontend exited with failure");
-    } else {
-        log::info!("frontend exited successfully");
-    }
-
-    ret
-}
-
-fn gtk_main() -> glib::ExitCode {
-    gio::resources_register_include!("lan-mouse.gresource").expect("Failed to register resources.");
-
-    let app = Application::builder()
-        .application_id("de.feschber.LanMouse")
-        .build();
-
-    app.connect_startup(|_| load_icons());
-    app.connect_activate(build_ui);
-
-    let args: Vec<&'static str> = vec![];
-    app.run_with_args(&args)
-}
-
-fn load_icons() {
-    let display = &Display::default().expect("Could not connect to a display.");
-    let icon_theme = IconTheme::for_display(display);
-    icon_theme.add_resource_path("/de/feschber/LanMouse/icons");
-}
-
-fn build_ui(app: &Application) {
-    log::debug!("connecting to lan-mouse-socket");
-    let (mut frontend_rx, frontend_tx) = match lan_mouse_ipc::connect() {
-        Ok(conn) => conn,
-        Err(e) => {
-            log::error!("{e}");
-            process::exit(1);
-        }
-    };
-    log::debug!("connected to lan-mouse-socket");
-
-    let (sender, receiver) = async_channel::bounded(10);
-
-    gio::spawn_blocking(move || {
-        while let Some(e) = frontend_rx.next_event() {
-            match e {
-                Ok(e) => sender.send_blocking(e).unwrap(),
-                Err(e) => {
-                    log::error!("{e}");
-                    break;
-                }
-            }
-        }
-    });
-
-    let window = Window::new(app, frontend_tx);
-
-    glib::spawn_future_local(clone!(
-        #[weak]
-        window,
-        async move {
-            loop {
-                let notify = receiver.recv().await.unwrap_or_else(|_| process::exit(1));
-                match notify {
-                    FrontendEvent::Changed(handle) => {
-                        window.request(FrontendRequest::GetState(handle));
-                    }
-                    FrontendEvent::Created(handle, client, state) => {
-                        window.new_client(handle, client, state);
-                    }
-                    FrontendEvent::Deleted(client) => {
-                        window.delete_client(client);
-                    }
-                    FrontendEvent::State(handle, config, state) => {
-                        window.update_client_config(handle, config);
-                        window.update_client_state(handle, state);
-                    }
-                    FrontendEvent::NoSuchClient(_) => {}
-                    FrontendEvent::Error(e) => {
-                        window.show_toast(e.as_str());
-                    }
-                    FrontendEvent::Enumerate(clients) => {
-                        for (handle, client, state) in clients {
-                            if window.client_idx(handle).is_some() {
-                                window.update_client_config(handle, client);
-                                window.update_client_state(handle, state);
-                            } else {
-                                window.new_client(handle, client, state);
-                            }
-                        }
-                    }
-                    FrontendEvent::PortChanged(port, msg) => {
-                        match msg {
-                            None => window.show_toast(format!("port changed: {port}").as_str()),
-                            Some(msg) => window.show_toast(msg.as_str()),
-                        }
-                        window.imp().set_port(port);
-                    }
-                    FrontendEvent::CaptureStatus(s) => {
-                        window.set_capture(s.into());
-                    }
-                    FrontendEvent::EmulationStatus(s) => {
-                        window.set_emulation(s.into());
-                    }
-                }
-            }
-        }
-    ));
-
-    window.present();
-}
--- a/lan-mouse-ipc/Cargo.toml
+++ b/lan-mouse-ipc/Cargo.toml
@@ -1,16 +0,0 @@
-[package]
-name = "lan-mouse-ipc"
-description = "library for communication between lan-mouse service and frontends"
-version = "0.1.0"
-edition = "2021"
-license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
-
-[dependencies]
-futures = "0.3.30"
-log = "0.4.22"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0.107"
-thiserror = "1.0.63"
-tokio = { version = "1.32.0", features = ["net", "io-util", "time"] }
-tokio-stream = { version = "0.1.15", features = ["io-util"] }
--- a/lan-mouse-ipc/src/connect.rs
+++ b/lan-mouse-ipc/src/connect.rs
@@ -1,89 +0,0 @@
-use crate::{ConnectionError, FrontendEvent, FrontendRequest, IpcError};
-use std::{
-    cmp::min,
-    io::{self, prelude::*, BufReader, LineWriter, Lines},
-    thread,
-    time::Duration,
-};
-
-#[cfg(unix)]
-use std::os::unix::net::UnixStream;
-
-#[cfg(windows)]
-use std::net::TcpStream;
-
-pub struct FrontendEventReader {
-    #[cfg(unix)]
-    lines: Lines<BufReader<UnixStream>>,
-    #[cfg(windows)]
-    lines: Lines<BufReader<TcpStream>>,
-}
-
-pub struct FrontendRequestWriter {
-    #[cfg(unix)]
-    line_writer: LineWriter<UnixStream>,
-    #[cfg(windows)]
-    line_writer: LineWriter<TcpStream>,
-}
-
-impl FrontendEventReader {
-    pub fn next_event(&mut self) -> Option<Result<FrontendEvent, IpcError>> {
-        match self.lines.next()? {
-            Err(e) => Some(Err(e.into())),
-            Ok(l) => Some(serde_json::from_str(l.as_str()).map_err(|e| e.into())),
-        }
-    }
-}
-
-impl FrontendRequestWriter {
-    pub fn request(&mut self, request: FrontendRequest) -> Result<(), io::Error> {
-        let mut json = serde_json::to_string(&request).unwrap();
-        log::debug!("requesting: {json}");
-        json.push('\n');
-        self.line_writer.write_all(json.as_bytes())?;
-        Ok(())
-    }
-}
-
-pub fn connect() -> Result<(FrontendEventReader, FrontendRequestWriter), ConnectionError> {
-    let rx = wait_for_service()?;
-    let tx = rx.try_clone()?;
-    let buf_reader = BufReader::new(rx);
-    let lines = buf_reader.lines();
-    let line_writer = LineWriter::new(tx);
-    let reader = FrontendEventReader { lines };
-    let writer = FrontendRequestWriter { line_writer };
-    Ok((reader, writer))
-}
-
-/// wait for the lan-mouse socket to come online
-#[cfg(unix)]
-fn wait_for_service() -> Result<UnixStream, ConnectionError> {
-    let socket_path = crate::default_socket_path()?;
-    let mut duration = Duration::from_millis(10);
-    loop {
-        if let Ok(stream) = UnixStream::connect(&socket_path) {
-            break Ok(stream);
-        }
-        // a signaling mechanism or inotify could be used to
-        // improve this
-        thread::sleep(exponential_back_off(&mut duration));
-    }
-}
-
-#[cfg(windows)]
-fn wait_for_service() -> Result<TcpStream, ConnectionError> {
-    let mut duration = Duration::from_millis(10);
-    loop {
-        if let Ok(stream) = TcpStream::connect("127.0.0.1:5252") {
-            break Ok(stream);
-        }
-        thread::sleep(exponential_back_off(&mut duration));
-    }
-}
-
-fn exponential_back_off(duration: &mut Duration) -> Duration {
-    let new = duration.saturating_mul(2);
-    *duration = min(new, Duration::from_secs(1));
-    *duration
-}
--- a/lan-mouse-ipc/src/connect_async.rs
+++ b/lan-mouse-ipc/src/connect_async.rs
@@ -1,104 +0,0 @@
-use crate::{ConnectionError, FrontendEvent, FrontendRequest, IpcError};
-use std::{
-    cmp::min,
-    io,
-    task::{ready, Poll},
-    time::Duration,
-};
-
-use futures::{Stream, StreamExt};
-use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader, ReadHalf, WriteHalf};
-use tokio_stream::wrappers::LinesStream;
-
-#[cfg(unix)]
-use tokio::net::UnixStream;
-
-#[cfg(windows)]
-use tokio::net::TcpStream;
-
-pub struct AsyncFrontendEventReader {
-    #[cfg(unix)]
-    lines_stream: LinesStream<BufReader<ReadHalf<UnixStream>>>,
-    #[cfg(windows)]
-    lines_stream: LinesStream<BufReader<ReadHalf<TcpStream>>>,
-}
-
-pub struct AsyncFrontendRequestWriter {
-    #[cfg(unix)]
-    tx: WriteHalf<UnixStream>,
-    #[cfg(windows)]
-    tx: WriteHalf<TcpStream>,
-}
-
-impl Stream for AsyncFrontendEventReader {
-    type Item = Result<FrontendEvent, IpcError>;
-
-    fn poll_next(
-        mut self: std::pin::Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Option<Self::Item>> {
-        let line = ready!(self.lines_stream.poll_next_unpin(cx));
-        let event = line.map(|l| {
-            l.map_err(Into::<IpcError>::into)
-                .and_then(|l| serde_json::from_str(l.as_str()).map_err(|e| e.into()))
-        });
-        Poll::Ready(event)
-    }
-}
-
-impl AsyncFrontendRequestWriter {
-    pub async fn request(&mut self, request: FrontendRequest) -> Result<(), io::Error> {
-        let mut json = serde_json::to_string(&request).unwrap();
-        log::debug!("requesting: {json}");
-        json.push('\n');
-        self.tx.write_all(json.as_bytes()).await?;
-        Ok(())
-    }
-}
-
-pub async fn connect_async(
-) -> Result<(AsyncFrontendEventReader, AsyncFrontendRequestWriter), ConnectionError> {
-    let stream = wait_for_service().await?;
-    #[cfg(unix)]
-    let (rx, tx): (ReadHalf<UnixStream>, WriteHalf<UnixStream>) = tokio::io::split(stream);
-    #[cfg(windows)]
-    let (rx, tx): (ReadHalf<TcpStream>, WriteHalf<TcpStream>) = tokio::io::split(stream);
-    let buf_reader = BufReader::new(rx);
-    let lines = buf_reader.lines();
-    let lines_stream = LinesStream::new(lines);
-    let reader = AsyncFrontendEventReader { lines_stream };
-    let writer = AsyncFrontendRequestWriter { tx };
-    Ok((reader, writer))
-}
-
-/// wait for the lan-mouse socket to come online
-#[cfg(unix)]
-async fn wait_for_service() -> Result<UnixStream, ConnectionError> {
-    let socket_path = crate::default_socket_path()?;
-    let mut duration = Duration::from_millis(10);
-    loop {
-        if let Ok(stream) = UnixStream::connect(&socket_path).await {
-            break Ok(stream);
-        }
-        // a signaling mechanism or inotify could be used to
-        // improve this
-        tokio::time::sleep(exponential_back_off(&mut duration)).await;
-    }
-}
-
-#[cfg(windows)]
-async fn wait_for_service() -> Result<TcpStream, ConnectionError> {
-    let mut duration = Duration::from_millis(10);
-    loop {
-        if let Ok(stream) = TcpStream::connect("127.0.0.1:5252").await {
-            break Ok(stream);
-        }
-        tokio::time::sleep(exponential_back_off(&mut duration)).await;
-    }
-}
-
-fn exponential_back_off(duration: &mut Duration) -> Duration {
-    let new = duration.saturating_mul(2);
-    *duration = min(new, Duration::from_secs(1));
-    *duration
-}
--- a/lan-mouse-ipc/src/lib.rs
+++ b/lan-mouse-ipc/src/lib.rs
@@ -1,264 +0,0 @@
-use std::{
-    collections::HashSet,
-    env::VarError,
-    fmt::Display,
-    io,
-    net::{IpAddr, SocketAddr},
-    str::FromStr,
-};
-use thiserror::Error;
-
-#[cfg(unix)]
-use std::{
-    env,
-    path::{Path, PathBuf},
-};
-
-use serde::{Deserialize, Serialize};
-
-mod connect;
-mod connect_async;
-mod listen;
-
-pub use connect::{connect, FrontendEventReader, FrontendRequestWriter};
-pub use connect_async::{connect_async, AsyncFrontendEventReader, AsyncFrontendRequestWriter};
-pub use listen::AsyncFrontendListener;
-
-#[derive(Debug, Error)]
-pub enum ConnectionError {
-    #[error(transparent)]
-    SocketPath(#[from] SocketPathError),
-    #[error(transparent)]
-    Io(#[from] io::Error),
-}
-
-#[derive(Debug, Error)]
-pub enum ListenerCreationError {
-    #[error("could not determine socket-path: `{0}`")]
-    SocketPath(#[from] SocketPathError),
-    #[error("service already running!")]
-    AlreadyRunning,
-    #[error("failed to bind lan-mouse socket: `{0}`")]
-    Bind(io::Error),
-}
-
-#[derive(Debug, Error)]
-pub enum IpcError {
-    #[error("io error occured: `{0}`")]
-    Io(#[from] io::Error),
-    #[error("invalid json: `{0}`")]
-    Json(#[from] serde_json::Error),
-    #[error(transparent)]
-    Connection(#[from] ConnectionError),
-    #[error(transparent)]
-    Listen(#[from] ListenerCreationError),
-}
-
-pub const DEFAULT_PORT: u16 = 4242;
-
-#[derive(Debug, Default, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
-pub enum Position {
-    #[default]
-    Left,
-    Right,
-    Top,
-    Bottom,
-}
-
-#[derive(Debug, Error)]
-#[error("not a valid position: {pos}")]
-pub struct PositionParseError {
-    pos: String,
-}
-
-impl FromStr for Position {
-    type Err = PositionParseError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "left" => Ok(Self::Left),
-            "right" => Ok(Self::Right),
-            "top" => Ok(Self::Top),
-            "bottom" => Ok(Self::Bottom),
-            _ => Err(PositionParseError { pos: s.into() }),
-        }
-    }
-}
-
-impl Display for Position {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                Position::Left => "left",
-                Position::Right => "right",
-                Position::Top => "top",
-                Position::Bottom => "bottom",
-            }
-        )
-    }
-}
-
-impl TryFrom<&str> for Position {
-    type Error = ();
-
-    fn try_from(s: &str) -> Result<Self, Self::Error> {
-        match s {
-            "left" => Ok(Position::Left),
-            "right" => Ok(Position::Right),
-            "top" => Ok(Position::Top),
-            "bottom" => Ok(Position::Bottom),
-            _ => Err(()),
-        }
-    }
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
-pub struct ClientConfig {
-    /// hostname of this client
-    pub hostname: Option<String>,
-    /// fix ips, determined by the user
-    pub fix_ips: Vec<IpAddr>,
-    /// both active_addr and addrs can be None / empty so port needs to be stored seperately
-    pub port: u16,
-    /// position of a client on screen
-    pub pos: Position,
-    /// enter hook
-    pub cmd: Option<String>,
-}
-
-impl Default for ClientConfig {
-    fn default() -> Self {
-        Self {
-            port: DEFAULT_PORT,
-            hostname: Default::default(),
-            fix_ips: Default::default(),
-            pos: Default::default(),
-            cmd: None,
-        }
-    }
-}
-
-pub type ClientHandle = u64;
-
-#[derive(Debug, Default, Clone, Serialize, Deserialize)]
-pub struct ClientState {
-    /// events should be sent to and received from the client
-    pub active: bool,
-    /// `active` address of the client, used to send data to.
-    /// This should generally be the socket address where data
-    /// was last received from.
-    pub active_addr: Option<SocketAddr>,
-    /// tracks whether or not the client is responding to pings
-    pub alive: bool,
-    /// ips from dns
-    pub dns_ips: Vec<IpAddr>,
-    /// all ip addresses associated with a particular client
-    /// e.g. Laptops usually have at least an ethernet and a wifi port
-    /// which have different ip addresses
-    pub ips: HashSet<IpAddr>,
-    /// client has pressed keys
-    pub has_pressed_keys: bool,
-    /// dns resolving in progress
-    pub resolving: bool,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub enum FrontendEvent {
-    /// client state has changed, new state must be requested via [`FrontendRequest::GetState`]
-    Changed(ClientHandle),
-    /// a client was created
-    Created(ClientHandle, ClientConfig, ClientState),
-    /// no such client
-    NoSuchClient(ClientHandle),
-    /// state changed
-    State(ClientHandle, ClientConfig, ClientState),
-    /// the client was deleted
-    Deleted(ClientHandle),
-    /// new port, reason of failure (if failed)
-    PortChanged(u16, Option<String>),
-    /// list of all clients, used for initial state synchronization
-    Enumerate(Vec<(ClientHandle, ClientConfig, ClientState)>),
-    /// an error occured
-    Error(String),
-    /// capture status
-    CaptureStatus(Status),
-    /// emulation status
-    EmulationStatus(Status),
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
-pub enum FrontendRequest {
-    /// activate/deactivate client
-    Activate(ClientHandle, bool),
-    /// add a new client
-    Create,
-    /// change the listen port (recreate udp listener)
-    ChangePort(u16),
-    /// remove a client
-    Delete(ClientHandle),
-    /// request an enumeration of all clients
-    Enumerate(),
-    /// resolve dns
-    ResolveDns(ClientHandle),
-    /// update hostname
-    UpdateHostname(ClientHandle, Option<String>),
-    /// update port
-    UpdatePort(ClientHandle, u16),
-    /// update position
-    UpdatePosition(ClientHandle, Position),
-    /// update fix-ips
-    UpdateFixIps(ClientHandle, Vec<IpAddr>),
-    /// request the state of the given client
-    GetState(ClientHandle),
-    /// request reenabling input capture
-    EnableCapture,
-    /// request reenabling input emulation
-    EnableEmulation,
-    /// synchronize all state
-    Sync,
-}
-
-#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
-pub enum Status {
-    #[default]
-    Disabled,
-    Enabled,
-}
-
-impl From<Status> for bool {
-    fn from(status: Status) -> Self {
-        match status {
-            Status::Enabled => true,
-            Status::Disabled => false,
-        }
-    }
-}
-
-#[cfg(unix)]
-const LAN_MOUSE_SOCKET_NAME: &str = "lan-mouse-socket.sock";
-
-#[derive(Debug, Error)]
-pub enum SocketPathError {
-    #[error("could not determine $XDG_RUNTIME_DIR: `{0}`")]
-    XdgRuntimeDirNotFound(VarError),
-    #[error("could not determine $HOME: `{0}`")]
-    HomeDirNotFound(VarError),
-}
-
-#[cfg(all(unix, not(target_os = "macos")))]
-pub fn default_socket_path() -> Result<PathBuf, SocketPathError> {
-    let xdg_runtime_dir =
-        env::var("XDG_RUNTIME_DIR").map_err(SocketPathError::XdgRuntimeDirNotFound)?;
-    Ok(Path::new(xdg_runtime_dir.as_str()).join(LAN_MOUSE_SOCKET_NAME))
-}
-
-#[cfg(all(unix, target_os = "macos"))]
-pub fn default_socket_path() -> Result<PathBuf, SocketPathError> {
-    let home = env::var("HOME").map_err(SocketPathError::HomeDirNotFound)?;
-    Ok(Path::new(home.as_str())
-        .join("Library")
-        .join("Caches")
-        .join(LAN_MOUSE_SOCKET_NAME))
-}
--- a/lan-mouse-ipc/src/listen.rs
+++ b/lan-mouse-ipc/src/listen.rs
@@ -1,147 +0,0 @@
-use futures::{stream::SelectAll, Stream, StreamExt};
-#[cfg(unix)]
-use std::path::PathBuf;
-use std::{
-    io::ErrorKind,
-    pin::Pin,
-    task::{Context, Poll},
-};
-
-use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader, ReadHalf, WriteHalf};
-use tokio_stream::wrappers::LinesStream;
-
-#[cfg(unix)]
-use tokio::net::UnixListener;
-#[cfg(unix)]
-use tokio::net::UnixStream;
-
-#[cfg(windows)]
-use tokio::net::TcpListener;
-#[cfg(windows)]
-use tokio::net::TcpStream;
-
-use crate::{FrontendEvent, FrontendRequest, IpcError, ListenerCreationError};
-
-pub struct AsyncFrontendListener {
-    #[cfg(windows)]
-    listener: TcpListener,
-    #[cfg(unix)]
-    listener: UnixListener,
-    #[cfg(unix)]
-    socket_path: PathBuf,
-    #[cfg(unix)]
-    line_streams: SelectAll<LinesStream<BufReader<ReadHalf<UnixStream>>>>,
-    #[cfg(windows)]
-    line_streams: SelectAll<LinesStream<BufReader<ReadHalf<TcpStream>>>>,
-    #[cfg(unix)]
-    tx_streams: Vec<WriteHalf<UnixStream>>,
-    #[cfg(windows)]
-    tx_streams: Vec<WriteHalf<TcpStream>>,
-}
-
-impl AsyncFrontendListener {
-    pub async fn new() -> Result<Self, ListenerCreationError> {
-        #[cfg(unix)]
-        let (socket_path, listener) = {
-            let socket_path = crate::default_socket_path()?;
-
-            log::debug!("remove socket: {:?}", socket_path);
-            if socket_path.exists() {
-                // try to connect to see if some other instance
-                // of lan-mouse is already running
-                match UnixStream::connect(&socket_path).await {
-                    // connected -> lan-mouse is already running
-                    Ok(_) => return Err(ListenerCreationError::AlreadyRunning),
-                    // lan-mouse is not running but a socket was left behind
-                    Err(e) => {
-                        log::debug!("{socket_path:?}: {e} - removing left behind socket");
-                        let _ = std::fs::remove_file(&socket_path);
-                    }
-                }
-            }
-            let listener = match UnixListener::bind(&socket_path) {
-                Ok(ls) => ls,
-                // some other lan-mouse instance has bound the socket in the meantime
-                Err(e) if e.kind() == ErrorKind::AddrInUse => {
-                    return Err(ListenerCreationError::AlreadyRunning)
-                }
-                Err(e) => return Err(ListenerCreationError::Bind(e)),
-            };
-            (socket_path, listener)
-        };
-
-        #[cfg(windows)]
-        let listener = match TcpListener::bind("127.0.0.1:5252").await {
-            Ok(ls) => ls,
-            // some other lan-mouse instance has bound the socket in the meantime
-            Err(e) if e.kind() == ErrorKind::AddrInUse => {
-                return Err(ListenerCreationError::AlreadyRunning)
-            }
-            Err(e) => return Err(ListenerCreationError::Bind(e)),
-        };
-
-        let adapter = Self {
-            listener,
-            #[cfg(unix)]
-            socket_path,
-            line_streams: SelectAll::new(),
-            tx_streams: vec![],
-        };
-
-        Ok(adapter)
-    }
-
-    pub async fn broadcast(&mut self, notify: FrontendEvent) {
-        // encode event
-        let mut json = serde_json::to_string(&notify).unwrap();
-        json.push('\n');
-
-        let mut keep = vec![];
-        // TODO do simultaneously
-        for tx in self.tx_streams.iter_mut() {
-            // write len + payload
-            if tx.write(json.as_bytes()).await.is_err() {
-                keep.push(false);
-                continue;
-            }
-            keep.push(true);
-        }
-
-        // could not find a better solution because async
-        let mut keep = keep.into_iter();
-        self.tx_streams.retain(|_| keep.next().unwrap());
-    }
-}
-
-#[cfg(unix)]
-impl Drop for AsyncFrontendListener {
-    fn drop(&mut self) {
-        log::debug!("remove socket: {:?}", self.socket_path);
-        let _ = std::fs::remove_file(&self.socket_path);
-    }
-}
-
-impl Stream for AsyncFrontendListener {
-    type Item = Result<FrontendRequest, IpcError>;
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        if let Poll::Ready(Some(Ok(l))) = self.line_streams.poll_next_unpin(cx) {
-            let request = serde_json::from_str(l.as_str()).map_err(|e| e.into());
-            return Poll::Ready(Some(request));
-        }
-        let mut sync = false;
-        while let Poll::Ready(Ok((stream, _))) = self.listener.poll_accept(cx) {
-            let (rx, tx) = tokio::io::split(stream);
-            let buf_reader = BufReader::new(rx);
-            let lines = buf_reader.lines();
-            let lines = LinesStream::new(lines);
-            self.line_streams.push(lines);
-            self.tx_streams.push(tx);
-            sync = true;
-        }
-        if sync {
-            Poll::Ready(Some(Ok(FrontendRequest::Sync)))
-        } else {
-            Poll::Pending
-        }
-    }
-}
--- a/lan-mouse-proto/Cargo.toml
+++ b/lan-mouse-proto/Cargo.toml
@@ -1,13 +0,0 @@
-[package]
-name = "lan-mouse-proto"
-description = "network protocol for lan-mouse"
-version = "0.1.0"
-edition = "2021"
-license = "GPL-3.0-or-later"
-repository = "https://github.com/feschber/lan-mouse"
-
-[dependencies]
-num_enum = "0.7.2"
-thiserror = "1.0.61"
-input-event = { path = "../input-event", version = "0.2.1" }
-paste = "1.0"
--- a/lan-mouse-proto/src/lib.rs
+++ b/lan-mouse-proto/src/lib.rs
@@ -1,251 +0,0 @@
-use input_event::{Event as InputEvent, KeyboardEvent, PointerEvent};
-use num_enum::{IntoPrimitive, TryFromPrimitive, TryFromPrimitiveError};
-use paste::paste;
-use std::{
-    fmt::{Debug, Display},
-    mem::size_of,
-};
-use thiserror::Error;
-
-/// defines the maximum size an encoded event can take up
-/// this is currently the pointer motion event
-/// type: u8, time: u32, dx: f64, dy: f64
-pub const MAX_EVENT_SIZE: usize = size_of::<u8>() + size_of::<u32>() + 2 * size_of::<f64>();
-
-/// error type for protocol violations
-#[derive(Debug, Error)]
-pub enum ProtocolError {
-    /// event type does not exist
-    #[error("invalid event id: `{0}`")]
-    InvalidEventId(#[from] TryFromPrimitiveError<EventType>),
-}
-
-/// main lan-mouse protocol event type
-#[derive(Clone, Copy, Debug)]
-pub enum ProtoEvent {
-    /// notify a client that the cursor entered its region
-    /// [`ProtoEvent::Ack`] with the same serial is used for synchronization between devices
-    Enter(u32),
-    /// notify a client that the cursor left its region
-    /// [`ProtoEvent::Ack`] with the same serial is used for synchronization between devices
-    Leave(u32),
-    /// acknowledge of an [`ProtoEvent::Enter`] or [`ProtoEvent::Leave`] event
-    Ack(u32),
-    /// Input event
-    Input(InputEvent),
-    /// Ping event for tracking unresponsive clients.
-    /// A client has to respond with [`ProtoEvent::Pong`].
-    Ping,
-    /// Response to [`ProtoEvent::Ping`]
-    Pong,
-}
-
-impl Display for ProtoEvent {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ProtoEvent::Enter(s) => write!(f, "Enter({s})"),
-            ProtoEvent::Leave(s) => write!(f, "Leave({s})"),
-            ProtoEvent::Ack(s) => write!(f, "Ack({s})"),
-            ProtoEvent::Input(e) => write!(f, "{e}"),
-            ProtoEvent::Ping => write!(f, "ping"),
-            ProtoEvent::Pong => write!(f, "pong"),
-        }
-    }
-}
-
-#[derive(TryFromPrimitive, IntoPrimitive)]
-#[repr(u8)]
-pub enum EventType {
-    PointerMotion,
-    PointerButton,
-    PointerAxis,
-    PointerAxisValue120,
-    KeyboardKey,
-    KeyboardModifiers,
-    Ping,
-    Pong,
-    Enter,
-    Leave,
-    Ack,
-}
-
-impl ProtoEvent {
-    fn event_type(&self) -> EventType {
-        match self {
-            ProtoEvent::Input(e) => match e {
-                InputEvent::Pointer(p) => match p {
-                    PointerEvent::Motion { .. } => EventType::PointerMotion,
-                    PointerEvent::Button { .. } => EventType::PointerButton,
-                    PointerEvent::Axis { .. } => EventType::PointerAxis,
-                    PointerEvent::AxisDiscrete120 { .. } => EventType::PointerAxisValue120,
-                },
-                InputEvent::Keyboard(k) => match k {
-                    KeyboardEvent::Key { .. } => EventType::KeyboardKey,
-                    KeyboardEvent::Modifiers { .. } => EventType::KeyboardModifiers,
-                },
-            },
-            ProtoEvent::Ping => EventType::Ping,
-            ProtoEvent::Pong => EventType::Pong,
-            ProtoEvent::Enter(_) => EventType::Enter,
-            ProtoEvent::Leave(_) => EventType::Leave,
-            ProtoEvent::Ack(_) => EventType::Ack,
-        }
-    }
-}
-
-impl TryFrom<[u8; MAX_EVENT_SIZE]> for ProtoEvent {
-    type Error = ProtocolError;
-
-    fn try_from(buf: [u8; MAX_EVENT_SIZE]) -> Result<Self, Self::Error> {
-        let mut buf = &buf[..];
-        let event_type = decode_u8(&mut buf)?;
-        match EventType::try_from(event_type)? {
-            EventType::PointerMotion => {
-                Ok(Self::Input(InputEvent::Pointer(PointerEvent::Motion {
-                    time: decode_u32(&mut buf)?,
-                    dx: decode_f64(&mut buf)?,
-                    dy: decode_f64(&mut buf)?,
-                })))
-            }
-            EventType::PointerButton => {
-                Ok(Self::Input(InputEvent::Pointer(PointerEvent::Button {
-                    time: decode_u32(&mut buf)?,
-                    button: decode_u32(&mut buf)?,
-                    state: decode_u32(&mut buf)?,
-                })))
-            }
-            EventType::PointerAxis => Ok(Self::Input(InputEvent::Pointer(PointerEvent::Axis {
-                time: decode_u32(&mut buf)?,
-                axis: decode_u8(&mut buf)?,
-                value: decode_f64(&mut buf)?,
-            }))),
-            EventType::PointerAxisValue120 => Ok(Self::Input(InputEvent::Pointer(
-                PointerEvent::AxisDiscrete120 {
-                    axis: decode_u8(&mut buf)?,
-                    value: decode_i32(&mut buf)?,
-                },
-            ))),
-            EventType::KeyboardKey => Ok(Self::Input(InputEvent::Keyboard(KeyboardEvent::Key {
-                time: decode_u32(&mut buf)?,
-                key: decode_u32(&mut buf)?,
-                state: decode_u8(&mut buf)?,
-            }))),
-            EventType::KeyboardModifiers => Ok(Self::Input(InputEvent::Keyboard(
-                KeyboardEvent::Modifiers {
-                    depressed: decode_u32(&mut buf)?,
-                    latched: decode_u32(&mut buf)?,
-                    locked: decode_u32(&mut buf)?,
-                    group: decode_u32(&mut buf)?,
-                },
-            ))),
-            EventType::Ping => Ok(Self::Ping),
-            EventType::Pong => Ok(Self::Pong),
-            EventType::Enter => Ok(Self::Enter(decode_u32(&mut buf)?)),
-            EventType::Leave => Ok(Self::Leave(decode_u32(&mut buf)?)),
-            EventType::Ack => Ok(Self::Ack(decode_u32(&mut buf)?)),
-        }
-    }
-}
-
-impl From<ProtoEvent> for ([u8; MAX_EVENT_SIZE], usize) {
-    fn from(event: ProtoEvent) -> Self {
-        let mut buf = [0u8; MAX_EVENT_SIZE];
-        let mut len = 0usize;
-        {
-            let mut buf = &mut buf[..];
-            let buf = &mut buf;
-            let len = &mut len;
-            encode_u8(buf, len, event.event_type() as u8);
-            match event {
-                ProtoEvent::Input(event) => match event {
-                    InputEvent::Pointer(p) => match p {
-                        PointerEvent::Motion { time, dx, dy } => {
-                            encode_u32(buf, len, time);
-                            encode_f64(buf, len, dx);
-                            encode_f64(buf, len, dy);
-                        }
-                        PointerEvent::Button {
-                            time,
-                            button,
-                            state,
-                        } => {
-                            encode_u32(buf, len, time);
-                            encode_u32(buf, len, button);
-                            encode_u32(buf, len, state);
-                        }
-                        PointerEvent::Axis { time, axis, value } => {
-                            encode_u32(buf, len, time);
-                            encode_u8(buf, len, axis);
-                            encode_f64(buf, len, value);
-                        }
-                        PointerEvent::AxisDiscrete120 { axis, value } => {
-                            encode_u8(buf, len, axis);
-                            encode_i32(buf, len, value);
-                        }
-                    },
-                    InputEvent::Keyboard(k) => match k {
-                        KeyboardEvent::Key { time, key, state } => {
-                            encode_u32(buf, len, time);
-                            encode_u32(buf, len, key);
-                            encode_u8(buf, len, state);
-                        }
-                        KeyboardEvent::Modifiers {
-                            depressed,
-                            latched,
-                            locked,
-                            group,
-                        } => {
-                            encode_u32(buf, len, depressed);
-                            encode_u32(buf, len, latched);
-                            encode_u32(buf, len, locked);
-                            encode_u32(buf, len, group);
-                        }
-                    },
-                },
-                ProtoEvent::Ping => {}
-                ProtoEvent::Pong => {}
-                ProtoEvent::Enter(serial) => encode_u32(buf, len, serial),
-                ProtoEvent::Leave(serial) => encode_u32(buf, len, serial),
-                ProtoEvent::Ack(serial) => encode_u32(buf, len, serial),
-            }
-        }
-        (buf, len)
-    }
-}
-
-macro_rules! decode_impl {
-    ($t:ty) => {
-        paste! {
-            fn [<decode_ $t>](data: &mut &[u8]) -> Result<$t, ProtocolError> {
-                let (int_bytes, rest) = data.split_at(size_of::<$t>());
-                *data = rest;
-                Ok($t::from_be_bytes(int_bytes.try_into().unwrap()))
-            }
-        }
-    };
-}
-
-decode_impl!(u8);
-decode_impl!(u32);
-decode_impl!(i32);
-decode_impl!(f64);
-
-macro_rules! encode_impl {
-    ($t:ty) => {
-        paste! {
-            fn [<encode_ $t>](buf: &mut &mut [u8], amt: &mut usize, n: $t) {
-                let src = n.to_be_bytes();
-                let data = std::mem::take(buf);
-                let (int_bytes, rest) = data.split_at_mut(size_of::<$t>());
-                int_bytes.copy_from_slice(&src);
-                *amt += size_of::<$t>();
-                *buf = rest
-            }
-        }
-    };
-}
-
-encode_impl!(u8);
-encode_impl!(u32);
-encode_impl!(i32);
-encode_impl!(f64);
--- a/nix/default.nix
+++ b/nix/default.nix
@@ -12,10 +12,8 @@ rustPlatform.buildRustPackage {
  version = version;

  nativeBuildInputs = with pkgs; [
-    git
    pkg-config
    cmake
-    makeWrapper
    buildPackages.gtk4
  ];

@@ -24,11 +22,9 @@ rustPlatform.buildRustPackage {
    gtk4
    libadwaita
    xorg.libXtst
-  ] ++ lib.optionals stdenv.isDarwin
-  (with darwin.apple_sdk_11_0.frameworks; [
-    CoreGraphics
-    ApplicationServices
-  ]);
+  ] ++ lib.optionals stdenv.isDarwin [
+    darwin.apple_sdk_11_0.frameworks.CoreGraphics
+  ];

  src = builtins.path {
    name = pname;
@@ -40,15 +36,6 @@ rustPlatform.buildRustPackage {
  # Set Environment Variables
  RUST_BACKTRACE = "full";

-  # Needed to enable support for SVG icons in GTK
-  postInstall = ''
-    wrapProgram "$out/bin/lan-mouse" \
-      --set GDK_PIXBUF_MODULE_FILE ${pkgs.librsvg.out}/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache
-
-    install -Dm444 *.desktop -t $out/share/applications
-    install -Dm444 lan-mouse-gtk/resources/*.svg -t $out/share/icons/hicolor/scalable/apps
-  '';
-
  meta = with lib; {
    description = "Lan Mouse is a mouse and keyboard sharing software";
    longDescription = ''
--- a/lan-mouse-gtk/resources/client_row.ui
+++ b/lan-mouse-gtk/resources/client_row.ui
@@ -44,7 +44,6 @@
 				<child>
 					<object class="GtkEntry" id="port">
 						<!-- <property name="title" translatable="yes">port</property> -->
-                        <property name="max-width-chars">5</property>
 						<property name="input_purpose">GTK_INPUT_PURPOSE_NUMBER</property>
 						<property name="xalign">0.5</property>
 						<property name="valign">center</property>
--- a/lan-mouse-gtk/resources/de.feschber.LanMouse.svg
+++ b/lan-mouse-gtk/resources/de.feschber.LanMouse.svg
--- a/lan-mouse-gtk/resources/resources.gresource.xml
+++ b/lan-mouse-gtk/resources/resources.gresource.xml
--- a/resources/window.ui
+++ b/resources/window.ui
@@ -0,0 +1,167 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<interface>
+	<requires lib="gtk" version="4.0"/>
+	<requires lib="libadwaita" version="1.0"/>
+	<menu id="main-menu">
+		<item>
+			<attribute name="label" translatable="yes">_Close window</attribute>
+			<attribute name="action">window.close</attribute>
+		</item>
+	</menu>
+	<template class="LanMouseWindow" parent="AdwApplicationWindow">
+		<property name="width-request">600</property>
+		<property name="height-request">700</property>
+		<property name="title" translatable="yes">Lan Mouse</property>
+		<property name="show-menubar">True</property>
+		<property name="content">
+			<object class="GtkBox">
+				<property name="orientation">vertical</property>
+				<child type="top">
+					<object class="AdwHeaderBar">
+						<child type ="end">
+							<object class="GtkMenuButton">
+								<property name="icon-name">open-menu-symbolic</property>
+								<property name="menu-model">main-menu</property>
+							</object>
+						</child>
+						<style>
+							<class name="flat"/>
+						</style>
+					</object>
+				</child>
+				<child>
+					<object class="AdwToastOverlay" id="toast_overlay">
+						<child>
+							<object class="AdwStatusPage">
+								<property name="title" translatable="yes">Lan Mouse</property>
+								<property name="description" translatable="yes">easily use your mouse and keyboard on multiple computers</property>
+								<property name="icon-name">de.feschber.LanMouse</property>
+								<property name="child">
+								  <object class="AdwClamp">
+									<property name="maximum-size">600</property>
+									<property name="tightening-threshold">0</property>
+									<property name="child">
+									  <object class="GtkBox">
+										<property name="orientation">vertical</property>
+										<property name="spacing">12</property>
+										<child>
+											<object class="AdwPreferencesGroup">
+												<property name="title" translatable="yes">General</property>
+												<!--
+												<child>
+													<object class="AdwActionRow">
+														<property name="title" translatable="yes">enable</property>
+														<child type="suffix">
+															<object class="GtkSwitch">
+																<property name="valign">center</property>
+																<property name="tooltip-text" translatable="yes">enable</property>
+															</object>
+														</child>
+													</object>
+												</child>
+												-->
+												<child>
+													<object class="AdwActionRow">
+														<property name="title">port</property>
+														<child>
+															<object class="GtkEntry" id="port_entry">
+																<signal name="activate" handler="handle_port_edit_apply" swapped="true"/>
+																<signal name="changed" handler="handle_port_changed" swapped="true"/>
+																<!-- <signal name="delete-text" handler="handle_port_changed" swapped="true"/> -->
+																<!-- <property name="title" translatable="yes">port</property> -->
+																<property name="placeholder-text">4242</property>
+																<property name="width-chars">5</property>
+																<property name="xalign">0.5</property>
+																<property name="valign">center</property>
+																<!-- <property name="show-apply-button">True</property> -->
+																<property name="input-purpose">GTK_INPUT_PURPOSE_DIGITS</property>
+															</object>
+														</child>
+														<child>
+															<object class="GtkButton" id="port_edit_apply">
+																<signal name="clicked" handler="handle_port_edit_apply" swapped="true"/>
+																<property name="icon-name">object-select-symbolic</property>
+																<property name="valign">center</property>
+																<property name="visible">false</property>
+																<property name="name">port-edit-apply</property>
+																<style><class name="success"/></style>
+															</object>
+														</child>
+														<child>
+															<object class="GtkButton" id="port_edit_cancel">
+																<signal name="clicked" handler="handle_port_edit_cancel" swapped="true"/>
+																<property name="icon-name">process-stop-symbolic</property>
+																<property name="valign">center</property>
+																<property name="visible">false</property>
+																<property name="name">port-edit-cancel</property>
+																<style><class name="error"/></style>
+															</object>
+														</child>
+													</object>
+												</child>
+												<child>
+													<object class="AdwActionRow">
+														<property name="title">hostname</property>
+														<child>
+															<object class="GtkLabel" id="hostname_label">
+																<property name="label">&lt;span font_style=&quot;italic&quot; font_weight=&quot;light&quot; foreground=&quot;darkgrey&quot;&gt;could not determine hostname&lt;/span&gt;</property>
+																<property name="use-markup">true</property>
+																<property name="valign">center</property>
+															</object>
+														</child>
+														<child>
+															<object class="GtkButton" id="copy-hostname-button">
+																<property name="icon-name">edit-copy-symbolic</property>
+																<property name="valign">center</property>
+																<signal name="clicked" handler="handle_copy_hostname" swapped="true"/>
+															</object>
+														</child>
+													</object>
+												</child>
+											</object>
+										</child>
+										<child>
+											<object class="AdwPreferencesGroup">
+												<property name="title" translatable="yes">Connections</property>
+												<property name="header-suffix">
+													<object class="GtkButton">
+														<signal name="clicked" handler="handle_add_client_pressed" swapped="true"/>
+														<property name="child">
+															<object class="AdwButtonContent">
+																<property name="icon-name">list-add-symbolic</property>
+																<property name="label" translatable="yes">Add</property>
+															</object>
+														</property>
+													<style>
+														<class name="flat"/>
+													</style>
+													</object>
+												</property>
+												<child>
+												  <object class="GtkListBox" id="client_list">
+														<property name="selection-mode">none</property>
+														<child type="placeholder">
+															<object class="AdwActionRow" id="client_placeholder">
+																<property name="title">No connections!</property>
+																<property name="subtitle">add a new client via the + button</property>
+															</object>
+														</child>
+														<style>
+															<class name="boxed-list" />
+														</style>
+												  </object>
+												</child>
+											</object>
+										</child>
+									  </object>
+									</property>
+								  </object>
+							  </property>
+							</object>
+						</child>
+					</object>
+				</child>
+			</object>
+		</property>
+	</template>
+</interface>
--- a/src/capture_test.rs
+++ b/src/capture_test.rs
@@ -1,44 +1,45 @@
 use crate::config::Config;
+use anyhow::{anyhow, Result};
 use futures::StreamExt;
-use input_capture::{self, CaptureError, CaptureEvent, InputCapture, InputCaptureError, Position};
+use input_capture::{self, Position};
 use input_event::{Event, KeyboardEvent};
+use tokio::task::LocalSet;

-pub async fn run(config: Config) -> Result<(), InputCaptureError> {
+pub fn run() -> Result<()> {
    log::info!("running input capture test");
-    log::info!("creating input capture");
-    let backend = config.capture_backend.map(|b| b.into());
-    loop {
-        let mut input_capture = InputCapture::new(backend).await?;
-        log::info!("creating clients");
-        input_capture.create(0, Position::Left).await?;
-        input_capture.create(4, Position::Left).await?;
-        input_capture.create(1, Position::Right).await?;
-        input_capture.create(2, Position::Top).await?;
-        input_capture.create(3, Position::Bottom).await?;
-        if let Err(e) = do_capture(&mut input_capture).await {
-            log::warn!("{e} - recreating capture");
-        }
-        let _ = input_capture.terminate().await;
-    }
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()?;
+
+    let config = Config::new()?;
+
+    runtime.block_on(LocalSet::new().run_until(input_capture_test(config)))
 }

-async fn do_capture(input_capture: &mut InputCapture) -> Result<(), CaptureError> {
+async fn input_capture_test(config: Config) -> Result<()> {
+    log::info!("creating input capture");
+    let backend = config.capture_backend.map(|b| b.into());
+    let mut input_capture = input_capture::create(backend).await?;
+    log::info!("creating clients");
+    input_capture.create(0, Position::Left)?;
+    input_capture.create(1, Position::Right)?;
+    input_capture.create(2, Position::Top)?;
+    input_capture.create(3, Position::Bottom)?;
    loop {
        let (client, event) = input_capture
            .next()
            .await
-            .ok_or(CaptureError::EndOfStream)??;
+            .ok_or(anyhow!("capture stream closed"))??;
        let pos = match client {
-            0 | 4 => Position::Left,
+            0 => Position::Left,
            1 => Position::Right,
            2 => Position::Top,
-            3 => Position::Bottom,
-            _ => panic!(),
+            _ => Position::Bottom,
        };
-        log::info!("position: {client} ({pos}), event: {event}");
-        if let CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key: 1, .. })) = event {
-            input_capture.release().await?;
-            break Ok(());
+        log::info!("position: {pos}, event: {event}");
+        if let Event::Keyboard(KeyboardEvent::Key { key: 1, .. }) = event {
+            input_capture.release()?;
        }
    }
 }
--- a/src/client.rs
+++ b/src/client.rs
@@ -1,18 +1,167 @@
-use std::net::SocketAddr;
+use std::{
+    collections::HashSet,
+    error::Error,
+    fmt::Display,
+    net::{IpAddr, SocketAddr},
+    str::FromStr,
+};

+use serde::{Deserialize, Serialize};
 use slab::Slab;

-use lan_mouse_ipc::{ClientConfig, ClientHandle, ClientState, Position};
+use crate::config::DEFAULT_PORT;
+use input_capture;
+
+#[derive(Debug, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
+pub enum Position {
+    Left,
+    Right,
+    Top,
+    Bottom,
+}
+
+impl Default for Position {
+    fn default() -> Self {
+        Self::Left
+    }
+}
+
+impl From<Position> for input_capture::Position {
+    fn from(position: Position) -> input_capture::Position {
+        match position {
+            Position::Left => input_capture::Position::Left,
+            Position::Right => input_capture::Position::Right,
+            Position::Top => input_capture::Position::Top,
+            Position::Bottom => input_capture::Position::Bottom,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct PositionParseError {
+    string: String,
+}
+
+impl Display for PositionParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "not a valid position: {}", self.string)
+    }
+}
+
+impl Error for PositionParseError {}
+
+impl FromStr for Position {
+    type Err = PositionParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "left" => Ok(Self::Left),
+            "right" => Ok(Self::Right),
+            "top" => Ok(Self::Top),
+            "bottom" => Ok(Self::Bottom),
+            _ => Err(PositionParseError { string: s.into() }),
+        }
+    }
+}
+
+impl Display for Position {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Position::Left => "left",
+                Position::Right => "right",
+                Position::Top => "top",
+                Position::Bottom => "bottom",
+            }
+        )
+    }
+}
+
+impl TryFrom<&str> for Position {
+    type Error = ();
+
+    fn try_from(s: &str) -> Result<Self, Self::Error> {
+        match s {
+            "left" => Ok(Position::Left),
+            "right" => Ok(Position::Right),
+            "top" => Ok(Position::Top),
+            "bottom" => Ok(Position::Bottom),
+            _ => Err(()),
+        }
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
+pub struct ClientConfig {
+    /// hostname of this client
+    pub hostname: Option<String>,
+    /// fix ips, determined by the user
+    pub fix_ips: Vec<IpAddr>,
+    /// both active_addr and addrs can be None / empty so port needs to be stored seperately
+    pub port: u16,
+    /// position of a client on screen
+    pub pos: Position,
+    /// enter hook
+    pub cmd: Option<String>,
+}
+
+impl Default for ClientConfig {
+    fn default() -> Self {
+        Self {
+            port: DEFAULT_PORT,
+            hostname: Default::default(),
+            fix_ips: Default::default(),
+            pos: Default::default(),
+            cmd: None,
+        }
+    }
+}
+
+pub type ClientHandle = u64;
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+pub struct ClientState {
+    /// events should be sent to and received from the client
+    pub active: bool,
+    /// `active` address of the client, used to send data to.
+    /// This should generally be the socket address where data
+    /// was last received from.
+    pub active_addr: Option<SocketAddr>,
+    /// tracks whether or not the client is responding to pings
+    pub alive: bool,
+    /// all ip addresses associated with a particular client
+    /// e.g. Laptops usually have at least an ethernet and a wifi port
+    /// which have different ip addresses
+    pub ips: HashSet<IpAddr>,
+    /// keys currently pressed by this client
+    pub pressed_keys: HashSet<u32>,
+    /// dns resolving in progress
+    pub resolving: bool,
+}

-#[derive(Default)]
 pub struct ClientManager {
    clients: Slab<(ClientConfig, ClientState)>,
 }

+impl Default for ClientManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ClientManager {
+    pub fn new() -> Self {
+        let clients = Slab::new();
+        Self { clients }
+    }
+
    /// add a new client to this manager
    pub fn add_client(&mut self) -> ClientHandle {
-        self.clients.insert(Default::default()) as ClientHandle
+        let client_config = Default::default();
+        let client_state = Default::default();
+        self.clients.insert((client_config, client_state)) as ClientHandle
    }

    /// find a client by its address
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,20 +1,22 @@
+use anyhow::Result;
 use clap::{Parser, ValueEnum};
 use serde::{Deserialize, Serialize};
-use std::env::{self, VarError};
+use std::collections::HashSet;
+use std::env;
 use std::fmt::Display;
-use std::fs;
 use std::net::IpAddr;
-use std::{collections::HashSet, io};
-use thiserror::Error;
+use std::{error::Error, fs};
 use toml;

-use lan_mouse_ipc::{Position, DEFAULT_PORT};
+use crate::client::Position;

 use input_event::scancode::{
    self,
    Linux::{KeyLeftAlt, KeyLeftCtrl, KeyLeftMeta, KeyLeftShift},
 };

+pub const DEFAULT_PORT: u16 = 4242;
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ConfigToml {
    pub capture_backend: Option<CaptureBackend>,
@@ -40,7 +42,7 @@ pub struct TomlClient {
 }

 impl ConfigToml {
-    pub fn new(path: &str) -> Result<ConfigToml, ConfigError> {
+    pub fn new(path: &str) -> Result<ConfigToml, Box<dyn Error>> {
        let config = fs::read_to_string(path)?;
        log::info!("using config: \"{path}\"");
        Ok(toml::from_str::<_>(&config)?)
@@ -48,7 +50,7 @@ impl ConfigToml {
 }

 #[derive(Parser, Debug)]
-#[command(author, version=env!("GIT_DESCRIBE"), about, long_about = None)]
+#[command(author, version, about, long_about = None)]
 struct CliArgs {
    /// the listen port for lan-mouse
    #[arg(short, long)]
@@ -229,21 +231,11 @@ pub struct ConfigClient {
    pub enter_hook: Option<String>,
 }

-#[derive(Debug, Error)]
-pub enum ConfigError {
-    #[error(transparent)]
-    Toml(#[from] toml::de::Error),
-    #[error(transparent)]
-    Io(#[from] io::Error),
-    #[error(transparent)]
-    Var(#[from] VarError),
-}
-
 const DEFAULT_RELEASE_KEYS: [scancode::Linux; 4] =
    [KeyLeftCtrl, KeyLeftShift, KeyLeftMeta, KeyLeftAlt];

 impl Config {
-    pub fn new() -> Result<Self, ConfigError> {
+    pub fn new() -> Result<Self> {
        let args = CliArgs::parse();
        let config_file = "config.toml";
        #[cfg(unix)]
--- a/src/dns.rs
+++ b/src/dns.rs
@@ -1,63 +1,23 @@
-use local_channel::mpsc::Receiver;
-use std::net::IpAddr;
+use anyhow::Result;
+use std::{error::Error, net::IpAddr};

-use hickory_resolver::{error::ResolveError, TokioAsyncResolver};
+use hickory_resolver::TokioAsyncResolver;

-use crate::server::Server;
-use lan_mouse_ipc::ClientHandle;
-
-pub(crate) struct DnsResolver {
+pub struct DnsResolver {
    resolver: TokioAsyncResolver,
-    dns_request: Receiver<ClientHandle>,
 }
-
 impl DnsResolver {
-    pub(crate) fn new(dns_request: Receiver<ClientHandle>) -> Result<Self, ResolveError> {
+    pub(crate) async fn new() -> Result<Self> {
        let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
-        Ok(Self {
-            resolver,
-            dns_request,
-        })
+        Ok(Self { resolver })
    }

-    async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, ResolveError> {
+    pub(crate) async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, Box<dyn Error>> {
+        log::info!("resolving {host} ...");
        let response = self.resolver.lookup_ip(host).await?;
        for ip in response.iter() {
            log::info!("{host}: adding ip {ip}");
        }
        Ok(response.iter().collect())
    }
-
-    pub(crate) async fn run(mut self, server: Server) {
-        tokio::select! {
-            _ = server.cancelled() => {},
-            _ = self.do_dns(&server) => {},
-        }
-    }
-
-    async fn do_dns(&mut self, server: &Server) {
-        loop {
-            let handle = self.dns_request.recv().await.expect("channel closed");
-
-            /* update resolving status */
-            let hostname = match server.get_hostname(handle) {
-                Some(hostname) => hostname,
-                None => continue,
-            };
-
-            log::info!("resolving ({handle}) `{hostname}` ...");
-            server.set_resolving(handle, true);
-
-            let ips = match self.resolve(&hostname).await {
-                Ok(ips) => ips,
-                Err(e) => {
-                    log::warn!("could not resolve host '{hostname}': {e}");
-                    vec![]
-                }
-            };
-
-            server.update_dns_ips(handle, ips);
-            server.set_resolving(handle, false);
-        }
-    }
 }
--- a/src/emulation_test.rs
+++ b/src/emulation_test.rs
@@ -1,19 +1,29 @@
 use crate::config::Config;
-use input_emulation::{InputEmulation, InputEmulationError};
+use anyhow::Result;
 use input_event::{Event, PointerEvent};
 use std::f64::consts::PI;
 use std::time::{Duration, Instant};
+use tokio::task::LocalSet;
+
+pub fn run() -> Result<()> {
+    log::info!("running input emulation test");
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_io()
+        .enable_time()
+        .build()?;
+
+    let config = Config::new()?;
+
+    runtime.block_on(LocalSet::new().run_until(input_emulation_test(config)))
+}

 const FREQUENCY_HZ: f64 = 1.0;
 const RADIUS: f64 = 100.0;

-pub async fn run(config: Config) -> Result<(), InputEmulationError> {
-    log::info!("running input emulation test");
-
+async fn input_emulation_test(config: Config) -> Result<()> {
    let backend = config.emulation_backend.map(|b| b.into());
-    let mut emulation = InputEmulation::new(backend).await?;
+    let mut emulation = input_emulation::create(backend).await?;
    emulation.create(0).await;
-
    let start = Instant::now();
    let mut offset = (0, 0);
    loop {
@@ -27,8 +37,12 @@ pub async fn run(config: Config) -> Result<(), InputEmulationError> {
        if new_offset != offset {
            let relative_motion = (new_offset.0 - offset.0, new_offset.1 - offset.1);
            offset = new_offset;
-            let (dx, dy) = (relative_motion.0 as f64, relative_motion.1 as f64);
-            let event = Event::Pointer(PointerEvent::Motion { time: 0, dx, dy });
+            let (relative_x, relative_y) = (relative_motion.0 as f64, relative_motion.1 as f64);
+            let event = Event::Pointer(PointerEvent::Motion {
+                time: 0,
+                relative_x,
+                relative_y,
+            });
            emulation.consume(event, 0).await?;
        }
    }
--- a/src/frontend.rs
+++ b/src/frontend.rs
@@ -0,0 +1,286 @@
+use anyhow::{anyhow, Result};
+use std::{cmp::min, io::ErrorKind, net::IpAddr, str, time::Duration};
+
+#[cfg(unix)]
+use std::{
+    env,
+    path::{Path, PathBuf},
+};
+
+use tokio::io::ReadHalf;
+use tokio::io::{AsyncReadExt, AsyncWriteExt, WriteHalf};
+
+#[cfg(unix)]
+use tokio::net::UnixListener;
+#[cfg(unix)]
+use tokio::net::UnixStream;
+
+#[cfg(windows)]
+use tokio::net::TcpListener;
+#[cfg(windows)]
+use tokio::net::TcpStream;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    client::{ClientConfig, ClientHandle, ClientState, Position},
+    config::{Config, Frontend},
+};
+
+/// cli frontend
+pub mod cli;
+
+/// gtk frontend
+#[cfg(feature = "gtk")]
+pub mod gtk;
+
+pub fn run_frontend(config: &Config) -> Result<()> {
+    match config.frontend {
+        #[cfg(feature = "gtk")]
+        Frontend::Gtk => {
+            gtk::run();
+        }
+        #[cfg(not(feature = "gtk"))]
+        Frontend::Gtk => panic!("gtk frontend requested but feature not enabled!"),
+        Frontend::Cli => {
+            cli::run()?;
+        }
+    };
+    Ok(())
+}
+
+fn exponential_back_off(duration: &mut Duration) -> &Duration {
+    let new = duration.saturating_mul(2);
+    *duration = min(new, Duration::from_secs(1));
+    duration
+}
+
+/// wait for the lan-mouse socket to come online
+#[cfg(unix)]
+pub fn wait_for_service() -> Result<std::os::unix::net::UnixStream> {
+    let socket_path = FrontendListener::socket_path()?;
+    let mut duration = Duration::from_millis(1);
+    loop {
+        use std::os::unix::net::UnixStream;
+        if let Ok(stream) = UnixStream::connect(&socket_path) {
+            break Ok(stream);
+        }
+        // a signaling mechanism or inotify could be used to
+        // improve this
+        std::thread::sleep(*exponential_back_off(&mut duration));
+    }
+}
+
+#[cfg(windows)]
+pub fn wait_for_service() -> Result<std::net::TcpStream> {
+    let mut duration = Duration::from_millis(1);
+    loop {
+        use std::net::TcpStream;
+        if let Ok(stream) = TcpStream::connect("127.0.0.1:5252") {
+            break Ok(stream);
+        }
+        std::thread::sleep(*exponential_back_off(&mut duration));
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Serialize, Deserialize)]
+pub enum FrontendRequest {
+    /// activate/deactivate client
+    Activate(ClientHandle, bool),
+    /// add a new client
+    Create,
+    /// change the listen port (recreate udp listener)
+    ChangePort(u16),
+    /// remove a client
+    Delete(ClientHandle),
+    /// request an enumeration of all clients
+    Enumerate(),
+    /// resolve dns
+    ResolveDns(ClientHandle),
+    /// service shutdown
+    Terminate(),
+    /// update hostname
+    UpdateHostname(ClientHandle, Option<String>),
+    /// update port
+    UpdatePort(ClientHandle, u16),
+    /// update position
+    UpdatePosition(ClientHandle, Position),
+    /// update fix-ips
+    UpdateFixIps(ClientHandle, Vec<IpAddr>),
+    /// request the state of the given client
+    GetState(ClientHandle),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum FrontendEvent {
+    /// a client was created
+    Created(ClientHandle, ClientConfig, ClientState),
+    /// no such client
+    NoSuchClient(ClientHandle),
+    /// state changed
+    State(ClientHandle, ClientConfig, ClientState),
+    /// the client was deleted
+    Deleted(ClientHandle),
+    /// new port, reason of failure (if failed)
+    PortChanged(u16, Option<String>),
+    /// list of all clients, used for initial state synchronization
+    Enumerate(Vec<(ClientHandle, ClientConfig, ClientState)>),
+    /// an error occured
+    Error(String),
+}
+
+pub struct FrontendListener {
+    #[cfg(windows)]
+    listener: TcpListener,
+    #[cfg(unix)]
+    listener: UnixListener,
+    #[cfg(unix)]
+    socket_path: PathBuf,
+    #[cfg(unix)]
+    tx_streams: Vec<WriteHalf<UnixStream>>,
+    #[cfg(windows)]
+    tx_streams: Vec<WriteHalf<TcpStream>>,
+}
+
+impl FrontendListener {
+    #[cfg(all(unix, not(target_os = "macos")))]
+    pub fn socket_path() -> Result<PathBuf> {
+        let xdg_runtime_dir = match env::var("XDG_RUNTIME_DIR") {
+            Ok(d) => d,
+            Err(e) => return Err(anyhow!("could not find XDG_RUNTIME_DIR: {e}")),
+        };
+        let xdg_runtime_dir = Path::new(xdg_runtime_dir.as_str());
+        Ok(xdg_runtime_dir.join("lan-mouse-socket.sock"))
+    }
+
+    #[cfg(all(unix, target_os = "macos"))]
+    pub fn socket_path() -> Result<PathBuf> {
+        let home = match env::var("HOME") {
+            Ok(d) => d,
+            Err(e) => return Err(anyhow!("could not find HOME: {e}")),
+        };
+        let home = Path::new(home.as_str());
+        let path = home
+            .join("Library")
+            .join("Caches")
+            .join("lan-mouse-socket.sock");
+        Ok(path)
+    }
+
+    pub async fn new() -> Option<Result<Self>> {
+        #[cfg(unix)]
+        let (socket_path, listener) = {
+            let socket_path = match Self::socket_path() {
+                Ok(path) => path,
+                Err(e) => return Some(Err(e)),
+            };
+
+            log::debug!("remove socket: {:?}", socket_path);
+            if socket_path.exists() {
+                // try to connect to see if some other instance
+                // of lan-mouse is already running
+                match UnixStream::connect(&socket_path).await {
+                    // connected -> lan-mouse is already running
+                    Ok(_) => return None,
+                    // lan-mouse is not running but a socket was left behind
+                    Err(e) => {
+                        log::debug!("{socket_path:?}: {e} - removing left behind socket");
+                        let _ = std::fs::remove_file(&socket_path);
+                    }
+                }
+            }
+            let listener = match UnixListener::bind(&socket_path) {
+                Ok(ls) => ls,
+                // some other lan-mouse instance has bound the socket in the meantime
+                Err(e) if e.kind() == ErrorKind::AddrInUse => return None,
+                Err(e) => return Some(Err(anyhow!("failed to bind lan-mouse-socket: {e}"))),
+            };
+            (socket_path, listener)
+        };
+
+        #[cfg(windows)]
+        let listener = match TcpListener::bind("127.0.0.1:5252").await {
+            Ok(ls) => ls,
+            // some other lan-mouse instance has bound the socket in the meantime
+            Err(e) if e.kind() == ErrorKind::AddrInUse => return None,
+            Err(e) => return Some(Err(anyhow!("failed to bind lan-mouse-socket: {e}"))),
+        };
+
+        let adapter = Self {
+            listener,
+            #[cfg(unix)]
+            socket_path,
+            tx_streams: vec![],
+        };
+
+        Some(Ok(adapter))
+    }
+
+    #[cfg(unix)]
+    pub async fn accept(&mut self) -> Result<ReadHalf<UnixStream>> {
+        let stream = self.listener.accept().await?.0;
+        let (rx, tx) = tokio::io::split(stream);
+        self.tx_streams.push(tx);
+        Ok(rx)
+    }
+
+    #[cfg(windows)]
+    pub async fn accept(&mut self) -> Result<ReadHalf<TcpStream>> {
+        let stream = self.listener.accept().await?.0;
+        let (rx, tx) = tokio::io::split(stream);
+        self.tx_streams.push(tx);
+        Ok(rx)
+    }
+
+    pub(crate) async fn broadcast_event(&mut self, notify: FrontendEvent) -> Result<()> {
+        // encode event
+        let json = serde_json::to_string(&notify).unwrap();
+        let payload = json.as_bytes();
+        let len = payload.len().to_be_bytes();
+        log::debug!("broadcasting event to streams: {json}");
+        let mut keep = vec![];
+        // TODO do simultaneously
+        for tx in self.tx_streams.iter_mut() {
+            // write len + payload
+            if tx.write(&len).await.is_err() {
+                keep.push(false);
+                continue;
+            }
+            if tx.write(payload).await.is_err() {
+                keep.push(false);
+                continue;
+            }
+            keep.push(true);
+        }
+
+        // could not find a better solution because async
+        let mut keep = keep.into_iter();
+        self.tx_streams.retain(|_| keep.next().unwrap());
+        Ok(())
+    }
+}
+
+#[cfg(unix)]
+impl Drop for FrontendListener {
+    fn drop(&mut self) {
+        log::debug!("remove socket: {:?}", self.socket_path);
+        let _ = std::fs::remove_file(&self.socket_path);
+    }
+}
+
+#[cfg(unix)]
+pub async fn wait_for_request(stream: &mut ReadHalf<UnixStream>) -> Result<FrontendRequest> {
+    let len = stream.read_u64().await?;
+    assert!(len <= 256);
+    let mut buf = [0u8; 256];
+    stream.read_exact(&mut buf[..len as usize]).await?;
+    Ok(serde_json::from_slice(&buf[..len as usize])?)
+}
+
+#[cfg(windows)]
+pub async fn wait_for_request(stream: &mut ReadHalf<TcpStream>) -> Result<FrontendRequest> {
+    let len = stream.read_u64().await?;
+    let mut buf = [0u8; 256];
+    stream.read_exact(&mut buf[..len as usize]).await?;
+    Ok(serde_json::from_slice(&buf[..len as usize])?)
+}
--- a/lan-mouse-cli/src/lib.rs
+++ b/lan-mouse-cli/src/lib.rs
@@ -1,65 +1,78 @@
-use futures::StreamExt;
+use anyhow::{anyhow, Result};
 use tokio::{
-    io::{AsyncBufReadExt, BufReader},
+    io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader},
    task::LocalSet,
 };

+#[cfg(windows)]
+use tokio::net::tcp::{ReadHalf, WriteHalf};
+#[cfg(unix)]
+use tokio::net::unix::{ReadHalf, WriteHalf};
+
 use std::io::{self, Write};

+use crate::{
+    client::{ClientConfig, ClientHandle, ClientState},
+    config::DEFAULT_PORT,
+};
+
 use self::command::{Command, CommandType};

-use lan_mouse_ipc::{
-    AsyncFrontendEventReader, AsyncFrontendRequestWriter, ClientConfig, ClientHandle, ClientState,
-    FrontendEvent, FrontendRequest, IpcError, DEFAULT_PORT,
-};
+use super::{FrontendEvent, FrontendRequest};

 mod command;

-pub fn run() -> Result<(), IpcError> {
+pub fn run() -> Result<()> {
+    let Ok(stream) = super::wait_for_service() else {
+        return Err(anyhow!("Could not connect to lan-mouse-socket"));
+    };
+
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_io()
        .enable_time()
        .build()?;
    runtime.block_on(LocalSet::new().run_until(async move {
-        let (rx, tx) = lan_mouse_ipc::connect_async().await?;
+        stream.set_nonblocking(true)?;
+        #[cfg(unix)]
+        let mut stream = tokio::net::UnixStream::from_std(stream)?;
+        #[cfg(windows)]
+        let mut stream = tokio::net::TcpStream::from_std(stream)?;
+        let (rx, tx) = stream.split();
+
        let mut cli = Cli::new(rx, tx);
        cli.run().await
    }))?;
    Ok(())
 }

-struct Cli {
+struct Cli<'a> {
    clients: Vec<(ClientHandle, ClientConfig, ClientState)>,
-    changed: Option<ClientHandle>,
-    rx: AsyncFrontendEventReader,
-    tx: AsyncFrontendRequestWriter,
+    rx: ReadHalf<'a>,
+    tx: WriteHalf<'a>,
 }

-impl Cli {
-    fn new(rx: AsyncFrontendEventReader, tx: AsyncFrontendRequestWriter) -> Cli {
+impl<'a> Cli<'a> {
+    fn new(rx: ReadHalf<'a>, tx: WriteHalf<'a>) -> Cli<'a> {
        Self {
            clients: vec![],
-            changed: None,
            rx,
            tx,
        }
    }

-    async fn run(&mut self) -> Result<(), IpcError> {
+    async fn run(&mut self) -> Result<()> {
        let stdin = tokio::io::stdin();
        let stdin = BufReader::new(stdin);
        let mut stdin = stdin.lines();

        /* initial state sync */
+        let request = FrontendRequest::Enumerate();
+        self.send_request(request).await?;
+
        self.clients = loop {
-            match self.rx.next().await {
-                Some(Ok(e)) => {
-                    if let FrontendEvent::Enumerate(clients) = e {
-                        break clients;
-                    }
-                }
-                Some(Err(e)) => return Err(e),
-                None => return Ok(()),
+            let event = self.await_event().await?;
+            if let FrontendEvent::Enumerate(clients) = event {
+                break clients;
            }
        };

@@ -79,23 +92,18 @@ impl Cli {
                    };
                    self.execute(cmd).await?;
                }
-                event = self.rx.next() => {
-                    if let Some(event) = event {
-                        self.handle_event(event?);
-                    } else {
-                        break Ok(());
-                    }
+                event = self.await_event() => {
+                    let event = event?;
+                    self.handle_event(event);
                }
            }
-            if let Some(handle) = self.changed.take() {
-                self.update_client(handle).await?;
-            }
        }
    }

-    async fn update_client(&mut self, handle: ClientHandle) -> Result<(), IpcError> {
-        self.tx.request(FrontendRequest::GetState(handle)).await?;
-        while let Some(Ok(event)) = self.rx.next().await {
+    async fn update_client(&mut self, handle: ClientHandle) -> Result<()> {
+        self.send_request(FrontendRequest::GetState(handle)).await?;
+        loop {
+            let event = self.await_event().await?;
            self.handle_event(event.clone());
            if let FrontendEvent::State(_, _, _) | FrontendEvent::NoSuchClient(_) = event {
                break;
@@ -104,23 +112,22 @@ impl Cli {
        Ok(())
    }

-    async fn execute(&mut self, cmd: Command) -> Result<(), IpcError> {
+    async fn execute(&mut self, cmd: Command) -> Result<()> {
        match cmd {
            Command::None => {}
            Command::Connect(pos, host, port) => {
                let request = FrontendRequest::Create;
-                self.tx.request(request).await?;
+                self.send_request(request).await?;
                let handle = loop {
-                    if let Some(Ok(event)) = self.rx.next().await {
-                        match event {
-                            FrontendEvent::Created(h, c, s) => {
-                                self.clients.push((h, c, s));
-                                break h;
-                            }
-                            _ => {
-                                self.handle_event(event);
-                                continue;
-                            }
+                    let event = self.await_event().await?;
+                    match event {
+                        FrontendEvent::Created(h, c, s) => {
+                            self.clients.push((h, c, s));
+                            break h;
+                        }
+                        _ => {
+                            self.handle_event(event);
+                            continue;
                        }
                    }
                };
@@ -129,36 +136,35 @@ impl Cli {
                    FrontendRequest::UpdatePort(handle, port.unwrap_or(DEFAULT_PORT)),
                    FrontendRequest::UpdatePosition(handle, pos),
                ] {
-                    self.tx.request(request).await?;
+                    self.send_request(request).await?;
                }
                self.update_client(handle).await?;
            }
            Command::Disconnect(id) => {
-                self.tx.request(FrontendRequest::Delete(id)).await?;
+                self.send_request(FrontendRequest::Delete(id)).await?;
                loop {
-                    if let Some(Ok(event)) = self.rx.next().await {
-                        self.handle_event(event.clone());
-                        if let FrontendEvent::Deleted(_) = event {
-                            self.handle_event(event);
-                            break;
-                        }
+                    let event = self.await_event().await?;
+                    self.handle_event(event.clone());
+                    if let FrontendEvent::Deleted(_) = event {
+                        self.handle_event(event);
+                        break;
                    }
                }
            }
            Command::Activate(id) => {
-                self.tx.request(FrontendRequest::Activate(id, true)).await?;
+                self.send_request(FrontendRequest::Activate(id, true))
+                    .await?;
                self.update_client(id).await?;
            }
            Command::Deactivate(id) => {
-                self.tx
-                    .request(FrontendRequest::Activate(id, false))
+                self.send_request(FrontendRequest::Activate(id, false))
                    .await?;
                self.update_client(id).await?;
            }
            Command::List => {
-                self.tx.request(FrontendRequest::Enumerate()).await?;
-                while let Some(e) = self.rx.next().await {
-                    let event = e?;
+                self.send_request(FrontendRequest::Enumerate()).await?;
+                loop {
+                    let event = self.await_event().await?;
                    self.handle_event(event.clone());
                    if let FrontendEvent::Enumerate(_) = event {
                        break;
@@ -167,12 +173,12 @@ impl Cli {
            }
            Command::SetHost(handle, host) => {
                let request = FrontendRequest::UpdateHostname(handle, Some(host.clone()));
-                self.tx.request(request).await?;
+                self.send_request(request).await?;
                self.update_client(handle).await?;
            }
            Command::SetPort(handle, port) => {
                let request = FrontendRequest::UpdatePort(handle, port.unwrap_or(DEFAULT_PORT));
-                self.tx.request(request).await?;
+                self.send_request(request).await?;
                self.update_client(handle).await?;
            }
            Command::Help => {
@@ -209,7 +215,6 @@ impl Cli {

    fn handle_event(&mut self, event: FrontendEvent) {
        match event {
-            FrontendEvent::Changed(h) => self.changed = Some(h),
            FrontendEvent::Created(h, c, s) => {
                eprint!("client added ({h}): ");
                print_config(&c);
@@ -268,12 +273,6 @@ impl Cli {
            FrontendEvent::Error(e) => {
                eprintln!("ERROR: {e}");
            }
-            FrontendEvent::CaptureStatus(s) => {
-                eprintln!("capture status: {s:?}")
-            }
-            FrontendEvent::EmulationStatus(s) => {
-                eprintln!("emulation status: {s:?}")
-            }
        }
    }

@@ -286,6 +285,23 @@ impl Cli {
            eprintln!();
        }
    }
+
+    async fn send_request(&mut self, request: FrontendRequest) -> io::Result<()> {
+        let json = serde_json::to_string(&request).unwrap();
+        let bytes = json.as_bytes();
+        let len = bytes.len();
+        self.tx.write_u64(len as u64).await?;
+        self.tx.write_all(bytes).await?;
+        Ok(())
+    }
+
+    async fn await_event(&mut self) -> Result<FrontendEvent> {
+        let len = self.rx.read_u64().await?;
+        let mut buf = vec![0u8; len as usize];
+        self.rx.read_exact(&mut buf).await?;
+        let event: FrontendEvent = serde_json::from_slice(&buf)?;
+        Ok(event)
+    }
 }

 fn prompt() -> io::Result<()> {
--- a/lan-mouse-cli/src/command.rs
+++ b/lan-mouse-cli/src/command.rs
@@ -3,7 +3,7 @@ use std::{
    str::{FromStr, SplitWhitespace},
 };

-use lan_mouse_ipc::{ClientHandle, Position};
+use crate::client::{ClientHandle, Position};

 pub(super) enum CommandType {
    NoCommand,
--- a/src/frontend/gtk.rs
+++ b/src/frontend/gtk.rs
@@ -0,0 +1,158 @@
+mod client_object;
+mod client_row;
+mod window;
+
+use std::{
+    env,
+    io::{ErrorKind, Read},
+    process, str,
+};
+
+use crate::frontend::{gtk::window::Window, FrontendRequest};
+
+use adw::Application;
+use endi::{Endian, ReadBytes};
+use gtk::{
+    gdk::Display, glib::clone, prelude::*, subclass::prelude::ObjectSubclassIsExt, IconTheme,
+};
+use gtk::{gio, glib, prelude::ApplicationExt};
+
+use self::client_object::ClientObject;
+
+use super::FrontendEvent;
+
+pub fn run() -> glib::ExitCode {
+    log::debug!("running gtk frontend");
+    #[cfg(windows)]
+    let ret = std::thread::Builder::new()
+        .stack_size(8 * 1024 * 1024) // https://gitlab.gnome.org/GNOME/gtk/-/commit/52dbb3f372b2c3ea339e879689c1de535ba2c2c3 -> caused crash on windows
+        .name("gtk".into())
+        .spawn(gtk_main)
+        .unwrap()
+        .join()
+        .unwrap();
+    #[cfg(not(windows))]
+    let ret = gtk_main();
+
+    if ret == glib::ExitCode::FAILURE {
+        log::error!("frontend exited with failure");
+    } else {
+        log::info!("frontend exited successfully");
+    }
+
+    ret
+}
+
+fn gtk_main() -> glib::ExitCode {
+    gio::resources_register_include!("lan-mouse.gresource").expect("Failed to register resources.");
+
+    let app = Application::builder()
+        .application_id("de.feschber.LanMouse")
+        .build();
+
+    app.connect_startup(|_| load_icons());
+    app.connect_activate(build_ui);
+
+    let args: Vec<&'static str> = vec![];
+    app.run_with_args(&args)
+}
+
+fn load_icons() {
+    let display = &Display::default().expect("Could not connect to a display.");
+    let icon_theme = IconTheme::for_display(display);
+    icon_theme.add_resource_path("/de/feschber/LanMouse/icons");
+}
+
+fn build_ui(app: &Application) {
+    log::debug!("connecting to lan-mouse-socket");
+    let mut rx = match super::wait_for_service() {
+        Ok(stream) => stream,
+        Err(e) => {
+            log::error!("could not connect to lan-mouse-socket: {e}");
+            process::exit(1);
+        }
+    };
+    let tx = match rx.try_clone() {
+        Ok(sock) => sock,
+        Err(e) => {
+            log::error!("{e}");
+            process::exit(1);
+        }
+    };
+    log::debug!("connected to lan-mouse-socket");
+
+    let (sender, receiver) = async_channel::bounded(10);
+
+    gio::spawn_blocking(move || {
+        match loop {
+            // read length
+            let len = match rx.read_u64(Endian::Big) {
+                Ok(l) => l,
+                Err(e) if e.kind() == ErrorKind::UnexpectedEof => break Ok(()),
+                Err(e) => break Err(e),
+            };
+
+            // read payload
+            let mut buf = vec![0u8; len as usize];
+            match rx.read_exact(&mut buf) {
+                Ok(_) => (),
+                Err(e) if e.kind() == ErrorKind::UnexpectedEof => break Ok(()),
+                Err(e) => break Err(e),
+            };
+
+            // parse json
+            let json = str::from_utf8(&buf).unwrap();
+            match serde_json::from_str(json) {
+                Ok(notify) => sender.send_blocking(notify).unwrap(),
+                Err(e) => log::error!("{e}"),
+            }
+        } {
+            Ok(()) => {}
+            Err(e) => log::error!("{e}"),
+        }
+    });
+
+    let window = Window::new(app, tx);
+    window.request(FrontendRequest::Enumerate());
+
+    glib::spawn_future_local(clone!(@weak window => async move {
+        loop {
+            let notify = receiver.recv().await.unwrap_or_else(|_| process::exit(1));
+            match notify {
+                FrontendEvent::Created(handle, client, state) => {
+                    window.new_client(handle, client, state);
+                },
+                FrontendEvent::Deleted(client) => {
+                    window.delete_client(client);
+                }
+                FrontendEvent::State(handle, config, state) => {
+                    window.update_client_config(handle, config);
+                    window.update_client_state(handle, state);
+                }
+                FrontendEvent::NoSuchClient(_) => { }
+                FrontendEvent::Error(e) => {
+                    window.show_toast(e.as_str());
+                },
+                FrontendEvent::Enumerate(clients) => {
+                    for (handle, client, state) in clients {
+                        if window.client_idx(handle).is_some() {
+                            window.update_client_config(handle, client);
+                            window.update_client_state(handle, state);
+                        } else {
+                            window.new_client(handle, client, state);
+                        }
+                    }
+                },
+                FrontendEvent::PortChanged(port, msg) => {
+                    match msg {
+                        None => window.show_toast(format!("port changed: {port}").as_str()),
+                        Some(msg) => window.show_toast(msg.as_str()),
+                    }
+                    window.imp().set_port(port);
+                }
+            }
+        }
+    }));
+
+    window.present();
+}
--- a/lan-mouse-gtk/src/client_object.rs
+++ b/lan-mouse-gtk/src/client_object.rs
@@ -3,7 +3,7 @@ mod imp;
 use adw::subclass::prelude::*;
 use gtk::glib::{self, Object};

-use lan_mouse_ipc::{ClientConfig, ClientHandle, ClientState};
+use crate::client::{ClientConfig, ClientHandle, ClientState};

 glib::wrapper! {
    pub struct ClientObject(ObjectSubclass<imp::ClientObject>);
--- a/lan-mouse-gtk/src/client_object/imp.rs
+++ b/lan-mouse-gtk/src/client_object/imp.rs
@@ -5,7 +5,7 @@ use gtk::glib;
 use gtk::prelude::*;
 use gtk::subclass::prelude::*;

-use lan_mouse_ipc::ClientHandle;
+use crate::client::ClientHandle;

 use super::ClientData;

--- a/lan-mouse-gtk/src/client_row.rs
+++ b/lan-mouse-gtk/src/client_row.rs
@@ -4,7 +4,7 @@ use adw::prelude::*;
 use adw::subclass::prelude::*;
 use gtk::glib::{self, Object};

-use lan_mouse_ipc::DEFAULT_PORT;
+use crate::config::DEFAULT_PORT;

 use super::ClientObject;

--- a/lan-mouse-gtk/src/client_row/imp.rs
+++ b/lan-mouse-gtk/src/client_row/imp.rs
@@ -52,13 +52,10 @@ impl ObjectSubclass for ClientRow {
 impl ObjectImpl for ClientRow {
    fn constructed(&self) {
        self.parent_constructed();
-        self.delete_button.connect_clicked(clone!(
-            #[weak(rename_to = row)]
-            self,
-            move |button| {
+        self.delete_button
+            .connect_clicked(clone!(@weak self as row => move |button| {
                row.handle_client_delete(button);
-            }
-        ));
+            }));
    }

    fn signals() -> &'static [glib::subclass::Signal] {
--- a/lan-mouse-gtk/src/window.rs
+++ b/lan-mouse-gtk/src/window.rs
@@ -1,7 +1,16 @@
 mod imp;

+use std::io::Write;
+
+#[cfg(unix)]
+use std::os::unix::net::UnixStream;
+
+#[cfg(windows)]
+use std::net::TcpStream;
+
 use adw::prelude::*;
 use adw::subclass::prelude::*;
+use endi::{Endian, WriteBytes};
 use glib::{clone, Object};
 use gtk::{
    gio,
@@ -9,12 +18,13 @@ use gtk::{
    ListBox, NoSelection,
 };

-use lan_mouse_ipc::{
-    ClientConfig, ClientHandle, ClientState, FrontendRequest, FrontendRequestWriter, Position,
-    DEFAULT_PORT,
+use crate::{
+    client::{ClientConfig, ClientHandle, ClientState, Position},
+    config::DEFAULT_PORT,
+    frontend::{gtk::client_object::ClientObject, FrontendRequest},
 };

-use super::{client_object::ClientObject, client_row::ClientRow};
+use super::client_row::ClientRow;

 glib::wrapper! {
    pub struct Window(ObjectSubclass<imp::Window>)
@@ -24,13 +34,13 @@ glib::wrapper! {
 }

 impl Window {
-    pub(crate) fn new(app: &adw::Application, conn: FrontendRequestWriter) -> Self {
+    pub(crate) fn new(
+        app: &adw::Application,
+        #[cfg(unix)] tx: UnixStream,
+        #[cfg(windows)] tx: TcpStream,
+    ) -> Self {
        let window: Self = Object::builder().property("application", app).build();
-        window
-            .imp()
-            .frontend_request_writer
-            .borrow_mut()
-            .replace(conn);
+        window.imp().stream.borrow_mut().replace(tx);
        window
    }

@@ -53,61 +63,31 @@ impl Window {
        let selection_model = NoSelection::new(Some(self.clients()));
        self.imp().client_list.bind_model(
            Some(&selection_model),
-            clone!(
-                #[weak(rename_to = window)]
-                self,
-                #[upgrade_or_panic]
-                move |obj| {
-                    let client_object = obj
-                        .downcast_ref()
-                        .expect("Expected object of type `ClientObject`.");
-                    let row = window.create_client_row(client_object);
-                    row.connect_closure(
-                        "request-update",
-                        false,
-                        closure_local!(
-                            #[strong]
-                            window,
-                            move |row: ClientRow, active: bool| {
-                                if let Some(client) = window.client_by_idx(row.index() as u32) {
-                                    window.request_client_activate(&client, active);
-                                    window.request_client_update(&client);
-                                    window.request_client_state(&client);
-                                }
-                            }
-                        ),
-                    );
-                    row.connect_closure(
-                        "request-delete",
-                        false,
-                        closure_local!(
-                            #[strong]
-                            window,
-                            move |row: ClientRow| {
-                                if let Some(client) = window.client_by_idx(row.index() as u32) {
-                                    window.request_client_delete(&client);
-                                }
-                            }
-                        ),
-                    );
-                    row.connect_closure(
-                        "request-dns",
-                        false,
-                        closure_local!(
-                            #[strong]
-                            window,
-                            move |row: ClientRow| {
-                                if let Some(client) = window.client_by_idx(row.index() as u32) {
-                                    window.request_client_update(&client);
-                                    window.request_dns(&client);
-                                    window.request_client_state(&client);
-                                }
-                            }
-                        ),
-                    );
-                    row.upcast()
-                }
-            ),
+            clone!(@weak self as window => @default-panic, move |obj| {
+                let client_object = obj.downcast_ref().expect("Expected object of type `ClientObject`.");
+                let row = window.create_client_row(client_object);
+                row.connect_closure("request-update", false, closure_local!(@strong window => move |row: ClientRow, active: bool| {
+                    if let Some(client) = window.client_by_idx(row.index() as u32) {
+                        window.request_client_activate(&client, active);
+                        window.request_client_update(&client);
+                        window.request_client_state(&client);
+                    }
+                }));
+                row.connect_closure("request-delete", false, closure_local!(@strong window => move |row: ClientRow| {
+                    if let Some(client) = window.client_by_idx(row.index() as u32) {
+                        window.request_client_delete(&client);
+                    }
+                }));
+                row.connect_closure("request-dns", false, closure_local!(@strong window => move
+                |row: ClientRow| {
+                    if let Some(client) = window.client_by_idx(row.index() as u32) {
+                        window.request_client_update(&client);
+                        window.request_dns(&client);
+                        window.request_client_state(&client);
+                    }
+                }));
+                row.upcast()
+            })
        );
    }

@@ -227,39 +207,29 @@ impl Window {
    }

    pub fn request_port_change(&self) {
-        let port = self
-            .imp()
-            .port_entry
-            .get()
-            .text()
-            .as_str()
-            .parse::<u16>()
-            .unwrap_or(DEFAULT_PORT);
-        self.request(FrontendRequest::ChangePort(port));
-    }
-
-    pub fn request_capture(&self) {
-        self.request(FrontendRequest::EnableCapture);
-    }
-
-    pub fn request_emulation(&self) {
-        self.request(FrontendRequest::EnableEmulation);
+        let port = self.imp().port_entry.get().text().to_string();
+        if let Ok(port) = port.as_str().parse::<u16>() {
+            self.request(FrontendRequest::ChangePort(port));
+        } else {
+            self.request(FrontendRequest::ChangePort(DEFAULT_PORT));
+        }
    }

    pub fn request_client_state(&self, client: &ClientObject) {
-        self.request_client_state_for(client.handle());
-    }
-
-    pub fn request_client_state_for(&self, handle: ClientHandle) {
-        self.request(FrontendRequest::GetState(handle));
+        let handle = client.handle();
+        let event = FrontendRequest::GetState(handle);
+        self.request(event);
    }

    pub fn request_client_create(&self) {
-        self.request(FrontendRequest::Create);
+        let event = FrontendRequest::Create;
+        self.request(event);
    }

    pub fn request_dns(&self, client: &ClientObject) {
-        self.request(FrontendRequest::ResolveDns(client.get_data().handle));
+        let data = client.get_data();
+        let event = FrontendRequest::ResolveDns(data.handle);
+        self.request(event);
    }

    pub fn request_client_update(&self, client: &ClientObject) {
@@ -279,17 +249,27 @@ impl Window {
    }

    pub fn request_client_activate(&self, client: &ClientObject, active: bool) {
-        self.request(FrontendRequest::Activate(client.handle(), active));
+        let handle = client.handle();
+        let event = FrontendRequest::Activate(handle, active);
+        self.request(event);
    }

    pub fn request_client_delete(&self, client: &ClientObject) {
-        self.request(FrontendRequest::Delete(client.handle()));
+        let handle = client.handle();
+        let event = FrontendRequest::Delete(handle);
+        self.request(event);
    }

-    pub fn request(&self, request: FrontendRequest) {
-        let mut requester = self.imp().frontend_request_writer.borrow_mut();
-        let requester = requester.as_mut().unwrap();
-        if let Err(e) = requester.request(request) {
+    pub fn request(&self, event: FrontendRequest) {
+        let json = serde_json::to_string(&event).unwrap();
+        log::debug!("requesting: {json}");
+        let mut stream = self.imp().stream.borrow_mut();
+        let stream = stream.as_mut().unwrap();
+        let bytes = json.as_bytes();
+        if let Err(e) = stream.write_u64(Endian::Big, bytes.len() as u64) {
+            log::error!("error sending message: {e}");
+        };
+        if let Err(e) = stream.write(bytes) {
            log::error!("error sending message: {e}");
        };
    }
@@ -299,24 +279,4 @@ impl Window {
        let toast_overlay = &self.imp().toast_overlay;
        toast_overlay.add_toast(toast);
    }
-
-    pub fn set_capture(&self, active: bool) {
-        self.imp().capture_active.replace(active);
-        self.update_capture_emulation_status();
-    }
-
-    pub fn set_emulation(&self, active: bool) {
-        self.imp().emulation_active.replace(active);
-        self.update_capture_emulation_status();
-    }
-
-    fn update_capture_emulation_status(&self) {
-        let capture = self.imp().capture_active.get();
-        let emulation = self.imp().emulation_active.get();
-        self.imp().capture_status_row.set_visible(!capture);
-        self.imp().emulation_status_row.set_visible(!emulation);
-        self.imp()
-            .capture_emulation_group
-            .set_visible(!capture || !emulation);
-    }
 }
--- a/lan-mouse-gtk/src/window/imp.rs
+++ b/lan-mouse-gtk/src/window/imp.rs
@@ -1,12 +1,17 @@
 use std::cell::{Cell, RefCell};

+#[cfg(windows)]
+use std::net::TcpStream;
+#[cfg(unix)]
+use std::os::unix::net::UnixStream;
+
 use adw::subclass::prelude::*;
-use adw::{prelude::*, ActionRow, PreferencesGroup, ToastOverlay};
+use adw::{prelude::*, ActionRow, ToastOverlay};
 use glib::subclass::InitializingObject;
 use gtk::glib::clone;
 use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, Label, ListBox};

-use lan_mouse_ipc::{FrontendRequestWriter, DEFAULT_PORT};
+use crate::config::DEFAULT_PORT;

 #[derive(CompositeTemplate, Default)]
 #[template(resource = "/de/feschber/LanMouse/window.ui")]
@@ -25,21 +30,12 @@ pub struct Window {
    pub hostname_label: TemplateChild<Label>,
    #[template_child]
    pub toast_overlay: TemplateChild<ToastOverlay>,
-    #[template_child]
-    pub capture_emulation_group: TemplateChild<PreferencesGroup>,
-    #[template_child]
-    pub capture_status_row: TemplateChild<ActionRow>,
-    #[template_child]
-    pub emulation_status_row: TemplateChild<ActionRow>,
-    #[template_child]
-    pub input_emulation_button: TemplateChild<Button>,
-    #[template_child]
-    pub input_capture_button: TemplateChild<Button>,
    pub clients: RefCell<Option<gio::ListStore>>,
-    pub frontend_request_writer: RefCell<Option<FrontendRequestWriter>>,
+    #[cfg(unix)]
+    pub stream: RefCell<Option<UnixStream>>,
+    #[cfg(windows)]
+    pub stream: RefCell<Option<TcpStream>>,
    pub port: Cell<u16>,
-    pub capture_active: Cell<bool>,
-    pub emulation_active: Cell<bool>,
 }

 #[glib::object_subclass]
@@ -76,15 +72,11 @@ impl Window {
            clipboard.set_text(hostname.to_str().expect("hostname: invalid utf8"));
            button.set_icon_name("emblem-ok-symbolic");
            button.set_css_classes(&["success"]);
-            glib::spawn_future_local(clone!(
-                #[weak]
-                button,
-                async move {
-                    glib::timeout_future_seconds(1).await;
-                    button.set_icon_name("edit-copy-symbolic");
-                    button.set_css_classes(&[]);
-                }
-            ));
+            glib::spawn_future_local(clone!(@weak button => async move {
+                glib::timeout_future_seconds(1).await;
+                button.set_icon_name("edit-copy-symbolic");
+                button.set_css_classes(&[]);
+            }));
        }
    }

@@ -108,16 +100,6 @@ impl Window {
        self.port_edit_cancel.set_visible(false);
    }

-    #[template_callback]
-    fn handle_emulation(&self) {
-        self.obj().request_emulation();
-    }
-
-    #[template_callback]
-    fn handle_capture(&self) {
-        self.obj().request_capture();
-    }
-
    pub fn set_port(&self, port: u16) {
        self.port.set(port);
        if port == DEFAULT_PORT {
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,3 +5,4 @@ pub mod server;

 pub mod capture_test;
 pub mod emulation_test;
+pub mod frontend;
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,36 +1,10 @@
-use env_logger::Env;
-use input_capture::InputCaptureError;
-use input_emulation::InputEmulationError;
-use lan_mouse::{
-    capture_test,
-    config::{Config, ConfigError, Frontend},
-    emulation_test,
-    server::{Server, ServiceError},
-};
-use lan_mouse_ipc::IpcError;
-use std::{
-    future::Future,
-    io,
-    process::{self, Child, Command},
-};
-use thiserror::Error;
-use tokio::task::LocalSet;
+use anyhow::Result;
+use std::process::{self, Child, Command};

-#[derive(Debug, Error)]
-enum LanMouseError {
-    #[error(transparent)]
-    Service(#[from] ServiceError),
-    #[error(transparent)]
-    IpcError(#[from] IpcError),
-    #[error(transparent)]
-    Config(#[from] ConfigError),
-    #[error(transparent)]
-    Io(#[from] io::Error),
-    #[error(transparent)]
-    Capture(#[from] InputCaptureError),
-    #[error(transparent)]
-    Emulation(#[from] InputEmulationError),
-}
+use env_logger::Env;
+use lan_mouse::{capture_test, config::Config, emulation_test, frontend, server::Server};
+
+use tokio::task::LocalSet;

 pub fn main() {
    // init logging
@@ -43,24 +17,32 @@ pub fn main() {
    }
 }

-fn run() -> Result<(), LanMouseError> {
+pub fn start_service() -> Result<Child> {
+    let child = Command::new(std::env::current_exe()?)
+        .args(std::env::args().skip(1))
+        .arg("--daemon")
+        .spawn()?;
+    Ok(child)
+}
+
+pub fn run() -> Result<()> {
    // parse config file + cli args
    let config = Config::new()?;
    log::debug!("{config:?}");
    log::info!("release bind: {:?}", config.release_bind);

    if config.test_capture {
-        run_async(capture_test::run(config))?;
+        capture_test::run()?;
    } else if config.test_emulation {
-        run_async(emulation_test::run(config))?;
+        emulation_test::run()?;
    } else if config.daemon {
        // if daemon is specified we run the service
-        run_async(run_service(config))?;
+        run_service(&config)?;
    } else {
        //  otherwise start the service as a child process and
        //  run a frontend
        let mut service = start_service()?;
-        run_frontend(&config)?;
+        frontend::run_frontend(&config)?;
        #[cfg(unix)]
        {
            // on unix we give the service a chance to terminate gracefully
@@ -73,14 +55,10 @@ fn run() -> Result<(), LanMouseError> {
        service.kill()?;
    }

-    Ok(())
+    anyhow::Ok(())
 }

-fn run_async<F, E>(f: F) -> Result<(), LanMouseError>
-where
-    F: Future<Output = Result<(), E>>,
-    LanMouseError: From<E>,
-{
+fn run_service(config: &Config) -> Result<()> {
    // create single threaded tokio runtime
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_io()
@@ -88,35 +66,17 @@ where
        .build()?;

    // run async event loop
-    Ok(runtime.block_on(LocalSet::new().run_until(f))?)
-}
+    runtime.block_on(LocalSet::new().run_until(async {
+        // run main loop
+        log::info!("Press {:?} to release the mouse", config.release_bind);

-fn start_service() -> Result<Child, io::Error> {
-    let child = Command::new(std::env::current_exe()?)
-        .args(std::env::args().skip(1))
-        .arg("--daemon")
-        .spawn()?;
-    Ok(child)
-}
+        let server = Server::new(config);
+        server
+            .run(config.capture_backend, config.emulation_backend)
+            .await?;

-async fn run_service(config: Config) -> Result<(), ServiceError> {
-    log::info!("Press {:?} to release the mouse", config.release_bind);
-    Server::new(config).run().await?;
-    log::info!("service exited!");
-    Ok(())
-}
-
-fn run_frontend(config: &Config) -> Result<(), IpcError> {
-    match config.frontend {
-        #[cfg(feature = "gtk")]
-        Frontend::Gtk => {
-            lan_mouse_gtk::run();
-        }
-        #[cfg(not(feature = "gtk"))]
-        Frontend::Gtk => panic!("gtk frontend requested but feature not enabled!"),
-        Frontend::Cli => {
-            lan_mouse_cli::run()?;
-        }
-    };
+        log::debug!("service exiting");
+        anyhow::Ok(())
+    }))?;
    Ok(())
 }
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,31 +1,27 @@
-use capture_task::CaptureRequest;
-use emulation_task::EmulationRequest;
-use futures::StreamExt;
-use hickory_resolver::error::ResolveError;
-use local_channel::mpsc::{channel, Sender};
 use log;
 use std::{
    cell::{Cell, RefCell},
-    collections::{HashSet, VecDeque},
-    io,
-    net::{IpAddr, SocketAddr},
+    collections::HashSet,
    rc::Rc,
 };
-use thiserror::Error;
-use tokio::{join, signal, sync::Notify};
-use tokio_util::sync::CancellationToken;
+use tokio::signal;

-use crate::{client::ClientManager, config::Config, dns::DnsResolver};
-
-use lan_mouse_ipc::{
-    AsyncFrontendListener, ClientConfig, ClientHandle, ClientState, FrontendEvent, FrontendRequest,
-    ListenerCreationError, Position, Status,
+use crate::{
+    client::{ClientConfig, ClientHandle, ClientManager, ClientState},
+    config::{CaptureBackend, Config, EmulationBackend},
+    dns,
+    frontend::{FrontendListener, FrontendRequest},
+    server::capture_task::CaptureEvent,
 };

+use self::{emulation_task::EmulationEvent, resolver_task::DnsRequest};
+
 mod capture_task;
 mod emulation_task;
+mod frontend_task;
 mod network_task;
 mod ping_task;
+mod resolver_task;

 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum State {
@@ -35,47 +31,22 @@ enum State {
    Receiving,
    /// Entered the deadzone of another device but waiting
    /// for acknowledgement (Leave event) from the device
-    AwaitAck,
-}
-
-#[derive(Debug, Error)]
-pub enum ServiceError {
-    #[error(transparent)]
-    Dns(#[from] ResolveError),
-    #[error(transparent)]
-    Listen(#[from] ListenerCreationError),
-    #[error(transparent)]
-    Io(#[from] io::Error),
+    AwaitingLeave,
 }

 #[derive(Clone)]
 pub struct Server {
    active_client: Rc<Cell<Option<ClientHandle>>>,
-    pub(crate) client_manager: Rc<RefCell<ClientManager>>,
+    client_manager: Rc<RefCell<ClientManager>>,
    port: Rc<Cell<u16>>,
    state: Rc<Cell<State>>,
    release_bind: Vec<input_event::scancode::Linux>,
-    notifies: Rc<Notifies>,
-    config: Rc<Config>,
-    pending_frontend_events: Rc<RefCell<VecDeque<FrontendEvent>>>,
-    capture_status: Rc<Cell<Status>>,
-    emulation_status: Rc<Cell<Status>>,
-}
-
-#[derive(Default)]
-struct Notifies {
-    capture: Notify,
-    emulation: Notify,
-    ping: Notify,
-    port_changed: Notify,
-    frontend_event_pending: Notify,
-    cancel: CancellationToken,
 }

 impl Server {
-    pub fn new(config: Config) -> Self {
+    pub fn new(config: &Config) -> Self {
        let active_client = Rc::new(Cell::new(None));
-        let client_manager = Rc::new(RefCell::new(ClientManager::default()));
+        let client_manager = Rc::new(RefCell::new(ClientManager::new()));
        let state = Rc::new(Cell::new(State::Receiving));
        let port = Rc::new(Cell::new(config.port));
        for config_client in config.get_clients() {
@@ -96,467 +67,153 @@ impl Server {
            let c = client_manager.get_mut(handle).expect("invalid handle");
            *c = (client, state);
        }
-
-        // task notification tokens
-        let notifies = Rc::new(Notifies::default());
        let release_bind = config.release_bind.clone();
-
-        let config = Rc::new(config);
-
        Self {
-            config,
            active_client,
            client_manager,
            port,
            state,
            release_bind,
-            notifies,
-            pending_frontend_events: Rc::new(RefCell::new(VecDeque::new())),
-            capture_status: Default::default(),
-            emulation_status: Default::default(),
        }
    }

-    pub async fn run(&mut self) -> Result<(), ServiceError> {
-        // create frontend communication adapter, exit if already running
-        let mut frontend = match AsyncFrontendListener::new().await {
-            Ok(f) => f,
-            Err(ListenerCreationError::AlreadyRunning) => {
+    pub async fn run(
+        &self,
+        capture_backend: Option<CaptureBackend>,
+        emulation_backend: Option<EmulationBackend>,
+    ) -> anyhow::Result<()> {
+        // create frontend communication adapter
+        let frontend = match FrontendListener::new().await {
+            Some(f) => f?,
+            None => {
+                // none means some other instance is already running
                log::info!("service already running, exiting");
-                return Ok(());
+                return anyhow::Ok(());
            }
-            e => e?,
        };

-        let (capture_tx, capture_rx) = channel(); /* requests for input capture */
-        let (emulation_tx, emulation_rx) = channel(); /* emulation requests */
-        let (udp_recv_tx, udp_recv_rx) = channel(); /* udp receiver */
-        let (udp_send_tx, udp_send_rx) = channel(); /* udp sender */
-        let (dns_tx, dns_rx) = channel(); /* dns requests */
+        let (timer_tx, timer_rx) = tokio::sync::mpsc::channel(1);
+        let (frontend_notify_tx, frontend_notify_rx) = tokio::sync::mpsc::channel(1);

-        let network = network_task::new(self.clone(), udp_recv_tx.clone(), udp_send_rx).await?;
-        let capture = capture_task::new(self.clone(), capture_rx, udp_send_tx.clone());
-        let emulation =
-            emulation_task::new(self.clone(), emulation_rx, udp_recv_rx, udp_send_tx.clone());
-        let resolver = DnsResolver::new(dns_rx)?;
-        let dns_task = tokio::task::spawn_local(resolver.run(self.clone()));
+        // udp task
+        let (mut udp_task, sender_tx, receiver_rx, port_tx) =
+            network_task::new(self.clone(), frontend_notify_tx.clone()).await?;

-        // task that pings clients to see if they are responding
-        let ping = ping_task::new(
+        // input capture
+        let (mut capture_task, capture_channel) = capture_task::new(
+            capture_backend,
            self.clone(),
-            udp_send_tx.clone(),
-            emulation_tx.clone(),
-            capture_tx.clone(),
+            sender_tx.clone(),
+            timer_tx.clone(),
+            self.release_bind.clone(),
+        )?;
+
+        // input emulation
+        let (mut emulation_task, emulate_channel) = emulation_task::new(
+            emulation_backend,
+            self.clone(),
+            receiver_rx,
+            sender_tx.clone(),
+            capture_channel.clone(),
+            timer_tx,
+        )?;
+
+        // create dns resolver
+        let resolver = dns::DnsResolver::new().await?;
+        let (mut resolver_task, resolve_tx) =
+            resolver_task::new(resolver, self.clone(), frontend_notify_tx);
+
+        // frontend listener
+        let (mut frontend_task, frontend_tx) = frontend_task::new(
+            frontend,
+            frontend_notify_rx,
+            self.clone(),
+            capture_channel.clone(),
+            emulate_channel.clone(),
+            resolve_tx.clone(),
+            port_tx,
        );

-        for handle in self.active_clients() {
-            dns_tx.send(handle).expect("channel closed");
+        // task that pings clients to see if they are responding
+        let mut ping_task = ping_task::new(
+            self.clone(),
+            sender_tx.clone(),
+            emulate_channel.clone(),
+            capture_channel.clone(),
+            timer_rx,
+        );
+
+        let active = self
+            .client_manager
+            .borrow()
+            .get_client_states()
+            .filter_map(|(h, (c, s))| {
+                if s.active {
+                    Some((h, c.hostname.clone()))
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+        for (handle, hostname) in active {
+            frontend_tx
+                .send(FrontendRequest::Activate(handle, true))
+                .await?;
+            if let Some(hostname) = hostname {
+                let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
+            }
+        }
+        log::info!("running service");
+
+        tokio::select! {
+            _ = signal::ctrl_c() => {
+                log::info!("terminating service");
+            }
+            e = &mut capture_task => {
+                if let Ok(Err(e)) = e {
+                    log::error!("error in input capture task: {e}");
+                }
+            }
+            e = &mut emulation_task => {
+                if let Ok(Err(e)) = e {
+                    log::error!("error in input emulation task: {e}");
+                }
+            }
+            e = &mut frontend_task => {
+                if let Ok(Err(e)) = e {
+                    log::error!("error in frontend listener: {e}");
+                }
+            }
+            _ = &mut resolver_task => { }
+            _ = &mut udp_task => { }
+            _ = &mut ping_task => { }
        }

-        loop {
-            tokio::select! {
-                request = frontend.next() => {
-                    let request = match request {
-                        Some(Ok(r)) => r,
-                        Some(Err(e)) => {
-                            log::error!("error receiving request: {e}");
-                            continue;
-                        }
-                        None => break,
-                    };
-                    log::debug!("handle frontend request: {request:?}");
-                    self.handle_request(&capture_tx.clone(), &emulation_tx.clone(), request, &dns_tx);
-                }
-                _ = self.notifies.frontend_event_pending.notified() => {
-                    while let Some(event) = {
-                        /* need to drop borrow before next iteration! */
-                        let event = self.pending_frontend_events.borrow_mut().pop_front();
-                        event
-                    } {
-                        frontend.broadcast(event).await;
-                    }
-                },
-                _ = self.cancelled() => break,
-                r = signal::ctrl_c() => {
-                    r.expect("failed to wait for CTRL+C");
-                    break;
-                }
+        let _ = emulate_channel.send(EmulationEvent::Terminate).await;
+        let _ = capture_channel.send(CaptureEvent::Terminate).await;
+        let _ = frontend_tx.send(FrontendRequest::Terminate()).await;
+
+        if !capture_task.is_finished() {
+            if let Err(e) = capture_task.await {
+                log::error!("error in input capture task: {e}");
+            }
+        }
+        if !emulation_task.is_finished() {
+            if let Err(e) = emulation_task.await {
+                log::error!("error in input emulation task: {e}");
            }
        }

-        log::info!("terminating service");
+        if !frontend_task.is_finished() {
+            if let Err(e) = frontend_task.await {
+                log::error!("error in frontend listener: {e}");
+            }
+        }

-        self.cancel();
-        let _ = join!(capture, dns_task, emulation, network, ping);
+        resolver_task.abort();
+        udp_task.abort();
+        ping_task.abort();

        Ok(())
    }
-
-    fn notify_frontend(&self, event: FrontendEvent) {
-        self.pending_frontend_events.borrow_mut().push_back(event);
-        self.notifies.frontend_event_pending.notify_one();
-    }
-
-    fn cancel(&self) {
-        self.notifies.cancel.cancel();
-    }
-
-    pub(crate) async fn cancelled(&self) {
-        self.notifies.cancel.cancelled().await
-    }
-
-    fn is_cancelled(&self) -> bool {
-        self.notifies.cancel.is_cancelled()
-    }
-
-    fn notify_capture(&self) {
-        log::info!("received capture enable request");
-        self.notifies.capture.notify_waiters()
-    }
-
-    async fn capture_enabled(&self) {
-        self.notifies.capture.notified().await
-    }
-
-    fn notify_emulation(&self) {
-        log::info!("received emulation enable request");
-        self.notifies.emulation.notify_waiters()
-    }
-
-    async fn emulation_notified(&self) {
-        self.notifies.emulation.notified().await
-    }
-
-    fn restart_ping_timer(&self) {
-        self.notifies.ping.notify_waiters()
-    }
-
-    async fn ping_timer_notified(&self) {
-        self.notifies.ping.notified().await
-    }
-
-    fn request_port_change(&self, port: u16) {
-        self.port.replace(port);
-        self.notifies.port_changed.notify_one();
-    }
-
-    fn notify_port_changed(&self, port: u16, msg: Option<String>) {
-        self.port.replace(port);
-        self.notify_frontend(FrontendEvent::PortChanged(port, msg));
-    }
-
-    pub(crate) fn client_updated(&self, handle: ClientHandle) {
-        self.notify_frontend(FrontendEvent::Changed(handle));
-    }
-
-    fn active_clients(&self) -> Vec<ClientHandle> {
-        self.client_manager
-            .borrow()
-            .get_client_states()
-            .filter(|(_, (_, s))| s.active)
-            .map(|(h, _)| h)
-            .collect()
-    }
-
-    fn handle_request(
-        &self,
-        capture: &Sender<CaptureRequest>,
-        emulate: &Sender<EmulationRequest>,
-        event: FrontendRequest,
-        dns: &Sender<ClientHandle>,
-    ) -> bool {
-        log::debug!("frontend: {event:?}");
-        match event {
-            FrontendRequest::EnableCapture => self.notify_capture(),
-            FrontendRequest::EnableEmulation => self.notify_emulation(),
-            FrontendRequest::Create => {
-                self.add_client();
-            }
-            FrontendRequest::Activate(handle, active) => {
-                if active {
-                    self.activate_client(capture, emulate, handle);
-                } else {
-                    self.deactivate_client(capture, emulate, handle);
-                }
-            }
-            FrontendRequest::ChangePort(port) => self.request_port_change(port),
-            FrontendRequest::Delete(handle) => {
-                self.remove_client(capture, emulate, handle);
-                self.notify_frontend(FrontendEvent::Deleted(handle));
-            }
-            FrontendRequest::Enumerate() => self.enumerate(),
-            FrontendRequest::GetState(handle) => self.broadcast_client(handle),
-            FrontendRequest::UpdateFixIps(handle, fix_ips) => self.update_fix_ips(handle, fix_ips),
-            FrontendRequest::UpdateHostname(handle, host) => {
-                self.update_hostname(handle, host, dns)
-            }
-            FrontendRequest::UpdatePort(handle, port) => self.update_port(handle, port),
-            FrontendRequest::UpdatePosition(handle, pos) => {
-                self.update_pos(handle, capture, emulate, pos)
-            }
-            FrontendRequest::ResolveDns(handle) => dns.send(handle).expect("channel closed"),
-            FrontendRequest::Sync => {
-                self.enumerate();
-                self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status.get()));
-                self.notify_frontend(FrontendEvent::CaptureStatus(self.capture_status.get()));
-                self.notify_frontend(FrontendEvent::PortChanged(self.port.get(), None));
-            }
-        };
-        false
-    }
-
-    fn enumerate(&self) {
-        let clients = self
-            .client_manager
-            .borrow()
-            .get_client_states()
-            .map(|(h, (c, s))| (h, c.clone(), s.clone()))
-            .collect();
-        self.notify_frontend(FrontendEvent::Enumerate(clients));
-    }
-
-    fn add_client(&self) -> ClientHandle {
-        let handle = self.client_manager.borrow_mut().add_client();
-        log::info!("added client {handle}");
-        let (c, s) = self.client_manager.borrow().get(handle).unwrap().clone();
-        self.notify_frontend(FrontendEvent::Created(handle, c, s));
-        handle
-    }
-
-    fn deactivate_client(
-        &self,
-        capture: &Sender<CaptureRequest>,
-        emulate: &Sender<EmulationRequest>,
-        handle: ClientHandle,
-    ) {
-        match self.client_manager.borrow_mut().get_mut(handle) {
-            None => return,
-            Some((_, s)) if !s.active => return,
-            Some((_, s)) => s.active = false,
-        };
-
-        let _ = capture.send(CaptureRequest::Destroy(handle));
-        let _ = emulate.send(EmulationRequest::Destroy(handle));
-        self.client_updated(handle);
-        log::info!("deactivated client {handle}");
-    }
-
-    fn activate_client(
-        &self,
-        capture: &Sender<CaptureRequest>,
-        emulate: &Sender<EmulationRequest>,
-        handle: ClientHandle,
-    ) {
-        /* deactivate potential other client at this position */
-        let pos = match self.client_manager.borrow().get(handle) {
-            None => return,
-            Some((_, s)) if s.active => return,
-            Some((client, _)) => client.pos,
-        };
-
-        let other = self.client_manager.borrow_mut().find_client(pos);
-        if let Some(other) = other {
-            self.deactivate_client(capture, emulate, other);
-        }
-
-        /* activate the client */
-        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
-            s.active = true;
-        } else {
-            return;
-        };
-
-        /* notify emulation, capture and frontends */
-        let _ = capture.send(CaptureRequest::Create(handle, to_capture_pos(pos)));
-        let _ = emulate.send(EmulationRequest::Create(handle));
-
-        self.client_updated(handle);
-
-        log::info!("activated client {handle} ({pos})");
-    }
-
-    fn remove_client(
-        &self,
-        capture: &Sender<CaptureRequest>,
-        emulate: &Sender<EmulationRequest>,
-        handle: ClientHandle,
-    ) {
-        let Some(active) = self
-            .client_manager
-            .borrow_mut()
-            .remove_client(handle)
-            .map(|(_, s)| s.active)
-        else {
-            return;
-        };
-
-        if active {
-            let _ = capture.send(CaptureRequest::Destroy(handle));
-            let _ = emulate.send(EmulationRequest::Destroy(handle));
-        }
-    }
-
-    fn update_pressed_keys(&self, handle: ClientHandle, has_pressed_keys: bool) {
-        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
-            s.has_pressed_keys = has_pressed_keys;
-        }
-    }
-
-    fn update_fix_ips(&self, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
-        if let Some((c, _)) = self.client_manager.borrow_mut().get_mut(handle) {
-            c.fix_ips = fix_ips;
-        };
-        self.update_ips(handle);
-        self.client_updated(handle);
-    }
-
-    pub(crate) fn update_dns_ips(&self, handle: ClientHandle, dns_ips: Vec<IpAddr>) {
-        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
-            s.dns_ips = dns_ips;
-        };
-        self.update_ips(handle);
-        self.client_updated(handle);
-    }
-
-    fn update_ips(&self, handle: ClientHandle) {
-        if let Some((c, s)) = self.client_manager.borrow_mut().get_mut(handle) {
-            s.ips = c
-                .fix_ips
-                .iter()
-                .cloned()
-                .chain(s.dns_ips.iter().cloned())
-                .collect::<HashSet<_>>();
-        }
-    }
-
-    fn update_hostname(
-        &self,
-        handle: ClientHandle,
-        hostname: Option<String>,
-        dns: &Sender<ClientHandle>,
-    ) {
-        let mut client_manager = self.client_manager.borrow_mut();
-        let Some((c, s)) = client_manager.get_mut(handle) else {
-            return;
-        };
-
-        // hostname changed
-        if c.hostname != hostname {
-            c.hostname = hostname;
-            s.active_addr = None;
-            s.dns_ips.clear();
-            drop(client_manager);
-            self.update_ips(handle);
-            dns.send(handle).expect("channel closed");
-        }
-        self.client_updated(handle);
-    }
-
-    fn update_port(&self, handle: ClientHandle, port: u16) {
-        let mut client_manager = self.client_manager.borrow_mut();
-        let Some((c, s)) = client_manager.get_mut(handle) else {
-            return;
-        };
-
-        if c.port != port {
-            c.port = port;
-            s.active_addr = s.active_addr.map(|a| SocketAddr::new(a.ip(), port));
-        }
-    }
-
-    fn update_pos(
-        &self,
-        handle: ClientHandle,
-        capture: &Sender<CaptureRequest>,
-        emulate: &Sender<EmulationRequest>,
-        pos: Position,
-    ) {
-        let (changed, active) = {
-            let mut client_manager = self.client_manager.borrow_mut();
-            let Some((c, s)) = client_manager.get_mut(handle) else {
-                return;
-            };
-
-            let changed = c.pos != pos;
-            if changed {
-                log::info!("update pos {handle} {} -> {}", c.pos, pos);
-            }
-            c.pos = pos;
-            (changed, s.active)
-        };
-
-        // update state in event input emulator & input capture
-        if changed {
-            self.deactivate_client(capture, emulate, handle);
-            if active {
-                self.activate_client(capture, emulate, handle);
-            }
-        }
-    }
-
-    fn broadcast_client(&self, handle: ClientHandle) {
-        let client = self.client_manager.borrow().get(handle).cloned();
-        let event = if let Some((config, state)) = client {
-            FrontendEvent::State(handle, config, state)
-        } else {
-            FrontendEvent::NoSuchClient(handle)
-        };
-        self.notify_frontend(event);
-    }
-
-    fn set_emulation_status(&self, status: Status) {
-        self.emulation_status.replace(status);
-        let status = FrontendEvent::EmulationStatus(status);
-        self.notify_frontend(status);
-    }
-
-    fn set_capture_status(&self, status: Status) {
-        self.capture_status.replace(status);
-        let status = FrontendEvent::CaptureStatus(status);
-        self.notify_frontend(status);
-    }
-
-    pub(crate) fn set_resolving(&self, handle: ClientHandle, status: bool) {
-        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
-            s.resolving = status;
-        }
-        self.client_updated(handle);
-    }
-
-    pub(crate) fn get_hostname(&self, handle: ClientHandle) -> Option<String> {
-        self.client_manager
-            .borrow_mut()
-            .get_mut(handle)
-            .and_then(|(c, _)| c.hostname.clone())
-    }
-
-    fn get_state(&self) -> State {
-        self.state.get()
-    }
-
-    fn set_state(&self, state: State) {
-        log::debug!("state => {state:?}");
-        self.state.replace(state);
-    }
-
-    fn set_active(&self, handle: Option<ClientHandle>) {
-        log::debug!("active client => {handle:?}");
-        self.active_client.replace(handle);
-    }
-
-    fn active_addr(&self, handle: ClientHandle) -> Option<SocketAddr> {
-        self.client_manager
-            .borrow()
-            .get(handle)
-            .and_then(|(_, s)| s.active_addr)
-    }
-}
-
-fn to_capture_pos(pos: Position) -> input_capture::Position {
-    match pos {
-        Position::Left => input_capture::Position::Left,
-        Position::Right => input_capture::Position::Right,
-        Position::Top => input_capture::Position::Top,
-        Position::Bottom => input_capture::Position::Bottom,
-    }
 }
--- a/src/server/capture_task.rs
+++ b/src/server/capture_task.rs
@@ -1,167 +1,156 @@
+use anyhow::{anyhow, Result};
 use futures::StreamExt;
-use lan_mouse_proto::ProtoEvent;
-use local_channel::mpsc::{Receiver, Sender};
-use std::net::SocketAddr;
+use std::{collections::HashSet, net::SocketAddr};

-use tokio::{process::Command, task::JoinHandle};
+use tokio::{process::Command, sync::mpsc::Sender, task::JoinHandle};

-use input_capture::{
-    self, CaptureError, CaptureEvent, CaptureHandle, InputCapture, InputCaptureError, Position,
-};
+use input_capture::{self, error::CaptureCreationError, CaptureHandle, InputCapture, Position};

-use crate::server::State;
-use lan_mouse_ipc::{ClientHandle, Status};
+use input_event::{scancode, Event, KeyboardEvent};
+
+use crate::{client::ClientHandle, config::CaptureBackend, server::State};

 use super::Server;

 #[derive(Clone, Copy, Debug)]
-pub(crate) enum CaptureRequest {
+pub enum CaptureEvent {
    /// capture must release the mouse
    Release,
    /// add a capture client
    Create(CaptureHandle, Position),
    /// destory a capture client
    Destroy(CaptureHandle),
+    /// termination signal
+    Terminate,
 }

-pub(crate) fn new(
+pub fn new(
+    backend: Option<CaptureBackend>,
    server: Server,
-    capture_rx: Receiver<CaptureRequest>,
-    udp_send: Sender<(ProtoEvent, SocketAddr)>,
-) -> JoinHandle<()> {
-    let backend = server.config.capture_backend.map(|b| b.into());
-    tokio::task::spawn_local(capture_task(server, backend, udp_send, capture_rx))
-}
-
-async fn capture_task(
-    server: Server,
-    backend: Option<input_capture::Backend>,
-    sender_tx: Sender<(ProtoEvent, SocketAddr)>,
-    mut notify_rx: Receiver<CaptureRequest>,
-) {
-    loop {
-        if let Err(e) = do_capture(backend, &server, &sender_tx, &mut notify_rx).await {
-            log::warn!("input capture exited: {e}");
-        }
-        server.set_capture_status(Status::Disabled);
-        if server.is_cancelled() {
-            break;
-        }
-
-        // allow cancellation
+    sender_tx: Sender<(Event, SocketAddr)>,
+    timer_tx: Sender<()>,
+    release_bind: Vec<scancode::Linux>,
+) -> Result<(JoinHandle<Result<()>>, Sender<CaptureEvent>), CaptureCreationError> {
+    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
+    let backend = backend.map(|b| b.into());
+    let task = tokio::task::spawn_local(async move {
+        let mut capture = input_capture::create(backend).await?;
+        let mut pressed_keys = HashSet::new();
        loop {
            tokio::select! {
-                _ = notify_rx.recv() => continue, /* need to ignore requests here! */
-                _ = server.capture_enabled() => break,
-                _ = server.cancelled() => return,
-            }
-        }
-    }
-}
-
-async fn do_capture(
-    backend: Option<input_capture::Backend>,
-    server: &Server,
-    sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
-    notify_rx: &mut Receiver<CaptureRequest>,
-) -> Result<(), InputCaptureError> {
-    /* allow cancelling capture request */
-    let mut capture = tokio::select! {
-        r = InputCapture::new(backend) => r?,
-        _ = server.cancelled() => return Ok(()),
-    };
-
-    server.set_capture_status(Status::Enabled);
-
-    let clients = server.active_clients();
-    let clients = clients.iter().copied().map(|handle| {
-        (
-            handle,
-            server
-                .client_manager
-                .borrow()
-                .get(handle)
-                .map(|(c, _)| c.pos)
-                .expect("no such client"),
-        )
-    });
-    for (handle, pos) in clients {
-        capture.create(handle, to_capture_pos(pos)).await?;
-    }
-
-    loop {
-        tokio::select! {
-            event = capture.next() => match event {
-                Some(event) => handle_capture_event(server, &mut capture, sender_tx, event?).await?,
-                None => return Ok(()),
-            },
-            e = notify_rx.recv() => {
-                log::debug!("input capture notify rx: {e:?}");
-                match e {
-                    Some(e) => match e {
-                        CaptureRequest::Release => {
-                            capture.release().await?;
-                            server.state.replace(State::Receiving);
-                        }
-                        CaptureRequest::Create(h, p) => capture.create(h, p).await?,
-                        CaptureRequest::Destroy(h) => capture.destroy(h).await?,
-                    },
-                    None => break,
+                event = capture.next() => {
+                    match event {
+                        Some(Ok(event)) => handle_capture_event(&server, &mut capture, &sender_tx, &timer_tx, event, &mut pressed_keys, &release_bind).await?,
+                        Some(Err(e)) => return Err(anyhow!("input capture: {e:?}")),
+                        None => return Err(anyhow!("input capture terminated")),
+                    }
+                }
+                e = rx.recv() => {
+                    log::debug!("input capture notify rx: {e:?}");
+                    match e {
+                        Some(e) => match e {
+                            CaptureEvent::Release => {
+                                capture.release()?;
+                                server.state.replace(State::Receiving);
+                            }
+                            CaptureEvent::Create(h, p) => capture.create(h, p)?,
+                            CaptureEvent::Destroy(h) => capture.destroy(h)?,
+                            CaptureEvent::Terminate => break,
+                        },
+                        None => break,
+                    }
                }
            }
-            _ = server.cancelled() => break,
        }
+        anyhow::Ok(())
+    });
+    Ok((task, tx))
+}
+
+fn update_pressed_keys(pressed_keys: &mut HashSet<scancode::Linux>, key: u32, state: u8) {
+    if let Ok(scancode) = scancode::Linux::try_from(key) {
+        log::debug!("key: {key}, state: {state}, scancode: {scancode:?}");
+        match state {
+            1 => pressed_keys.insert(scancode),
+            _ => pressed_keys.remove(&scancode),
+        };
    }
-    capture.terminate().await?;
-    Ok(())
 }

 async fn handle_capture_event(
    server: &Server,
-    capture: &mut InputCapture,
-    sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
-    event: (CaptureHandle, CaptureEvent),
-) -> Result<(), CaptureError> {
-    let (handle, event) = event;
-    log::trace!("({handle}) {event:?}");
+    capture: &mut Box<dyn InputCapture>,
+    sender_tx: &Sender<(Event, SocketAddr)>,
+    timer_tx: &Sender<()>,
+    event: (CaptureHandle, Event),
+    pressed_keys: &mut HashSet<scancode::Linux>,
+    release_bind: &[scancode::Linux],
+) -> Result<()> {
+    let (handle, mut e) = event;
+    log::trace!("({handle}) {e:?}");

-    // capture started
-    if event == CaptureEvent::Begin {
-        // wait for remote to acknowlegde enter
-        server.set_state(State::AwaitAck);
-        server.set_active(Some(handle));
-        // restart ping timer to release capture if unreachable
-        server.restart_ping_timer();
-        // spawn enter hook cmd
+    if let Event::Keyboard(KeyboardEvent::Key { key, state, .. }) = e {
+        update_pressed_keys(pressed_keys, key, state);
+        log::debug!("{pressed_keys:?}");
+        if release_bind.iter().all(|k| pressed_keys.contains(k)) {
+            pressed_keys.clear();
+            log::info!("releasing pointer");
+            capture.release()?;
+            server.state.replace(State::Receiving);
+            log::trace!("STATE ===> Receiving");
+            // send an event to release all the modifiers
+            e = Event::Disconnect();
+        }
+    }
+
+    let (addr, enter, start_timer) = {
+        let mut enter = false;
+        let mut start_timer = false;
+
+        // get client state for handle
+        let mut client_manager = server.client_manager.borrow_mut();
+        let client_state = match client_manager.get_mut(handle) {
+            Some((_, s)) => s,
+            None => {
+                // should not happen
+                log::warn!("unknown client!");
+                capture.release()?;
+                server.state.replace(State::Receiving);
+                log::trace!("STATE ===> Receiving");
+                return Ok(());
+            }
+        };
+
+        // if we just entered the client we want to send additional enter events until
+        // we get a leave event
+        if let Event::Enter() = e {
+            server.state.replace(State::AwaitingLeave);
+            server.active_client.replace(Some(handle));
+            log::trace!("Active client => {}", handle);
+            start_timer = true;
+            log::trace!("STATE ===> AwaitingLeave");
+            enter = true;
+        } else {
+            // ignore any potential events in receiving mode
+            if server.state.get() == State::Receiving && e != Event::Disconnect() {
+                return Ok(());
+            }
+        }
+
+        (client_state.active_addr, enter, start_timer)
+    };
+    if start_timer {
+        let _ = timer_tx.try_send(());
+    }
+    if enter {
        spawn_hook_command(server, handle);
    }
-
-    // release capture if emulation set state to Receiveing
-    if server.get_state() == State::Receiving {
-        capture.release().await?;
-        return Ok(());
+    if let Some(addr) = addr {
+        if enter {
+            let _ = sender_tx.send((Event::Enter(), addr)).await;
+        }
+        let _ = sender_tx.send((e, addr)).await;
    }
-
-    // check release bind
-    if capture.keys_pressed(&server.release_bind) {
-        capture.release().await?;
-        server.set_state(State::Receiving);
-    }
-
-    if let Some(addr) = server.active_addr(handle) {
-        let event = match server.get_state() {
-            State::Sending => match event {
-                CaptureEvent::Begin => ProtoEvent::Enter(0),
-                CaptureEvent::Input(e) => ProtoEvent::Input(e),
-            },
-            /* send additional enter events until acknowleged */
-            State::AwaitAck => ProtoEvent::Enter(0),
-            /* released capture */
-            State::Receiving => ProtoEvent::Leave(0),
-        };
-        sender_tx.send((event, addr)).expect("sender closed");
-    };
-
    Ok(())
 }

@@ -195,12 +184,3 @@ fn spawn_hook_command(server: &Server, handle: ClientHandle) {
        }
    });
 }
-
-fn to_capture_pos(pos: lan_mouse_ipc::Position) -> input_capture::Position {
-    match pos {
-        lan_mouse_ipc::Position::Left => input_capture::Position::Left,
-        lan_mouse_ipc::Position::Right => input_capture::Position::Right,
-        lan_mouse_ipc::Position::Top => input_capture::Position::Top,
-        lan_mouse_ipc::Position::Bottom => input_capture::Position::Bottom,
-    }
-}
--- a/src/server/emulation_task.rs
+++ b/src/server/emulation_task.rs
@@ -1,160 +1,201 @@
-use local_channel::mpsc::{Receiver, Sender};
+use anyhow::{anyhow, Result};
 use std::net::SocketAddr;

-use lan_mouse_proto::ProtoEvent;
-use tokio::task::JoinHandle;
+use tokio::{
+    sync::mpsc::{Receiver, Sender},
+    task::JoinHandle,
+};

-use lan_mouse_ipc::ClientHandle;
+use crate::{client::ClientHandle, config::EmulationBackend, server::State};
+use input_emulation::{
+    self,
+    error::{EmulationCreationError, EmulationError},
+    EmulationHandle, InputEmulation,
+};
+use input_event::{Event, KeyboardEvent};

-use crate::{client::ClientManager, server::State};
-use input_emulation::{self, EmulationError, EmulationHandle, InputEmulation, InputEmulationError};
-use lan_mouse_ipc::Status;
-
-use super::{network_task::NetworkError, Server};
+use super::{CaptureEvent, Server};

 #[derive(Clone, Debug)]
-pub(crate) enum EmulationRequest {
+pub enum EmulationEvent {
    /// create a new client
    Create(EmulationHandle),
    /// destroy a client
    Destroy(EmulationHandle),
    /// input emulation must release keys for client
    ReleaseKeys(ClientHandle),
+    /// termination signal
+    Terminate,
 }

-pub(crate) fn new(
+pub fn new(
+    backend: Option<EmulationBackend>,
    server: Server,
-    emulation_rx: Receiver<EmulationRequest>,
-    udp_rx: Receiver<Result<(ProtoEvent, SocketAddr), NetworkError>>,
-    sender_tx: Sender<(ProtoEvent, SocketAddr)>,
-) -> JoinHandle<()> {
-    let emulation_task = emulation_task(server, emulation_rx, udp_rx, sender_tx);
-    tokio::task::spawn_local(emulation_task)
-}
+    mut udp_rx: Receiver<Result<(Event, SocketAddr)>>,
+    sender_tx: Sender<(Event, SocketAddr)>,
+    capture_tx: Sender<CaptureEvent>,
+    timer_tx: Sender<()>,
+) -> Result<(JoinHandle<Result<()>>, Sender<EmulationEvent>), EmulationCreationError> {
+    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
+    let emulate_task = tokio::task::spawn_local(async move {
+        let backend = backend.map(|b| b.into());
+        let mut emulate = input_emulation::create(backend).await?;
+        let mut last_ignored = None;

-async fn emulation_task(
-    server: Server,
-    mut rx: Receiver<EmulationRequest>,
-    mut udp_rx: Receiver<Result<(ProtoEvent, SocketAddr), NetworkError>>,
-    sender_tx: Sender<(ProtoEvent, SocketAddr)>,
-) {
-    loop {
-        if let Err(e) = do_emulation(&server, &mut rx, &mut udp_rx, &sender_tx).await {
-            log::warn!("input emulation exited: {e}");
-        }
-        server.set_emulation_status(Status::Disabled);
-        if server.is_cancelled() {
-            break;
-        }
-
-        // allow cancellation
        loop {
            tokio::select! {
-                _ = rx.recv() => continue, /* need to ignore requests here! */
-                _ = server.emulation_notified() => break,
-                _ = server.cancelled() => return,
-            }
-        }
-    }
-}
-
-async fn do_emulation(
-    server: &Server,
-    rx: &mut Receiver<EmulationRequest>,
-    udp_rx: &mut Receiver<Result<(ProtoEvent, SocketAddr), NetworkError>>,
-    sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
-) -> Result<(), InputEmulationError> {
-    let backend = server.config.emulation_backend.map(|b| b.into());
-    log::info!("creating input emulation...");
-    let mut emulation = tokio::select! {
-        r = InputEmulation::new(backend) => r?,
-        _ = server.cancelled() => return Ok(()),
-    };
-
-    server.set_emulation_status(Status::Enabled);
-
-    // add clients
-    for handle in server.active_clients() {
-        emulation.create(handle).await;
-    }
-
-    let res = do_emulation_session(server, &mut emulation, rx, udp_rx, sender_tx).await;
-    emulation.terminate().await; // manual drop
-    res
-}
-
-async fn do_emulation_session(
-    server: &Server,
-    emulation: &mut InputEmulation,
-    rx: &mut Receiver<EmulationRequest>,
-    udp_rx: &mut Receiver<Result<(ProtoEvent, SocketAddr), NetworkError>>,
-    sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
-) -> Result<(), InputEmulationError> {
-    let mut last_ignored = None;
-
-    loop {
-        tokio::select! {
-            udp_event = udp_rx.recv() => {
-                let udp_event = match udp_event.expect("channel closed") {
-                    Ok(e) => e,
-                    Err(e) => {
-                        log::warn!("network error: {e}");
-                        continue;
+                udp_event = udp_rx.recv() => {
+                    let udp_event = udp_event.ok_or(anyhow!("receiver closed"))??;
+                    handle_udp_rx(&server, &capture_tx, &mut emulate, &sender_tx, &mut last_ignored, udp_event, &timer_tx).await?;
+                }
+                emulate_event = rx.recv() => {
+                    match emulate_event {
+                        Some(e) => match e {
+                            EmulationEvent::Create(h) => emulate.create(h).await,
+                            EmulationEvent::Destroy(h) => emulate.destroy(h).await,
+                            EmulationEvent::ReleaseKeys(c) => release_keys(&server, &mut emulate, c).await?,
+                            EmulationEvent::Terminate => break,
+                        },
+                        None => break,
                    }
-                };
-                handle_incoming_event(server, emulation, sender_tx, &mut last_ignored, udp_event).await?;
-            }
-            emulate_event = rx.recv() => {
-                match emulate_event.expect("channel closed") {
-                    EmulationRequest::Create(h) => { let _ = emulation.create(h).await; },
-                    EmulationRequest::Destroy(h) => emulation.destroy(h).await,
-                    EmulationRequest::ReleaseKeys(c) => emulation.release_keys(c).await?,
                }
            }
-            _ = server.notifies.cancel.cancelled() => break Ok(()),
        }
-    }
+
+        // release potentially still pressed keys
+        let clients = server
+            .client_manager
+            .borrow()
+            .get_client_states()
+            .map(|(h, _)| h)
+            .collect::<Vec<_>>();
+        for client in clients {
+            release_keys(&server, &mut emulate, client).await?;
+        }
+
+        anyhow::Ok(())
+    });
+    Ok((emulate_task, tx))
 }

-async fn handle_incoming_event(
+async fn handle_udp_rx(
    server: &Server,
-    emulate: &mut InputEmulation,
-    sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
+    capture_tx: &Sender<CaptureEvent>,
+    emulate: &mut Box<dyn InputEmulation>,
+    sender_tx: &Sender<(Event, SocketAddr)>,
    last_ignored: &mut Option<SocketAddr>,
-    event: (ProtoEvent, SocketAddr),
+    event: (Event, SocketAddr),
+    timer_tx: &Sender<()>,
 ) -> Result<(), EmulationError> {
    let (event, addr) = event;

-    log::trace!("{:20} <-<-<-<------ {addr}", event.to_string());
-
-    // get client handle for addr
-    let Some(handle) =
-        activate_client_if_exists(&mut server.client_manager.borrow_mut(), addr, last_ignored)
-    else {
-        return Ok(());
+    // get handle for addr
+    let handle = match server.client_manager.borrow().get_client(addr) {
+        Some(a) => a,
+        None => {
+            if last_ignored.is_none() || last_ignored.is_some() && last_ignored.unwrap() != addr {
+                log::warn!("ignoring events from client {addr}");
+                last_ignored.replace(addr);
+            }
+            return Ok(());
+        }
    };

+    // next event can be logged as ignored again
+    last_ignored.take();
+
+    log::trace!("{:20} <-<-<-<------ {addr} ({handle})", event.to_string());
+    {
+        let mut client_manager = server.client_manager.borrow_mut();
+        let client_state = match client_manager.get_mut(handle) {
+            Some((_, s)) => s,
+            None => {
+                log::error!("unknown handle");
+                return Ok(());
+            }
+        };
+
+        // reset ttl for client and
+        client_state.alive = true;
+        // set addr as new default for this client
+        client_state.active_addr = Some(addr);
+    }
+
    match (event, addr) {
-        (ProtoEvent::Pong, _) => { /* ignore pong events */ }
-        (ProtoEvent::Ping, addr) => {
-            let _ = sender_tx.send((ProtoEvent::Pong, addr));
+        (Event::Pong(), _) => { /* ignore pong events */ }
+        (Event::Ping(), addr) => {
+            let _ = sender_tx.send((Event::Pong(), addr)).await;
        }
-        (ProtoEvent::Leave(_), _) => emulate.release_keys(handle).await?,
-        (ProtoEvent::Ack(_), _) => server.set_state(State::Sending),
-        (ProtoEvent::Enter(_), _) => {
-            server.set_state(State::Receiving);
-            sender_tx
-                .send((ProtoEvent::Ack(0), addr))
-                .expect("no channel")
+        (Event::Disconnect(), _) => {
+            release_keys(server, emulate, handle).await?;
        }
-        (ProtoEvent::Input(e), _) => {
-            if let State::Receiving = server.get_state() {
-                log::trace!("{event} => emulate");
-                emulate.consume(e, handle).await?;
-                let has_pressed_keys = emulate.has_pressed_keys(handle);
-                server.update_pressed_keys(handle, has_pressed_keys);
-                if has_pressed_keys {
-                    server.restart_ping_timer();
+        (event, addr) => {
+            // tell clients that we are ready to receive events
+            if let Event::Enter() = event {
+                let _ = sender_tx.send((Event::Leave(), addr)).await;
+            }
+
+            match server.state.get() {
+                State::Sending => {
+                    if let Event::Leave() = event {
+                        // ignore additional leave events that may
+                        // have been sent for redundancy
+                    } else {
+                        // upon receiving any event, we go back to receiving mode
+                        server.state.replace(State::Receiving);
+                        let _ = capture_tx.send(CaptureEvent::Release).await;
+                        log::trace!("STATE ===> Receiving");
+                    }
+                }
+                State::Receiving => {
+                    let mut ignore_event = false;
+                    if let Event::Keyboard(KeyboardEvent::Key {
+                        time: _,
+                        key,
+                        state,
+                    }) = event
+                    {
+                        let mut client_manager = server.client_manager.borrow_mut();
+                        let client_state = if let Some((_, s)) = client_manager.get_mut(handle) {
+                            s
+                        } else {
+                            log::error!("unknown handle");
+                            return Ok(());
+                        };
+                        if state == 0 {
+                            // ignore release event if key not pressed
+                            ignore_event = !client_state.pressed_keys.remove(&key);
+                        } else {
+                            // ignore press event if key not released
+                            ignore_event = !client_state.pressed_keys.insert(key);
+                            let _ = timer_tx.try_send(());
+                        }
+                    }
+                    // ignore double press / release events to
+                    // workaround buggy rdp backend.
+                    if !ignore_event {
+                        // consume event
+                        emulate.consume(event, handle).await?;
+                        log::trace!("{event} => emulate");
+                    }
+                }
+                State::AwaitingLeave => {
+                    // we just entered the deadzone of a client, so
+                    // we need to ignore events that may still
+                    // be on the way until a leave event occurs
+                    // telling us the client registered the enter
+                    if let Event::Leave() = event {
+                        server.state.replace(State::Sending);
+                        log::trace!("STATE ===> Sending");
+                    }
+
+                    // entering a client that is waiting for a leave
+                    // event should still be possible
+                    if let Event::Enter() = event {
+                        server.state.replace(State::Receiving);
+                        let _ = capture_tx.send(CaptureEvent::Release).await;
+                        log::trace!("STATE ===> Receiving");
+                    }
                }
            }
        }
@@ -162,27 +203,37 @@ async fn handle_incoming_event(
    Ok(())
 }

-fn activate_client_if_exists(
-    client_manager: &mut ClientManager,
-    addr: SocketAddr,
-    last_ignored: &mut Option<SocketAddr>,
-) -> Option<ClientHandle> {
-    let Some(handle) = client_manager.get_client(addr) else {
-        // log ignored if it is the first event from the client in a series
-        if last_ignored.is_none() || last_ignored.is_some() && last_ignored.unwrap() != addr {
-            log::warn!("ignoring events from client {addr}");
-            last_ignored.replace(addr);
+async fn release_keys(
+    server: &Server,
+    emulate: &mut Box<dyn InputEmulation>,
+    client: ClientHandle,
+) -> Result<(), EmulationError> {
+    let keys = server
+        .client_manager
+        .borrow_mut()
+        .get_mut(client)
+        .iter_mut()
+        .flat_map(|(_, s)| s.pressed_keys.drain())
+        .collect::<Vec<_>>();
+
+    for key in keys {
+        let event = Event::Keyboard(KeyboardEvent::Key {
+            time: 0,
+            key,
+            state: 0,
+        });
+        emulate.consume(event, client).await?;
+        if let Ok(key) = input_event::scancode::Linux::try_from(key) {
+            log::warn!("releasing stuck key: {key:?}");
        }
-        return None;
-    };
-    // next event can be logged as ignored again
-    last_ignored.take();
+    }

-    let (_, client_state) = client_manager.get_mut(handle)?;
-
-    // reset ttl for client
-    client_state.alive = true;
-    // set addr as new default for this client
-    client_state.active_addr = Some(addr);
-    Some(handle)
+    let event = Event::Keyboard(KeyboardEvent::Modifiers {
+        mods_depressed: 0,
+        mods_latched: 0,
+        mods_locked: 0,
+        group: 0,
+    });
+    emulate.consume(event, client).await?;
+    Ok(())
 }
--- a/src/server/frontend_task.rs
+++ b/src/server/frontend_task.rs
@@ -0,0 +1,350 @@
+use std::{
+    collections::HashSet,
+    io::ErrorKind,
+    net::{IpAddr, SocketAddr},
+};
+#[cfg(unix)]
+use tokio::net::UnixStream;
+
+#[cfg(windows)]
+use tokio::net::TcpStream;
+
+use anyhow::{anyhow, Result};
+use tokio::{
+    io::ReadHalf,
+    sync::mpsc::{Receiver, Sender},
+    task::JoinHandle,
+};
+
+use crate::{
+    client::{ClientHandle, Position},
+    frontend::{self, FrontendEvent, FrontendListener, FrontendRequest},
+};
+
+use super::{
+    capture_task::CaptureEvent, emulation_task::EmulationEvent, resolver_task::DnsRequest, Server,
+};
+
+pub(crate) fn new(
+    mut frontend: FrontendListener,
+    mut notify_rx: Receiver<FrontendEvent>,
+    server: Server,
+    capture: Sender<CaptureEvent>,
+    emulate: Sender<EmulationEvent>,
+    resolve_ch: Sender<DnsRequest>,
+    port_tx: Sender<u16>,
+) -> (JoinHandle<Result<()>>, Sender<FrontendRequest>) {
+    let (event_tx, mut event_rx) = tokio::sync::mpsc::channel(32);
+    let event_tx_clone = event_tx.clone();
+    let frontend_task = tokio::task::spawn_local(async move {
+        loop {
+            tokio::select! {
+                stream = frontend.accept() => {
+                    let stream = match stream {
+                        Ok(s) => s,
+                        Err(e) => {
+                            log::warn!("error accepting frontend connection: {e}");
+                            continue;
+                        }
+                    };
+                    handle_frontend_stream(&event_tx_clone, stream).await;
+                }
+                event = event_rx.recv() => {
+                    let frontend_event = event.ok_or(anyhow!("frontend channel closed"))?;
+                    if handle_frontend_event(&server, &capture, &emulate, &resolve_ch, &mut frontend, &port_tx, frontend_event).await {
+                        break;
+                    }
+                }
+                notify = notify_rx.recv() => {
+                    let notify = notify.ok_or(anyhow!("frontend notify closed"))?;
+                    let _ = frontend.broadcast_event(notify).await;
+                }
+            }
+        }
+        anyhow::Ok(())
+    });
+    (frontend_task, event_tx)
+}
+
+async fn handle_frontend_stream(
+    frontend_tx: &Sender<FrontendRequest>,
+    #[cfg(unix)] mut stream: ReadHalf<UnixStream>,
+    #[cfg(windows)] mut stream: ReadHalf<TcpStream>,
+) {
+    use std::io;
+
+    let tx = frontend_tx.clone();
+    tokio::task::spawn_local(async move {
+        loop {
+            let request = frontend::wait_for_request(&mut stream).await;
+            match request {
+                Ok(request) => {
+                    let _ = tx.send(request).await;
+                }
+                Err(e) => {
+                    if let Some(e) = e.downcast_ref::<io::Error>() {
+                        if e.kind() == ErrorKind::UnexpectedEof {
+                            return;
+                        }
+                    }
+                    log::error!("error reading frontend event: {e}");
+                    return;
+                }
+            }
+        }
+    });
+}
+
+async fn handle_frontend_event(
+    server: &Server,
+    capture: &Sender<CaptureEvent>,
+    emulate: &Sender<EmulationEvent>,
+    resolve_tx: &Sender<DnsRequest>,
+    frontend: &mut FrontendListener,
+    port_tx: &Sender<u16>,
+    event: FrontendRequest,
+) -> bool {
+    log::debug!("frontend: {event:?}");
+    match event {
+        FrontendRequest::Create => {
+            let handle = add_client(server, frontend).await;
+            resolve_dns(server, resolve_tx, handle).await;
+        }
+        FrontendRequest::Activate(handle, active) => {
+            if active {
+                activate_client(server, capture, emulate, handle).await;
+            } else {
+                deactivate_client(server, capture, emulate, handle).await;
+            }
+        }
+        FrontendRequest::ChangePort(port) => {
+            let _ = port_tx.send(port).await;
+        }
+        FrontendRequest::Delete(handle) => {
+            remove_client(server, capture, emulate, handle).await;
+            broadcast(frontend, FrontendEvent::Deleted(handle)).await;
+        }
+        FrontendRequest::Enumerate() => {
+            let clients = server
+                .client_manager
+                .borrow()
+                .get_client_states()
+                .map(|(h, (c, s))| (h, c.clone(), s.clone()))
+                .collect();
+            broadcast(frontend, FrontendEvent::Enumerate(clients)).await;
+        }
+        FrontendRequest::GetState(handle) => {
+            broadcast_client(server, frontend, handle).await;
+        }
+        FrontendRequest::Terminate() => {
+            log::info!("terminating gracefully...");
+            return true;
+        }
+        FrontendRequest::UpdateFixIps(handle, fix_ips) => {
+            update_fix_ips(server, handle, fix_ips).await;
+            resolve_dns(server, resolve_tx, handle).await;
+        }
+        FrontendRequest::UpdateHostname(handle, hostname) => {
+            update_hostname(server, resolve_tx, handle, hostname).await;
+            resolve_dns(server, resolve_tx, handle).await;
+        }
+        FrontendRequest::UpdatePort(handle, port) => {
+            update_port(server, handle, port).await;
+        }
+        FrontendRequest::UpdatePosition(handle, pos) => {
+            update_pos(server, handle, capture, emulate, pos).await;
+        }
+        FrontendRequest::ResolveDns(handle) => {
+            resolve_dns(server, resolve_tx, handle).await;
+        }
+    };
+    false
+}
+
+async fn resolve_dns(server: &Server, resolve_tx: &Sender<DnsRequest>, handle: ClientHandle) {
+    let hostname = server
+        .client_manager
+        .borrow()
+        .get(handle)
+        .and_then(|(c, _)| c.hostname.clone());
+    if let Some(hostname) = hostname {
+        let _ = resolve_tx
+            .send(DnsRequest {
+                hostname: hostname.clone(),
+                handle,
+            })
+            .await;
+    }
+}
+
+async fn broadcast(frontend: &mut FrontendListener, event: FrontendEvent) {
+    if let Err(e) = frontend.broadcast_event(event).await {
+        log::error!("error notifying frontend: {e}");
+    }
+}
+
+pub async fn add_client(server: &Server, frontend: &mut FrontendListener) -> ClientHandle {
+    let handle = server.client_manager.borrow_mut().add_client();
+    log::info!("added client {handle}");
+
+    let (c, s) = server.client_manager.borrow().get(handle).unwrap().clone();
+    broadcast(frontend, FrontendEvent::Created(handle, c, s)).await;
+    handle
+}
+
+pub async fn deactivate_client(
+    server: &Server,
+    capture: &Sender<CaptureEvent>,
+    emulate: &Sender<EmulationEvent>,
+    handle: ClientHandle,
+) {
+    match server.client_manager.borrow_mut().get_mut(handle) {
+        Some((_, s)) => {
+            s.active = false;
+        }
+        None => return,
+    };
+
+    let _ = capture.send(CaptureEvent::Destroy(handle)).await;
+    let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
+}
+
+pub async fn activate_client(
+    server: &Server,
+    capture: &Sender<CaptureEvent>,
+    emulate: &Sender<EmulationEvent>,
+    handle: ClientHandle,
+) {
+    /* deactivate potential other client at this position */
+    let pos = match server.client_manager.borrow().get(handle) {
+        Some((client, _)) => client.pos,
+        None => return,
+    };
+
+    let other = server.client_manager.borrow_mut().find_client(pos);
+    if let Some(other) = other {
+        if other != handle {
+            deactivate_client(server, capture, emulate, other).await;
+        }
+    }
+
+    /* activate the client */
+    if let Some((_, s)) = server.client_manager.borrow_mut().get_mut(handle) {
+        s.active = true;
+    } else {
+        return;
+    };
+
+    /* notify emulation, capture and frontends */
+    let _ = capture.send(CaptureEvent::Create(handle, pos.into())).await;
+    let _ = emulate.send(EmulationEvent::Create(handle)).await;
+}
+
+pub async fn remove_client(
+    server: &Server,
+    capture: &Sender<CaptureEvent>,
+    emulate: &Sender<EmulationEvent>,
+    handle: ClientHandle,
+) {
+    let Some(active) = server
+        .client_manager
+        .borrow_mut()
+        .remove_client(handle)
+        .map(|(_, s)| s.active)
+    else {
+        return;
+    };
+
+    if active {
+        let _ = capture.send(CaptureEvent::Destroy(handle)).await;
+        let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
+    }
+}
+
+async fn update_fix_ips(server: &Server, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
+    let mut client_manager = server.client_manager.borrow_mut();
+    let Some((c, _)) = client_manager.get_mut(handle) else {
+        return;
+    };
+
+    c.fix_ips = fix_ips;
+}
+
+async fn update_hostname(
+    server: &Server,
+    resolve_tx: &Sender<DnsRequest>,
+    handle: ClientHandle,
+    hostname: Option<String>,
+) {
+    let hostname = {
+        let mut client_manager = server.client_manager.borrow_mut();
+        let Some((c, s)) = client_manager.get_mut(handle) else {
+            return;
+        };
+
+        // update hostname
+        if c.hostname != hostname {
+            c.hostname = hostname;
+            s.ips = HashSet::from_iter(c.fix_ips.iter().cloned());
+            s.active_addr = None;
+            c.hostname.clone()
+        } else {
+            None
+        }
+    };
+
+    // resolve to update ips in state
+    if let Some(hostname) = hostname {
+        let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
+    }
+}
+
+async fn update_port(server: &Server, handle: ClientHandle, port: u16) {
+    let mut client_manager = server.client_manager.borrow_mut();
+    let Some((c, s)) = client_manager.get_mut(handle) else {
+        return;
+    };
+
+    if c.port != port {
+        c.port = port;
+        s.active_addr = s.active_addr.map(|a| SocketAddr::new(a.ip(), port));
+    }
+}
+
+async fn update_pos(
+    server: &Server,
+    handle: ClientHandle,
+    capture: &Sender<CaptureEvent>,
+    emulate: &Sender<EmulationEvent>,
+    pos: Position,
+) {
+    let (changed, active) = {
+        let mut client_manager = server.client_manager.borrow_mut();
+        let Some((c, s)) = client_manager.get_mut(handle) else {
+            return;
+        };
+
+        let changed = c.pos != pos;
+        c.pos = pos;
+        (changed, s.active)
+    };
+
+    // update state in event input emulator & input capture
+    if changed {
+        if active {
+            let _ = capture.send(CaptureEvent::Destroy(handle)).await;
+            let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
+        }
+        let _ = capture.send(CaptureEvent::Create(handle, pos.into())).await;
+        let _ = emulate.send(EmulationEvent::Create(handle)).await;
+    }
+}
+
+async fn broadcast_client(server: &Server, frontend: &mut FrontendListener, handle: ClientHandle) {
+    let client = server.client_manager.borrow().get(handle).cloned();
+    if let Some((config, state)) = client {
+        broadcast(frontend, FrontendEvent::State(handle, config, state)).await;
+    } else {
+        broadcast(frontend, FrontendEvent::NoSuchClient(handle)).await;
+    }
+}
--- a/src/server/network_task.rs
+++ b/src/server/network_task.rs
@@ -1,99 +1,90 @@
-use local_channel::mpsc::{Receiver, Sender};
-use std::{io, net::SocketAddr};
+use std::net::SocketAddr;

-use thiserror::Error;
-use tokio::{net::UdpSocket, task::JoinHandle};
+use anyhow::Result;
+use tokio::{
+    net::UdpSocket,
+    sync::mpsc::{Receiver, Sender},
+    task::JoinHandle,
+};
+
+use crate::frontend::FrontendEvent;
+use input_event::Event;

 use super::Server;
-use lan_mouse_proto::{ProtoEvent, ProtocolError};

-pub(crate) async fn new(
+pub async fn new(
    server: Server,
-    udp_recv_tx: Sender<Result<(ProtoEvent, SocketAddr), NetworkError>>,
-    udp_send_rx: Receiver<(ProtoEvent, SocketAddr)>,
-) -> io::Result<JoinHandle<()>> {
+    frontend_notify_tx: Sender<FrontendEvent>,
+) -> Result<(
+    JoinHandle<()>,
+    Sender<(Event, SocketAddr)>,
+    Receiver<Result<(Event, SocketAddr)>>,
+    Sender<u16>,
+)> {
    // bind the udp socket
    let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), server.port.get());
    let mut socket = UdpSocket::bind(listen_addr).await?;
+    let (receiver_tx, receiver_rx) = tokio::sync::mpsc::channel(32);
+    let (sender_tx, mut sender_rx) = tokio::sync::mpsc::channel(32);
+    let (port_tx, mut port_rx) = tokio::sync::mpsc::channel(32);

-    Ok(tokio::task::spawn_local(async move {
-        let mut sender_rx = udp_send_rx;
+    let udp_task = tokio::task::spawn_local(async move {
        loop {
-            let udp_receiver = udp_receiver(&socket, &udp_recv_tx);
-            let udp_sender = udp_sender(&socket, &mut sender_rx);
            tokio::select! {
-                _ = udp_receiver => break, /* channel closed */
-                _ = udp_sender => break, /* channel closed */
-                _ = server.notifies.port_changed.notified() => update_port(&server, &mut socket).await,
-                _ = server.cancelled() => break, /* cancellation requested */
+                event = receive_event(&socket) => {
+                    let _ = receiver_tx.send(event).await;
+                }
+                event = sender_rx.recv() => {
+                    let Some((event, addr)) = event else {
+                        break;
+                    };
+                    if let Err(e) = send_event(&socket, event, addr) {
+                        log::warn!("udp send failed: {e}");
+                    };
+                }
+                port = port_rx.recv() => {
+                    let Some(port) = port else {
+                        break;
+                    };
+
+                    if socket.local_addr().unwrap().port() == port {
+                        continue;
+                    }
+
+                    let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), port);
+                    match UdpSocket::bind(listen_addr).await {
+                        Ok(new_socket) => {
+                            socket = new_socket;
+                            server.port.replace(port);
+                            let _ = frontend_notify_tx.send(FrontendEvent::PortChanged(port, None)).await;
+                        }
+                        Err(e) => {
+                            log::warn!("could not change port: {e}");
+                            let port = socket.local_addr().unwrap().port();
+                            let _ = frontend_notify_tx.send(FrontendEvent::PortChanged(
+                                    port,
+                                    Some(format!("could not change port: {e}")),
+                                )).await;
+                        }
+                    }
+
+                }
            }
        }
-    }))
+    });
+    Ok((udp_task, sender_tx, receiver_rx, port_tx))
 }

-async fn update_port(server: &Server, socket: &mut UdpSocket) {
-    let new_port = server.port.get();
-    let current_port = socket.local_addr().expect("socket not bound").port();
-
-    // if port is the same, we dont need to change it
-    if current_port == new_port {
-        return;
-    }
-
-    // bind new socket
-    let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), new_port);
-    let new_socket = UdpSocket::bind(listen_addr).await;
-    let err = match new_socket {
-        Ok(new_socket) => {
-            *socket = new_socket;
-            None
-        }
-        Err(e) => Some(e.to_string()),
-    };
-
-    // notify frontend of the actual port
-    let port = socket.local_addr().expect("socket not bound").port();
-    server.notify_port_changed(port, err);
+async fn receive_event(socket: &UdpSocket) -> Result<(Event, SocketAddr)> {
+    let mut buf = vec![0u8; 22];
+    let (_amt, src) = socket.recv_from(&mut buf).await?;
+    Ok((Event::try_from(buf)?, src))
 }

-async fn udp_receiver(
-    socket: &UdpSocket,
-    receiver_tx: &Sender<Result<(ProtoEvent, SocketAddr), NetworkError>>,
-) {
-    loop {
-        let event = receive_event(socket).await;
-        receiver_tx.send(event).expect("channel closed");
-    }
-}
-
-async fn udp_sender(socket: &UdpSocket, rx: &mut Receiver<(ProtoEvent, SocketAddr)>) {
-    loop {
-        let (event, addr) = rx.recv().await.expect("channel closed");
-        if let Err(e) = send_event(socket, event, addr) {
-            log::warn!("udp send failed: {e}");
-        };
-    }
-}
-
-#[derive(Debug, Error)]
-pub(crate) enum NetworkError {
-    #[error(transparent)]
-    Protocol(#[from] ProtocolError),
-    #[error("network error: `{0}`")]
-    Io(#[from] io::Error),
-}
-
-async fn receive_event(socket: &UdpSocket) -> Result<(ProtoEvent, SocketAddr), NetworkError> {
-    let mut buf = [0u8; lan_mouse_proto::MAX_EVENT_SIZE];
-    let (_len, src) = socket.recv_from(&mut buf).await?;
-    let event = ProtoEvent::try_from(buf)?;
-    Ok((event, src))
-}
-
-fn send_event(sock: &UdpSocket, e: ProtoEvent, addr: SocketAddr) -> Result<usize, NetworkError> {
+fn send_event(sock: &UdpSocket, e: Event, addr: SocketAddr) -> Result<usize> {
    log::trace!("{:20} ------>->->-> {addr}", e.to_string());
-    let (data, len): ([u8; lan_mouse_proto::MAX_EVENT_SIZE], usize) = e.into();
+    let data: Vec<u8> = (&e).into();
    // When udp blocks, we dont want to block the event loop.
    // Dropping events is better than potentially crashing the input capture.
-    Ok(sock.try_send_to(&data[..len], addr)?)
+    Ok(sock.try_send_to(&data, addr)?)
 }
--- a/src/server/ping_task.rs
+++ b/src/server/ping_task.rs
@@ -1,138 +1,131 @@
 use std::{net::SocketAddr, time::Duration};

-use lan_mouse_proto::ProtoEvent;
-use local_channel::mpsc::Sender;
-use tokio::task::JoinHandle;
+use tokio::{
+    sync::mpsc::{Receiver, Sender},
+    task::JoinHandle,
+};

-use lan_mouse_ipc::ClientHandle;
+use input_event::Event;

-use super::{capture_task::CaptureRequest, emulation_task::EmulationRequest, Server, State};
+use crate::client::ClientHandle;
+
+use super::{capture_task::CaptureEvent, emulation_task::EmulationEvent, Server, State};

 const MAX_RESPONSE_TIME: Duration = Duration::from_millis(500);

-pub(crate) fn new(
+pub fn new(
    server: Server,
-    sender_ch: Sender<(ProtoEvent, SocketAddr)>,
-    emulate_notify: Sender<EmulationRequest>,
-    capture_notify: Sender<CaptureRequest>,
+    sender_ch: Sender<(Event, SocketAddr)>,
+    emulate_notify: Sender<EmulationEvent>,
+    capture_notify: Sender<CaptureEvent>,
+    mut timer_rx: Receiver<()>,
 ) -> JoinHandle<()> {
    // timer task
-    tokio::task::spawn_local(async move {
-        tokio::select! {
-            _ = server.notifies.cancel.cancelled() => {}
-            _ = ping_task(&server, sender_ch, emulate_notify, capture_notify) => {}
-        }
-    })
-}
-
-async fn ping_task(
-    server: &Server,
-    sender_ch: Sender<(ProtoEvent, SocketAddr)>,
-    emulate_notify: Sender<EmulationRequest>,
-    capture_notify: Sender<CaptureRequest>,
-) {
-    loop {
-        // wait for wake up signal
-        server.ping_timer_notified().await;
+    let ping_task = tokio::task::spawn_local(async move {
        loop {
-            let receiving = server.state.get() == State::Receiving;
-            let (ping_clients, ping_addrs) = {
-                let mut client_manager = server.client_manager.borrow_mut();
+            // wait for wake up signal
+            let Some(_): Option<()> = timer_rx.recv().await else {
+                break;
+            };
+            loop {
+                let receiving = server.state.get() == State::Receiving;
+                let (ping_clients, ping_addrs) = {
+                    let mut client_manager = server.client_manager.borrow_mut();

-                let ping_clients: Vec<ClientHandle> = if receiving {
-                    // if receiving we care about clients with pressed keys
-                    client_manager
-                        .get_client_states()
-                        .filter(|(_, (_, s))| s.has_pressed_keys)
-                        .map(|(h, _)| h)
-                        .collect()
-                } else {
-                    // if sending we care about the active client
-                    server.active_client.get().iter().cloned().collect()
+                    let ping_clients: Vec<ClientHandle> = if receiving {
+                        // if receiving we care about clients with pressed keys
+                        client_manager
+                            .get_client_states_mut()
+                            .filter(|(_, (_, s))| !s.pressed_keys.is_empty())
+                            .map(|(h, _)| h)
+                            .collect()
+                    } else {
+                        // if sending we care about the active client
+                        server.active_client.get().iter().cloned().collect()
+                    };
+
+                    // get relevant socket addrs for clients
+                    let ping_addrs: Vec<SocketAddr> = {
+                        ping_clients
+                            .iter()
+                            .flat_map(|&h| client_manager.get(h))
+                            .flat_map(|(c, s)| {
+                                if s.alive && s.active_addr.is_some() {
+                                    vec![s.active_addr.unwrap()]
+                                } else {
+                                    s.ips
+                                        .iter()
+                                        .cloned()
+                                        .map(|ip| SocketAddr::new(ip, c.port))
+                                        .collect()
+                                }
+                            })
+                            .collect()
+                    };
+
+                    // reset alive
+                    for (_, (_, s)) in client_manager.get_client_states_mut() {
+                        s.alive = false;
+                    }
+
+                    (ping_clients, ping_addrs)
                };

-                // get relevant socket addrs for clients
-                let ping_addrs: Vec<SocketAddr> = {
+                if receiving && ping_clients.is_empty() {
+                    // receiving and no client has pressed keys
+                    // -> no need to keep pinging
+                    break;
+                }
+
+                // ping clients
+                for addr in ping_addrs {
+                    if sender_ch.send((Event::Ping(), addr)).await.is_err() {
+                        break;
+                    }
+                }
+
+                // give clients time to resond
+                if receiving {
+                    log::trace!("waiting {MAX_RESPONSE_TIME:?} for response from client with pressed keys ...");
+                } else {
+                    log::trace!(
+                        "state: {:?} => waiting {MAX_RESPONSE_TIME:?} for client to respond ...",
+                        server.state.get()
+                    );
+                }
+
+                tokio::time::sleep(MAX_RESPONSE_TIME).await;
+
+                // when anything is received from a client,
+                // the alive flag gets set
+                let unresponsive_clients: Vec<_> = {
+                    let client_manager = server.client_manager.borrow();
                    ping_clients
                        .iter()
-                        .flat_map(|&h| client_manager.get(h))
-                        .flat_map(|(c, s)| {
-                            if s.alive && s.active_addr.is_some() {
-                                vec![s.active_addr.unwrap()]
-                            } else {
-                                s.ips
-                                    .iter()
-                                    .cloned()
-                                    .map(|ip| SocketAddr::new(ip, c.port))
-                                    .collect()
-                            }
+                        .filter_map(|&h| match client_manager.get(h) {
+                            Some((_, s)) if !s.alive => Some(h),
+                            _ => None,
                        })
                        .collect()
                };

-                // reset alive
-                for (_, (_, s)) in client_manager.get_client_states_mut() {
-                    s.alive = false;
-                }
-
-                (ping_clients, ping_addrs)
-            };
-
-            if receiving && ping_clients.is_empty() {
-                // receiving and no client has pressed keys
-                // -> no need to keep pinging
-                break;
-            }
-
-            // ping clients
-            for addr in ping_addrs {
-                if sender_ch.send((ProtoEvent::Ping, addr)).is_err() {
-                    break;
-                }
-            }
-
-            // give clients time to resond
-            if receiving {
-                log::trace!(
-                    "waiting {MAX_RESPONSE_TIME:?} for response from client with pressed keys ..."
-                );
-            } else {
-                log::trace!(
-                    "state: {:?} => waiting {MAX_RESPONSE_TIME:?} for client to respond ...",
-                    server.state.get()
-                );
-            }
-
-            tokio::time::sleep(MAX_RESPONSE_TIME).await;
-
-            // when anything is received from a client,
-            // the alive flag gets set
-            let unresponsive_clients: Vec<_> = {
-                let client_manager = server.client_manager.borrow();
-                ping_clients
-                    .iter()
-                    .filter_map(|&h| match client_manager.get(h) {
-                        Some((_, s)) if !s.alive => Some(h),
-                        _ => None,
-                    })
-                    .collect()
-            };
-
-            // we may not be receiving anymore but we should respond
-            // to the original state and not the "new" one
-            if receiving {
-                for h in unresponsive_clients {
-                    log::warn!("device not responding, releasing keys!");
-                    let _ = emulate_notify.send(EmulationRequest::ReleaseKeys(h));
-                }
-            } else {
-                // release pointer if the active client has not responded
-                if !unresponsive_clients.is_empty() {
-                    log::warn!("client not responding, releasing pointer!");
-                    server.state.replace(State::Receiving);
-                    let _ = capture_notify.send(CaptureRequest::Release);
+                // we may not be receiving anymore but we should respond
+                // to the original state and not the "new" one
+                if receiving {
+                    for h in unresponsive_clients {
+                        log::warn!("device not responding, releasing keys!");
+                        let _ = emulate_notify.send(EmulationEvent::ReleaseKeys(h)).await;
+                    }
+                } else {
+                    // release pointer if the active client has not responded
+                    if !unresponsive_clients.is_empty() {
+                        log::warn!("client not responding, releasing pointer!");
+                        server.state.replace(State::Receiving);
+                        let _ = capture_notify.send(CaptureEvent::Release).await;
+                    }
                }
            }
        }
-    }
+    });
+    ping_task
 }
--- a/src/server/resolver_task.rs
+++ b/src/server/resolver_task.rs
@@ -0,0 +1,68 @@
+use std::collections::HashSet;
+
+use tokio::{sync::mpsc::Sender, task::JoinHandle};
+
+use crate::{client::ClientHandle, dns::DnsResolver, frontend::FrontendEvent};
+
+use super::Server;
+
+#[derive(Clone)]
+pub struct DnsRequest {
+    pub hostname: String,
+    pub handle: ClientHandle,
+}
+
+pub fn new(
+    resolver: DnsResolver,
+    mut server: Server,
+    mut frontend: Sender<FrontendEvent>,
+) -> (JoinHandle<()>, Sender<DnsRequest>) {
+    let (dns_tx, mut dns_rx) = tokio::sync::mpsc::channel::<DnsRequest>(32);
+    let resolver_task = tokio::task::spawn_local(async move {
+        loop {
+            let (host, handle) = match dns_rx.recv().await {
+                Some(r) => (r.hostname, r.handle),
+                None => break,
+            };
+
+            /* update resolving status */
+            if let Some((_, s)) = server.client_manager.borrow_mut().get_mut(handle) {
+                s.resolving = true;
+            }
+            notify_state_change(&mut frontend, &mut server, handle).await;
+
+            let ips = match resolver.resolve(&host).await {
+                Ok(ips) => ips,
+                Err(e) => {
+                    log::warn!("could not resolve host '{host}': {e}");
+                    vec![]
+                }
+            };
+
+            /* update ips and resolving state */
+            if let Some((c, s)) = server.client_manager.borrow_mut().get_mut(handle) {
+                let mut addrs = HashSet::from_iter(c.fix_ips.iter().cloned());
+                for ip in ips {
+                    addrs.insert(ip);
+                }
+                s.ips = addrs;
+                s.resolving = false;
+            }
+            notify_state_change(&mut frontend, &mut server, handle).await;
+        }
+    });
+    (resolver_task, dns_tx)
+}
+
+async fn notify_state_change(
+    frontend: &mut Sender<FrontendEvent>,
+    server: &mut Server,
+    handle: ClientHandle,
+) {
+    let state = server.client_manager.borrow_mut().get_mut(handle).cloned();
+    if let Some((config, state)) = state {
+        let _ = frontend
+            .send(FrontendEvent::State(handle, config, state))
+            .await;
+    }
+}
Author	SHA1	Message	Date
Ferdinand Schober	09f08f1798	fix drop impl for desktop-portal	2024-07-05 00:31:16 +02:00
Ferdinand Schober	f97621e987	adjust error handling	2024-07-04 23:44:32 +02:00
Ferdinand Schober	b3aa3f4281	remove dispatch workaround	2024-07-04 22:40:05 +02:00