I am experiencing the same issue on sway. It began happening very recently, and I have used remote play successfully many times in the past. For me, steam shows me playing the game, but the window never appears.

I am experiencing the same issue on Niri with a RTX 5060 TI. While trying to trouble shoot it, AI gave me this workaround:

• After accepting a Remote Play Together invitation, in a terminal execute the following script:

#!/usr/bin/env bash

# 1. Grab the last streaming command from the log
RAW_CMD=$(grep -E "streaming_client" ~/.local/share/Steam/logs/gameprocess_log.txt | tail -n 1)

if [ -z "$RAW_CMD" ]; then
    echo "No streaming log data found. Click 'Stream' in Steam first."
    exit 1
fi

# 2. Strip hidden Windows carriage returns (\r) so bash can see the real end of the string
CLEAN_CMD=$(echo "$RAW_CMD" | tr -d '\r')

# 3. Extract from the binary path to the end of the line
ARGS=$(echo "$CLEAN_CMD" | grep -oP "'/home/jaopedrodev/.local/share/Steam/ubuntu12_32/streaming_client'.*")

# 4. Cleanly slice off the trailing log wrapper quote
ARGS="${ARGS%\"}"

# 5. Execute via the XWayland fallback path
eval "env -u WAYLAND_DISPLAY $ARGS"

It uses the streaming binary directly, passing the correct arguments that it grabs from steam logs.

I'm having the same issues in NixOS with an GTX 1650 on KDE Plasma Wayland. I got to stressed trying to fix it on Wayland (like with different configurations, beta clients or custom scripts), then tried on X11 Plasma and it works fine.

No ideia why, but it would make my day if someone fixed or even just discovered why this is happening on Wayland.

I am also on NixOS with a 3060 on sway. I also tried X11 and it worked fine there.

Any fix that isnt creating a script?

No fix yet, but I needed to use a slightly different set of ENV variables to get mine to work. I am on an RX 9070xt on nobara KDE, base kde window manager.

#!/bin/bash

LOGFILE="/home/lucinafailure/.local/share/Steam/logs/gameprocess_log.txt"

RAW_CMD=$(grep -E "streaming_client" "$LOGFILE" | tail -n 1)

if [ -z "$RAW_CMD" ]; then
    echo "No streaming_client entry found."
    exit 1
fi

CLEAN_CMD=$(echo "$RAW_CMD" | tr -d '\r')

FULL_CMD=$(echo "$CLEAN_CMD" | sed -E 's/.*tracked process "(.*)"/\1/')

if [ -z "$FULL_CMD" ]; then
    echo "Failed to extract full command."
    exit 1
fi

echo "Running:"
echo "$FULL_CMD"
echo

SDL_VIDEODRIVER=x11 \
EGL_PLATFORM=x11 \
env -u WAYLAND_DISPLAY \
bash -c "$FULL_CMD"

I can post the exact segfault message thing from kde I get if that helps.

I investigated the exact root cause of this crash using GDB and core dumps on Fedora 44 (Wayland, GNOME, NVIDIA RTX 3060 Mobile + Intel UHD, Steam Build 1788400362).

1. Why running the command manually from a terminal works

When Steam launches streaming_client, it hardcodes LD_PRELOAD to inject /home/.../ubuntu12_64/gameoverlayrenderer.so. When running the command manually from a terminal without Steam's environment, LD_PRELOAD is unset, so gameoverlayrenderer.so is not hooked into SDL3.

2. Root Cause: Type Confusion in eglGetDisplay (gameoverlayrenderer.so)

streaming_client links to libSDL3.so.0. On Wayland sessions under Xwayland, SDL3 initializes its video subsystem as X11 (Video initialized: x11) and calls eglGetDisplay(display_id).

Inside gameoverlayrenderer.so:

0x00007f4f5b61ead0 <+0>:   push   %rbx
0x00007f4f5b61ead1 <+1>:   mov    %rdi,%rbx                  ; %rbx = display_id
...
0x00007f4f5b61eaec <+28>:  call   *%rax                      ; real_eglGetDisplay(display_id)
0x00007f4f5b61eaee <+30>:  test   %rax,%rax
0x00007f4f5b61eaf1 <+33>:  mov    %rax,0x8(%rsp)
0x00007f4f5b61eaf6 <+38>:  je     0x7f4f5b61eb20
0x00007f4f5b61eaf8 <+40>:  test   %rbx,%rbx
0x00007f4f5b61eafb <+43>:  je     0x7f4f5b61eb20
0x00007f4f5b61eafd <+45>:  mov    (%rbx),%rdx                ; %rdx = *(void**)display_id
0x00007f4f5b61eb00 <+48>:  test   %rdx,%rdx
0x00007f4f5b61eb03 <+51>:  je     0x7f4f5b61eb20
0x00007f4f5b61eb05 <+53>:  mov    (%rdx),%rsi                ; %rsi = *(void**)rdx
0x00007f4f5b61eb08 <+56>:  lea    -0x21310(%rip),%rdi        ; points to string "wl_display"
0x00007f4f5b61eb0f <+63>:  mov    $0xa,%ecx
0x00007f4f5b61eb14 <+68>:  repz cmpsb (%rdi),(%rsi)          ; <-- SIGSEGV HERE: %rsi is not a valid pointer

• The code assumes display_id is a Wayland struct wl_display * (struct wl_proxy), where *(void**)display_id points to struct wl_interface *, and **(const char***)display_id points to interface->name ("wl_display").
• However, because SDL3 is running in X11 mode, display_id is an Xlib Display * (struct _XDisplay).
• In Xlib (Xlibint.h), the first field of _XDisplay is XExtData *ext_data;.
• When X11 extensions are registered, ext_data points to struct _XExtData, whose first field is int number; (e.g. 0x9).
• gameoverlayrenderer.so reads this integer as a 64-bit pointer (0x559000000009), dereferences it, and crashes immediately with SIGSEGV when executing repz cmpsb.

3. Tested & Working Workaround

Editing /home/<user>/.local/share/Steam/ubuntu12_32/streaming_client to strip gameoverlayrenderer.so from LD_PRELOAD before executing $BIN/streaming_client completely fixes the crash on Wayland:

#!/bin/sh
TOP=$(dirname "$0")
BIN="$TOP/../ubuntu12_64"

# Workaround for SIGSEGV in gameoverlayrenderer.so (eglGetDisplay bug on Wayland/Xwayland)
if [ -n "${LD_PRELOAD:-}" ]; then
    CLEANED_PRELOAD=$(echo ":$LD_PRELOAD:" | sed -E 's|:[^:]*gameoverlayrenderer\.so:|:|g; s|:[^:]*gameoverlayrenderer\.so:|:|g; s|^:+||; s|:+$||')
    export LD_PRELOAD="$CLEANED_PRELOAD"
fi

LD_LIBRARY_PATH="$BIN:$LD_LIBRARY_PATH" exec "$BIN/streaming_client" "$@"

With this in place, streaming_client initializes the player window and connects cleanly.

4. Suggested Upstream Fix

In gameoverlayrenderer.so, check whether the platform is Wayland before assuming display_id is a wl_proxy, or query the platform via eglGetPlatformDisplay / EGL_EXT_platform_base instead of performing unsafe memory dereferences on foreign display pointers.

Sorry, this fix did not work for me.

The workaround provided by dandgabr did work for me but I also had to disable the in-game interface on Steam settings; also you might want to set the modified file into read only as Steam will change it on launch (it did for me), or modify it after Steam opened.

I also had this problem, and followed more or less the same debugging route as @dandgabr , with the help of Claude.
Like him, I tried stripping gameoverlayrenderer.so from the client's LD_PRELOAD and it worked, but then it looked like no input reached the host for some reason, no idea why.

// Preloaded into every Steam process, ahead of Steam's gameoverlayrenderer.so.
//
// In streaming_client (the Remote Play client) the overlay's eglGetDisplay
// hook reads the native display as if it were a wl_display, which faults on
// the X11 display SDL3 hands it (steam-for-linux#13179). The overlay also
// hooks dlsym, which is how SDL3 finds eglGetDisplay, so in that process this
// library answers dlsym("eglGetDisplay") with libEGL's own entry point.
//
// Every other process, and every other lookup, passes straight through to the
// next definition. dlsym forwards as a tail call so that RTLD_NEXT lookups
// still resolve relative to their real caller.
//
// dlsym is reached from other libraries' constructors during startup, so the
// shared setup only uses RTLD_NEXT lookups; a dlopen there would run pending
// constructors ahead of their dependencies.
#define _GNU_SOURCE
#include <dlfcn.h>
#include <errno.h>
#include <pthread.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>

typedef void *(*dlsym_fn)(void *, const char *);
typedef void *(*dlopen_fn)(const char *, int);
typedef void *(*get_display_fn)(void *);

static bool active;
static dlsym_fn libc_dlsym;
static dlsym_fn next_dlsym;
static get_display_fn target_get_display;
static pthread_once_t once = PTHREAD_ONCE_INIT;

// Versioned lookups skip the overlay's unversioned dlsym/dlopen hooks.
static void *libc_symbol(const char *name)
{
    void *sym = dlvsym(RTLD_NEXT, name, "GLIBC_2.34");
    return sym ? sym : dlvsym(RTLD_NEXT, name, "GLIBC_2.2.5");
}

static void init(void)
{
    active = strcmp(program_invocation_short_name, "streaming_client") == 0;
    libc_dlsym = (dlsym_fn)libc_symbol("dlsym");
    if (libc_dlsym)
        next_dlsym = (dlsym_fn)libc_dlsym(RTLD_NEXT, "dlsym");
}

// Runs on the first eglGetDisplay call, by which point the caller has loaded
// libEGL and startup constructors are done.
static void init_egl(void)
{
    pthread_once(&once, init);
    if (!libc_dlsym)
        return;
    if (!active) {
        target_get_display = (get_display_fn)libc_dlsym(RTLD_NEXT, "eglGetDisplay");
        return;
    }
    dlopen_fn libc_dlopen = (dlopen_fn)libc_symbol("dlopen");
    void *egl = libc_dlopen ? libc_dlopen("libEGL.so.1", RTLD_LAZY | RTLD_NOLOAD) : NULL;
    if (egl)
        target_get_display = (get_display_fn)libc_dlsym(egl, "eglGetDisplay");
}

void *eglGetDisplay(void *native_display)
{
    static pthread_once_t egl_once = PTHREAD_ONCE_INIT;
    pthread_once(&egl_once, init_egl);
    if (!target_get_display)
        return NULL;
    __attribute__((musttail)) return target_get_display(native_display);
}

void *dlsym(void *handle, const char *symbol)
{
    pthread_once(&once, init);
    if (active && handle != RTLD_NEXT && strcmp(symbol, "eglGetDisplay") == 0)
        return (void *)eglGetDisplay;
    if (!next_dlsym)
        return NULL;
    __attribute__((musttail)) return next_dlsym(handle, symbol);
}

Build:

gcc -shared -fPIC -O2 -Wall -Wextra -o libsteam-eglfix.so steam-eglfix.c

Steam appends its overlay to the LD_PRELOAD it inherits, so the shim only has to be in Steam's environment at launch:

LD_PRELOAD=/path/to/libsteam-eglfix.so${LD_PRELOAD:+:$LD_PRELOAD} steam

32-bit Steam processes skip it with a harmless wrong ELF class line, the same one the overlay's own 64-bit entry already produces.

I've only run this on NixOS, where I inject it via the Steam package's FHS profile (steam.override { extraProfile = ''export LD_PRELOAD=…''; }). I haven't tested it on other distributions or with the Flatpak/Snap Steam. The code should still work, but probably you need some adjusting to this.

These fixes didn't work for me on Fedora 44 KDE

I'd like to apologize, for the issue is fixed for me, and there's only one of two reasons that could be the case. I was trying to solve a completely different issue involving the steam overlay crashing, when I noticed nomachine's /run/host/usr/NX/lib/libnxegl.so while inspecting steam from terminal (btw when a something crashes can you automatically direct users to a log of the things that would normally print here so things don't just fail silently?), so I uninstalled it which not only fixed that issue, but also this issue. there was also a steam client update which took me off the beta branch, so it was either uninstalling nomachine or this update that fixed it, in the former case, sorry for wasting everyone's time.