# PartyDeck: split-screen game launching on Linux and SteamOS

> PartyDeck runs several instances of a game, each in its own Gamescope window with its own controller and its own save data, and it works out of the box on SteamOS. It is also an early-stage project that says so, with the auto-tiling script depending on KDE Plasma 6 and the launcher UI being controller navigation of the most primitive kind.

**partydeck/partydeck** — A split-screen game launcher for Linux/SteamOS

- Repository: https://github.com/partydeck/partydeck
- Stars: 815 · Forks: 49
- Language: Rust
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/partydeck-partydeck

## Four windows per monitor, tiled automatically

PartyDeck is a split-screen game launcher for Linux and SteamOS, written in Rust, and the headline capability is running multiple instances of a game at once and automatically tiling up to 4 game windows per monitor. The screenshots in the README show a launcher screen and then gameplay split across a display. Native Linux games are supported directly, and Windows games run through Proton-GE with the UMU Launcher. The project positions itself against a console-like experience on a PC rather than on dedicated hardware, and it says it works out of the box on SteamOS. Two features make it more than a window splitter. Each instance only reads from the input devices specifically assigned to that instance, and the project now works with multiple keyboards and mice, which is what makes local multiplayer with separate peripherals possible rather than just multiple controllers.

## Five layers between you and the game

The How it Works section is the most useful part of the README, because it names each layer and what it contributes. An optional KWin Session displays all running game instances and runs a script to automatically resize and reposition each Gamescope window. Gamescope contains each instance of the game in its own window, and has the side effect of receiving controller input even when the window is not currently active, so multiple Gamescope instances can all receive input simultaneously. Bubblewrap uses bindings to mask out evdev input files from the instances so each receives input from one specific controller, and also uses directory binding to give each player their own save data and settings within the games. The runtime layer runs native Linux games through a Steam Runtime, with 1.0 (scout) and 2.0 (soldier) supported, for better compatibility. Windows games go through the UMU Launcher. And Goldberg Steam Emu handles the games that use the Steam API for multiplayer, letting instances connect to each other and to other devices on the same LAN.

## Emulating Steam is what makes local multiplayer work

Goldberg Steam Emu is the piece that removes the most obvious obstacle to running several copies of a Steam game at once. The feature list states that the Steam multiplayer API is emulated, allowing for multiple instances of Steam games without needing multiple sign-ins, and the How it Works section explains that on games using the Steam API for multiplayer, Goldberg is used so the game instances can connect to each other and to other devices on the same LAN. Without that, each instance would try to talk to Steam as a separate signed-in client, and a household with one Steam account would be stuck. The cost is a dependency you do not control, and the build system treats it as optional. The Cargo manifest shows that downloading it is behind the download_deps feature flag, which pulls in reqwest, serde_json, tar, bzip2, sevenz-rust2 and sha2 as build dependencies so the archive can be fetched and verified.

## Profiles are the save data boundary between players

Each instance gets its own save data, but where that data lives is a separate decision, and that is what profiles are for. The profile support allows each player to have their own persistent save data, settings and stats for games, and the profiles menu is where you create them so the data persists across sessions. The mechanism underneath is Bubblewrap directory binding: the sandbox maps a per-player directory over the game's save location, so the game writes to a path that belongs to that profile. The Getting Started section describes two ways to add games. The New button creates a handler from scratch, and the Import button imports a pre-made PartyDeck Handler package, a .pd2 file. Pre-made handlers exist for certain games that do not work out of the box, or that require mods or special configuration, and the handler system is designed so that little manual setup is needed for most games.

## Building it needs a Rust toolchain and optionally a Gamescope fork

The build instructions assume a Rust toolchain with the 2024 Edition, and the mouse and keyboard Gamescope fork additionally needs meson and ninja. The clone is a two-step, with submodules:

```bash
git clone https://github.com/partydeck/partydeck.git
cd partydeck
git submodule update --init --recursive --depth 1
```

Then the release build:

```bash
cargo build --release
```

If built with the download deps flag, the build script fetches the latest releases of Goldberg Steam Emu and the UMU Launcher from GitHub, and the output binary plus the bundled dependencies land in target/release/. Three feature flags control this, and all default to off. download_deps pulls Goldberg and UMU from GitHub releases with known good versions, download_deps_latest does the same with the latest available versions, and build_gamescope builds the mouse and keyboard Gamescope fork from the submodule, which is the one requiring meson and ninja. The two build variants are:

```bash
cargo build --release -F build_gamescope
cargo build --release -F download_deps
```

The Cargo manifest shows the interface library behind it, eframe and egui_extras for the launcher UI with x11 and wayland support, evdev pinned at 0.13.0 for input devices, zbus over D-Bus for the session integration, x11rb, image, rfd for file dialogs and steamlocate for finding Steam installations.

## SteamOS gets the easy path, other desktops need Plasma 6

Platform support is uneven and the README is specific about it. PartyDeck is supported on SteamOS 3.8.1 and newer. On SteamOS, in desktop mode you simply run the partydeck executable, and for Gaming Mode you add GamingModeLauncher.sh as a shortcut to Steam and disable Steam Input for that shortcut in the shortcut settings. On any other Linux distribution the universal AppImage is the recommended way to run it, but the splitscreen tiling script requires KDE Plasma 6.0 or later. On an older Plasma, or on another desktop environment or compositor entirely, you can run PartyDeck without the script, and then resizing and repositioning the game windows is up to you. That is the single largest constraint for anyone outside SteamOS, because the automatic tiling is the feature the whole product is named for. You also want Bubblewrap installed from your package manager, or instances may not isolate correctly on certain games.

## The known issues list is where the real limits are

The README ends with a section on known issues, limitations and to-dos, and it is more informative than the feature list. AppImages and Flatpaks are not supported yet for native Linux games, and handlers can only run regular executables inside folders, so a Flatpak-only title is out of reach. Controller navigation in the launcher is described as super primitive, with an aspiration of a more controller-friendly, Big-Picture-style UI and no immediate plans for it. And games using Goldberg might have trouble discovering LAN games from other devices, with two workarounds given: adding a firewall rule for port 47584, and changing the hostnames of two connected Steam Decks away from the default steamdeck. The project also carries a prominent note that it is in early development and may contain violations of software best practices and security flaws, use at your own discretion. On maintenance, the repository is not archived, the last push was on 2026-10-12, and the release tags are v0.8.7-c, v0.8.7-d and v0.8.7-e, the last two labelled hotfix.

## Conclusion

Adopt PartyDeck if you want couch multiplayer on SteamOS or a KDE Plasma 6 desktop, and you are prepared to build the mouse and keyboard Gamescope fork yourself for the smoothest experience. Do not adopt it if you need AppImage or Flatpak support for native Linux games, because the README states those are not supported yet, or if you want a controller-friendly launcher UI, which it describes as super primitive with no immediate plans. Before you commit, install Bubblewrap, since the README warns that without it instances may not isolate correctly, and check the known-issues list for the LAN discovery port before you plan a multi-Deck session.

## FAQ

### What is PartyDeck?

It is an MIT licensed Rust split-screen game launcher for Linux and SteamOS. It runs multiple instances of a game at once, tiling up to four game windows per monitor, supports native Linux games and Windows games through Proton-GE with the UMU Launcher, and works out of the box on SteamOS.

### How does PartyDeck give each player their own controller and save data?

Gamescope puts each instance in its own window and receives controller input even when the window is not active, and Bubblewrap masks evdev input files so each instance only reads from its assigned controller. Directory bindings inside Bubblewrap give each player their own save data, and profiles make that data persist across sessions.

### What are the system requirements for PartyDeck?

SteamOS 3.8.1 or newer is supported. On other Linux distributions the universal AppImage is recommended, the splitscreen tiling script requires KDE Plasma 6.0 or later, and Bubblewrap must be installed or instances may not isolate correctly on some games.

### How do I build PartyDeck from source?

You need a Rust toolchain with the 2024 Edition, and meson and ninja if you want the mouse and keyboard Gamescope fork. Clone the repo, run git submodule update --init --recursive --depth 1, then cargo build --release, adding -F build_gamescope or -F download_deps for the optional pieces.

## Sources

- [Issues](https://github.com/partydeck/partydeck/issues)
- [License: MIT](https://github.com/partydeck/partydeck/blob/main/LICENSE)
- [partydeck/partydeck on GitHub](https://github.com/partydeck/partydeck)
- [README](https://github.com/partydeck/partydeck/blob/main/README.md)
- [Releases](https://github.com/partydeck/partydeck/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/partydeck-partydeck