CoopAllTheThings

Steam Remote Play Together (RPT) for any XInput game — without breaking DRM, achievements, or playtime.

Existing "donor game" tools (e.g. RemotePlayWhatever) copy a target game's files into a donor game's folder and rename the executable so Steam streams the target under the donor's appid. That breaks DRM-protected games, breaks achievements, and credits playtime to the donor.

CoopAllTheThings takes a different approach: the real game runs normally under its own appid (so DRM, achievements, and playtime all work), while a lightweight mirror app runs under the donor appid. The mirror presents a borderless window that is a live copy of the game's video + audio, and forwards the guests' input back into the real game. Steam's RPT captures the mirror window — so any XInput game becomes Remote-Play-Together-able.

See docs and the in-repo plan for the full design.

Architecture (target)

Concern	Mechanism	Where
Receive guest input	Steam Input / XInput (RPT delivers guests to the focused window)	coop_host.exe
Forward input to game	DLL injection + XInput hook (SafetyHook) — game sees only our pad	coop_hook.dll
Mirror video	Windows Graphics Capture first; IDXGISwapChain::Present hook as the low-latency upgrade	host (+ hook)
Mirror audio	WASAPI process-loopback capture of the game, re-rendered	coop_host.exe
Host ↔ hook IPC	Named shared memory (seqlock for input, shared D3D11 texture for video)	common/

Limitations

• Anti-cheat: the input path injects coop_hook.dll into the target game. Games protected by kernel-level anti-cheat (Easy Anti-Cheat, BattlEye, Vanguard, etc.) will detect the injected module and may kick the player or issue a ban. Such games are explicitly out of scope and unsupported — do not use CoopAllTheThings with them. The tool targets single-player and co-op/local-multiplayer titles without active anti-cheat.
• XInput only: the game must read controllers via XInput (the common case). DirectInput-only / RawInput-only games are not handled.
• Architecture match: the host and hook DLL must match the game's bitness. x64 is supported first; x86 support is a later phase (see the plan).

Status

Phase 0 — donor spike (current). coop_host.exe is a borderless D3D11 window with an ImGui overlay that lists every controller it can see. It exists to validate the riskiest assumption before anything else is built: can Steam RPT stream an arbitrary window launched under a donor appid, and route a guest's gamepad into it?

Later phases (capture, injection, audio) are scoped in the plan and gated on Phase 0 passing.

Building

Requirements: Windows 10/11, Visual Studio 2022 (MSVC + C++ workload), CMake ≥ 3.21.

git clone --recurse-submodules <repo-url>
# or, if already cloned:
git submodule update --init --recursive

cmake -S . -B build -G "Visual Studio 17 2022" -A x64
cmake --build build --config Debug
# output: bin/Debug/coop_host.exe

Third-party dependencies (Dear ImGui, SafetyHook) are git submodules under third_party/; the Steamworks SDK is vendored manually there when wired. No vcpkg / package manager is used.

Phase 0: validating the donor-launch assumption

This is a manual test — it needs Steam, a second person (or second account), and a donor game that supports Remote Play Together.

1. Pick a donor game you own that supports Remote Play Together (check the "Remote Play Together" tag on its store page). The donor only needs RPT support; it is never actually played.

2. Launch the host under the donor's appid. Find the donor's appid (the number in its store URL), then run:

   "C:\Program Files (x86)\Steam\steam.exe" -applaunch <donorAppId> "D:\dev\CoopAllTheThings\bin\Debug\coop_host.exe"
   

   The borderless overlay window should appear and Steam should consider the donor "running" (green status / "Stop" button in the library).

   If the donor ignores the trailing path, set the host as the donor's Launch Options instead ("D:\...\coop_host.exe" %command% variants), or use a launcher such as RemotePlayDetached. Recording which method makes Steam attribute our window to the donor is the main deliverable of Phase 0.

3. Start Remote Play Together from the Steam friends list / overlay and invite a friend (or a second machine/account).

4. Verify on the guest side:

   • The guest sees the borderless overlay window streamed (not a black screen).
   • The guest presses buttons on their controller and the corresponding slot in the overlay lights up. This proves RPT routes guest input into our window as XInput — the foundation the whole tool relies on.

5. Press Esc in the host window to quit.

If steps 2 and 4 both work, the core premise holds and we proceed to Phase 1 (window capture + input injection). If not, we revisit the donor-attribution approach before building further.