Rustdesk / Wayland / Omarchy - "Wayland requires higher version of linux distro. Please try X11 desktop or change your OS"

[lukejmorrison]

Has anyone come accross this error? I believe Rustdesk has Wayland support for a while now.

I can control MacOS Macbook from my Omarchy Arch Linux but not the other way around. Is anyone aware of this issue?

I wonder, does Omarchy Arch Linux not report it's version correctly or ist it with Rustdesk not recognizing Omarchy Arch Linux as a "Distro"?

[qusaismael]

Try restarting the portal, it may work... if the reason was a crash to start with..

it worked with me tho.
systemctl --user restart xdg-desktop-portal plasma-xdg-desktop-portal-kde

[Rainboylvx]

same error

[ortonomy]

Yeah, same error. Cant get rustdesk to work from macOS

[Skarvion]

I got a different error. It throws xdp-portal-unavailable now. IIRC, I think there was a recent-ish update with Rustdesk to allow using RustDesk server on Wayland, so maybe you'll have a different error now

[Mikesco3]

This article helped me:
https://andotech.net/taming-rustdesk-on-wayland-how-to-fix-screensharing-and-input-issues/

[Bulwark-Black]

Solved this today on Omarchy 4.0.2. The root cause is not a crashed portal and not RustDesk failing to detect the distro — xdg-desktop-portal-hyprland does not implement org.freedesktop.impl.portal.RemoteDesktop, and RustDesk requires it.

RustDesk's dialog is misleading. The real error is in ~/.local/share/logs/RustDesk/*.log:

ERROR [src/server/wayland.rs:82] Failed scrap
No such interface "org.freedesktop.portal.RemoteDesktop" on object at path /org/freedesktop/portal/desktop

Confirm it on your own machine:

gdbus introspect --session --dest org.freedesktop.portal.Desktop \
  --object-path /org/freedesktop/portal/desktop | grep -c portal.RemoteDesktop

0 means the interface is missing. Restarting the portal cannot help — mine was active (running) with [screencopy] init successful and PipeWire connected the whole time. The Hyprland portal ships Screenshot;ScreenCast;GlobalShortcuts;InputCapture and nothing else; see hyprwm/xdg-desktop-portal-hyprland#252, still open. RustDesk needs RemoteDesktop specifically because it wants capture and input injection in one session.

Fix

Install a backend that implements it. xdg-desktop-portal-luminous (AUR) does, and coexists with xdg-desktop-portal-hyprland — nothing is removed:

yay -S --needed xdg-desktop-portal-luminous

Then ~/.config/xdg-desktop-portal/hyprland-portals.conf:

[preferred]
default=hyprland;gtk
org.freedesktop.impl.portal.RemoteDesktop=luminous
org.freedesktop.impl.portal.ScreenCast=luminous

systemctl --user restart xdg-desktop-portal-hyprland xdg-desktop-portal

Note this file replaces /usr/share/xdg-desktop-portal/hyprland-portals.conf rather than merging with it, which is why the stock default=hyprland;gtk line is repeated.

Why ScreenCast has to move too

This is the part that will waste your afternoon if you skip it. I first tried routing only RemoteDesktop to luminous and leaving ScreenCast on Hyprland. That cannot work. In xdg-desktop-portal's desktop-portal/screen-cast.c, handle_select_sources always dispatches to the global ScreenCast implementation, even when the session belongs to a RemoteDesktop session:

xdp_dbus_impl_screen_cast_call_select_sources (screen_cast->impl, ...)

So a split routing hands luminous's session handle to Hyprland's backend, which has never seen it. Both interfaces must point at the same backend.

Also worth knowing: portals.conf has no per-application routing. It only has [preferred], keyed on XDG_CURRENT_DESKTOP, so this is a session-wide choice — you cannot scope it to RustDesk alone.

What this affects

Anything using the ScreenCast portal moves to luminous — browser screen sharing, OBS's PipeWire source. Nothing Omarchy-native is affected: omarchy capture screenshot, region, QR and OCR all shell out to grim+slurp, and screen recording uses gpu-screen-recorder's kms backend unless you set OMARCHY_SCREENRECORD_USE_PORTAL=true. grep finds no reference to ScreenCast or xdg-desktop-portal anywhere in /usr/share/omarchy/bin/ or the shell tree.

Revert with rm ~/.config/xdg-desktop-portal/hyprland-portals.conf and restart the portal.

Verifying

# must now print 1
gdbus introspect --session --dest org.freedesktop.portal.Desktop \
  --object-path /org/freedesktop/portal/desktop | grep -c portal.RemoteDesktop

# 7 = keyboard | pointer | touchscreen
gdbus call --session --dest org.freedesktop.portal.Desktop \
  --object-path /org/freedesktop/portal/desktop \
  --method org.freedesktop.DBus.Properties.Get \
  org.freedesktop.portal.RemoteDesktop AvailableDeviceTypes

On a real connection journalctl --user | grep luminous should show remotedesktop: Start remoting followed by pipewirethread: state-changed 'Paused' -> 'Streaming'.

You get a one-time picker asking which screen to share on the first connection; subsequent connections reused it for me.

Environment

Omarchy 4.0.2-1 · Hyprland 0.56.2-1 · xdg-desktop-portal 1.22.1-2 · xdg-desktop-portal-hyprland 1.4.1-1 · xdg-desktop-portal-luminous 0.1.21-1 · rustdesk 1.4.9-1 · NVIDIA GTX 1080 Ti (580.178.04)

[drivesensei]

This worked for me on omarchy 4.0.2 but only after installing luminous from the install -> AUR menu. Installed using yay and didnt worked.

Anyways, your fix is legendary and rustdesk is working for me now beautifully. Thank you so much

[Bulwark-Black]

Follow-up: my earlier answer was only half of it

The portal fix above gets you video. It does not get you a mouse, and I want to correct that before anyone burns an afternoon the way I did. Screen capture and input injection on Wayland are two completely separate mechanisms in RustDesk, and fixing one tells you nothing about the other.

Full working setup on Omarchy 4.0.2 is below. All three parts are needed.

---

Part 1 — video: the RemoteDesktop portal

Unchanged from my earlier comment: install xdg-desktop-portal-luminous and route both RemoteDesktop and ScreenCast to it in ~/.config/xdg-desktop-portal/hyprland-portals.conf. xdg-desktop-portal-hyprland implements no RemoteDesktop interface at all (hyprwm/xdg-desktop-portal-hyprland#252), and ScreenCast has to move with it because handle_select_sources always dispatches to the global ScreenCast impl.

Verify with:

gdbus introspect --session --dest org.freedesktop.portal.Desktop \
  --object-path /org/freedesktop/portal/desktop | grep -c portal.RemoteDesktop

1 = good, 0 = the interface is missing.

---

Part 2 — mouse and keyboard: the root service, not the portal

RustDesk does not inject input through the portal. It writes to /dev/uinput, which is root-only. UInputKeyboard / UInputMouse talk over IPC to a background service running as root. So RustDesk on Wayland is two processes:

Process	Runs as	Provides
rustdesk --service	root	/dev/uinput — mouse and keyboard
rustdesk --server	you	Wayland + portal — screen capture

If you only have the user half, you get a perfect picture and a dead mouse. That was my mistake: I had wrapped rustdesk --server in a user unit to survive a crash, which silently removed the only component that can move the pointer.

sudo systemctl enable --now rustdesk

The part that actually bites on Hyprland

Enabling it is not enough. The root service has to find your session to spawn the user-side server, and it does so by grepping for a GNOME process:

/bin/sh -c "ps -u 1000 -f | grep -E 'goa-daemon' | grep -v 'grep' | tail -1 | awk '{print $2}' \
  | xargs -I__ cat /proc/__/environ | tr '\0' '\n' | grep '^DISPLAY=' | tail -1 | sed 's/DISPLAY=//g'"

goa-daemon is GNOME Online Accounts. It does not exist on Hyprland, so the lookup returns nothing and the journal shows:

rustdesk[149010]: Error: DISPLAY environment variable is empty. Is there an Xorg or other X server running?
rustdesk[149017]: cannot open display:

The user-side server then starts with exactly one environment variable — XDG_RUNTIME_DIR — so it cannot reach your compositor, cannot capture, and never registers with the rendezvous server.

Fix — hand it the session directly:

sudo mkdir -p /etc/systemd/system/rustdesk.service.d
sudo tee /etc/systemd/system/rustdesk.service.d/session-env.conf >/dev/null <<'EOF'
[Service]
Environment=DISPLAY=:0
Environment=WAYLAND_DISPLAY=wayland-1
Environment=XDG_CURRENT_DESKTOP=Hyprland
Environment=XDG_SESSION_TYPE=wayland
EOF
sudo systemctl daemon-reload && sudo systemctl restart rustdesk

Adjust WAYLAND_DISPLAY if yours differs (echo $WAYLAND_DISPLAY).

Verify it survived the handoff — the service passes it through sudo -E, and sudo's env_reset could strip it, so check rather than assume:

tr '\0' '\n' < /proc/$(pgrep -u $USER -f 'rustdesk --server')/environ | grep -E 'DISPLAY|WAYLAND'

You want to see DISPLAY, WAYLAND_DISPLAY, XDG_CURRENT_DESKTOP. One lone XDG_RUNTIME_DIR means it did not take.

Do not also run your own user-level unit for --server — the root service spawns it, and two will fight.

---

Part 3 — the screen picker, and automating it

With the above working you get a picker on connect, sometimes. It is genuinely nondeterministic, and here is why:

• Luminous has no persistence. It writes nothing to disk. Its options struct carries restore_token and persist_mode, but nothing in src/screencast.rs or src/remotedesktop.rs ever reads them to skip the prompt.
• RustDesk never asks it to remember — there is no restore_token or persist_mode string anywhere in the binary, so the portal is never permitted to persist a choice.
• The only reason a second connection sometimes skips the dialog is CAST_SESSIONS still holding a live session in RAM.

So it asks whenever that in-memory session is gone. For unattended access that is fatal — nobody is there to click, and the peer times out. I watched a connection die six seconds after the picker appeared.

Luminous has a supported hook for this

Both selection paths are gated on a socket simply existing:

// src/screencast.rs, and identically in src/remotedesktop.rs
let (target, source_type) = if SERVER_SOCK.exists() {
    let monitors: Vec<String> = outputs.iter().map(|o| o.name.clone()).collect();
    let index = get_selection_from_socket(monitors)?;
    ...
} else {
    // draw the GUI picker
}

Note it is SERVER_SOCK.exists() — not the LUMIOUS_HEADLESS env var, which gates other things. Creating $XDG_RUNTIME_DIR/luminus_selector.sock and answering on it is the intended override, and it covers both video and the output that mouse coordinates map onto, because both send the same message.

Protocol, from stream_message/src/lib.rs — native-endian u32 length then serde-tagged JSON:

->  {"type": "screen_share", "monitors": ["HDMI-A-2", ...]}
<-  {"type": "success", "index": 0} | {"type": "cancel"} | {"type": "busy"}

Luminous ships lumious_headless_helper which serves this with a terminal dialoguer prompt — useful for a TTY, but still a prompt. What follows answers from a saved preference instead.

Two things that will burn you

1. Never answer cancel, and never leave the socket behind on exit. Once the socket exists luminous has no fallback. A cancel kills the session; a socket with nothing listening makes get_selection_from_socket fail with Cannot connect to socket and breaks every screen share on the machine, browser sharing included. Trap SIGTERM.
2. Detect RustDesk on create_relay requested, not Start cm. Measured here, the portal call lands 333–653 ms after create_relay requested but before Start cm. My first attempt keyed on Start cm, concluded "not RustDesk" for genuine sessions, and cancelled them.

~/.local/bin/luminous-autoselect

Answers from ~/.config/luminous-autoselect.json, e.g. {"output": "HDMI-A-2"}. Omit the file and it takes the first output.

Full script (Python 3, no dependencies)

#!/usr/bin/env python3
"""Answer luminous's screen picker automatically, from a saved preference.

Luminous asks which output to share by drawing a dialog and has no way to
remember the answer: its options struct carries restore_token and persist_mode,
but nothing in src/screencast.rs or src/remotedesktop.rs reads them to skip the
prompt, and it writes no state to disk. The only reason a second connection
sometimes skips the dialog is CAST_SESSIONS still holding a session in RAM,
which is why it appears sporadically rather than never or always. RustDesk
cannot help either -- it never sends persist_mode or restore_token, so the
portal is never permitted to remember anything.

The durable preference therefore has to live out here.

Luminous gates both selection paths on the socket simply existing:

    // src/screencast.rs, and identically in src/remotedesktop.rs
    if SERVER_SOCK.exists() {
        let index = get_selection_from_socket(monitors)?;
    } else {
        // draw the GUI picker
    }

Note that is SERVER_SOCK.exists(), not the LUMIOUS_HEADLESS env var. Creating
the socket is the supported override, and it covers both video (ScreenCast) and
the output mouse coordinates map onto (RemoteDesktop) -- both send the same
screen_share message.

Wire format, from stream_message/src/lib.rs: native-endian u32 length, then a
serde-tagged JSON body.

    ->  {"type": "screen_share", "monitors": ["HDMI-A-2", ...]}
    <-  {"type": "success", "index": 0} | {"type": "cancel"} | {"type": "busy"}

Two rules learned by breaking this machine earlier:

1. Never answer cancel, and never leave the socket behind. Once the socket
   exists luminous has no fallback -- a cancel kills the session, and a socket
   with nothing listening makes get_selection_from_socket fail with "Cannot
   connect to socket", breaking every screen share on the system. Every path
   here ends in success, and SIGTERM unlinks the socket.

2. Detect RustDesk on "create_relay requested", not "Start cm". Measured here,
   the portal call lands 333-653ms after create_relay but BEFORE Start cm, so
   keying on Start cm declared real sessions "not rustdesk" and cancelled them.
"""

import json
import os
import re
import signal
import socket
import struct
import subprocess
import sys
import threading
import time

SOCK_PATH = os.path.join(
    os.environ.get("XDG_RUNTIME_DIR") or "/tmp", "luminus_selector.sock"
)
CONFIG_PATH = os.path.expanduser("~/.config/luminous-autoselect.json")
RUSTDESK_LOG = os.path.expanduser(
    "~/.local/share/logs/RustDesk/server/rustdesk_rCURRENT.log"
)

# Lines meaning "RustDesk is mid-handshake". create_relay is the earliest and
# the one that matters; the others catch direct, non-relayed connections.
MARKERS = ("create_relay requested", "Handle intranet", "Start cm")
WINDOW_SECONDS = 90


def log(message):
    print(message, flush=True)


def load_config():
    try:
        with open(CONFIG_PATH) as handle:
            data = json.load(handle)
        return data if isinstance(data, dict) else {}
    except FileNotFoundError:
        return {}
    except (OSError, ValueError) as error:
        log(f"ignoring unreadable {CONFIG_PATH}: {error}")
        return {}


def read_exact(conn, count):
    buf = b""
    while len(buf) < count:
        chunk = conn.recv(count - len(buf))
        if not chunk:
            return None
        buf += chunk
    return buf


def read_msg(conn):
    header = read_exact(conn, 4)
    if header is None:
        return None
    (length,) = struct.unpack("=I", header)  # native endian, per u32::from_ne_bytes
    if length > 1 << 20:
        raise ValueError(f"implausible message length {length}")
    body = read_exact(conn, length)
    if body is None:
        return None
    return json.loads(body)


def write_msg(conn, payload):
    body = json.dumps(payload).encode()
    conn.sendall(struct.pack("=I", len(body)) + body)


def rustdesk_cm_running():
    """A `rustdesk --cm` process means a session is being set up.

    Walks /proc instead of grepping `pgrep -af`, because a substring match on
    whole command lines says yes to any shell command merely mentioning
    rustdesk and --cm -- this script's own test harness included.
    """
    try:
        entries = os.listdir("/proc")
    except OSError:
        return False
    for entry in entries:
        if not entry.isdigit():
            continue
        try:
            with open(f"/proc/{entry}/cmdline", "rb") as handle:
                argv = handle.read().split(b"\0")
        except OSError:
            continue
        if not argv or not argv[0]:
            continue
        if os.path.basename(argv[0].decode("utf-8", "replace")) != "rustdesk":
            continue
        if b"--cm" in argv[1:]:
            return True
    return False


def rustdesk_marker_recent():
    try:
        if time.time() - os.path.getmtime(RUSTDESK_LOG) > WINDOW_SECONDS:
            return False
        with open(RUSTDESK_LOG, "rb") as handle:
            handle.seek(0, os.SEEK_END)
            handle.seek(max(0, handle.tell() - 262144))
            tail = handle.read().decode("utf-8", "replace")
    except OSError:
        return False
    for line in reversed(tail.splitlines()):
        if not any(marker in line for marker in MARKERS):
            continue
        stamp = re.match(r"\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})", line)
        if not stamp:
            continue
        try:
            seen = time.mktime(time.strptime(stamp.group(1), "%Y-%m-%d %H:%M:%S"))
        except ValueError:
            continue
        return time.time() - seen < WINDOW_SECONDS
    return False


def choose_index(monitors, config):
    """Index of the saved output, else the first. Never fails."""
    preferred = str(config.get("output") or "").strip()
    if not preferred:
        return 0, "no saved preference; first output"
    for index, name in enumerate(monitors):
        if name == preferred:
            return index, f"saved preference {preferred!r}"
    return 0, f"{preferred!r} not among {monitors}; first output instead"


def notify(summary, body):
    """Best-effort desktop notice. Never raises."""
    try:
        subprocess.run(
            ["notify-send", "--app-name=Screen sharing", summary, body],
            capture_output=True, timeout=5,
        )
    except (OSError, subprocess.SubprocessError):
        pass


def handle(conn):
    with conn:
        while True:
            try:
                request = read_msg(conn)
            except (OSError, ValueError) as error:
                log(f"read failed: {error}")
                return
            if request is None:
                return
            if request.get("type") != "screen_share":
                log(f"ignoring unknown request: {request}")
                continue

            monitors = request.get("monitors") or []
            if not monitors:
                log("request carried no monitors; answering index 0 regardless")
                write_msg(conn, {"type": "success", "index": 0})
                continue

            index, why = choose_index(monitors, load_config())
            if rustdesk_cm_running() or rustdesk_marker_recent():
                log(f"rustdesk connecting -> {monitors[index]!r} ({why})")
            else:
                # Answering here removes the consent prompt a browser or OBS
                # would otherwise get. Do it, but never silently.
                log(f"NOT rustdesk -> auto-answered {monitors[index]!r} ({why})")
                notify(
                    "Screen shared automatically",
                    f"{monitors[index]} was shared without a prompt. "
                    "Stop luminous-autoselect to get the picker back.",
                )
            write_msg(conn, {"type": "success", "index": index})


def main():
    # A socket left by a killed process makes bind() fail, and worse, luminous
    # would connect to it and every screen share would break. The path is ours
    # by construction, so clearing it is safe.
    try:
        os.unlink(SOCK_PATH)
    except FileNotFoundError:
        pass
    except OSError as error:
        log(f"cannot clear {SOCK_PATH}: {error}")
        return 1

    server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    server.bind(SOCK_PATH)
    os.chmod(SOCK_PATH, 0o600)
    server.listen(16)

    def cleanup(signum, _frame):
        # systemd stops us with SIGTERM. An earlier version caught only
        # KeyboardInterrupt, stranded the socket, and broke all sharing.
        log(f"signal {signum}; removing {SOCK_PATH}")
        try:
            os.unlink(SOCK_PATH)
        except OSError:
            pass
        sys.exit(0)

    signal.signal(signal.SIGTERM, cleanup)
    signal.signal(signal.SIGINT, cleanup)

    config = load_config()
    log(f"listening on {SOCK_PATH}")
    log(f"preference: {config.get('output') or '(first output)'} from {CONFIG_PATH}")

    try:
        while True:
            try:
                conn, _ = server.accept()
            except OSError as error:
                log(f"accept failed: {error}")
                continue
            threading.Thread(target=handle, args=(conn,), daemon=True).start()
    finally:
        server.close()
        try:
            os.unlink(SOCK_PATH)
        except OSError:
            pass
    return 0


if __name__ == "__main__":
    sys.exit(main())

chmod +x ~/.local/bin/luminous-autoselect
printf '{\n  "output": "HDMI-A-2"\n}\n' > ~/.config/luminous-autoselect.json

~/.config/systemd/user/luminous-autoselect.service:

[Unit]
Description=Auto-answer the luminous screen picker
PartOf=graphical-session.target
After=graphical-session.target
StartLimitIntervalSec=300
StartLimitBurst=10

[Service]
Type=simple
ExecStart=%h/.local/bin/luminous-autoselect
Restart=always
RestartSec=2

[Install]
WantedBy=graphical-session.target

systemctl --user daemon-reload
systemctl --user enable --now luminous-autoselect

Starting the service is the switch, because luminous only checks whether the socket exists. Stopping it hands the dialog straight back.

The tradeoff, stated plainly

That socket is process-wide, so while this runs luminous never draws a dialog for anything — browser and OBS screen sharing get auto-answered too. There is no way to scope it to RustDesk; portals.conf has no per-application routing, only [preferred] keyed on XDG_CURRENT_DESKTOP. The script fires a desktop notification whenever it auto-answers something that is not RustDesk, so at least it is never silent. If that is not acceptable, systemctl --user stop luminous-autoselect restores the picker instantly.

---

Final architecture

root   /usr/bin/rustdesk --service                     <- /dev/uinput: mouse + keyboard
root     sudo -E ... -u you .../rustdesk --server      <- spawned by the above
you        /usr/lib/rustdesk/rustdesk --server         <- Wayland + portal: capture
you        /usr/lib/rustdesk/rustdesk --tray
you   python3 ~/.local/bin/luminous-autoselect         <- answers the picker
       xdg-desktop-portal-luminous                     <- RemoteDesktop + ScreenCast
       xdg-desktop-portal-hyprland                     <- Screenshot, GlobalShortcuts

Nothing Omarchy-native is affected by any of this: omarchy capture screenshot, region, QR and OCR all use grim+slurp directly, and screen recording uses gpu-screen-recorder's kms backend unless you set OMARCHY_SCREENRECORD_USE_PORTAL=true. There are no references to ScreenCast or xdg-desktop-portal anywhere in /usr/share/omarchy/bin/ or the shell tree.

Unrelated gotcha worth knowing

If RustDesk logs endless failures to http://<your-server>:21114/api/heartbeat, that is the web console / API port, which only exists in RustDesk Server Pro. The open-source hbbs/hbbr provide 21115–21119 only. Connections work fine without it; account login, audit logging and the online/offline indicator do not. On my droplet 21114 timed out identically to a random unused port — nothing listening, firewalled shut.

Environment

Omarchy 4.0.2-1 · Hyprland 0.56.2-1 · xdg-desktop-portal 1.22.1-2 · xdg-desktop-portal-hyprland 1.4.1-1 · xdg-desktop-portal-luminous 0.1.21-1 · rustdesk 1.4.9-1 · NVIDIA GTX 1080 Ti (580.178.04) · self-hosted OSS rustdesk-server

[drivesensei]

this tutorial also works now

[Bulwark-Black]

2026-09-05.15-15-40.-.redacted-blur.mov

[HumintToShell]

I would absolutely love to see this built into the next Omarchy update. While there are plenty of us who are more than willing to piece it together ourselves, I do kind of miss that it just worked out of the box with Fedora 44 Workstation on my laptop and desktop.

This isn't just a nostalgia thing for me, I run my Omarchy laptop as a daily driver and remote into a second machine on-demand whenever I need more horsepower. Right now that means a raw VNC-over-SSH tunnel, which works but has none of the clipboard/file-transfer/performance stuff RustDesk gave me for free. I'd guess I'm not the only one hitting this either — anyone coming over from Fedora/GNOME/KDE where RustDesk just worked is going to notice this is the one piece of their workflow that doesn't carry over.

I saw Bulwark-Black's post further up about getting this working with xdg-desktop-portal-luminous from the AUR, plus a custom systemd env override just so the root rustdesk service can even SEE the wayland session, and then another script on top of that just to auto-click through the screen picker dialog. And hey, it works, and I genuinely appreciate someone put in the effort to document all that — but that's three separate pieces I'd have to go dig up and duct-tape together myself, for something that was just there, out of the box, on Fedora. This is exactly the kind of thing that should be baked into Omarchy by default instead of "here's a guide", the same way pretty much everything else about Omarchy already just works. Love the fact that we've got a fix, but outside of people like us, there are plenty of people who would like to remote into other machines but wouldn't have the gumption to put it all together like this.