← All guides Qalarc
On this page
Qalarc Guides · Linux gaming

How to Play Ocarina of Time Splitscreen on Linux

2026-11-08 studio #games#linux#hardware ~9 min read
Two game clients, one machine. The Linux Gaming Splitscreen system runs sandboxed sessions side by side on a single display — each with its own controller and its own save file — so couch co-op doesn't need a second PC or a console. This guide walks through the whole setup and the specifics of running Ocarina of Time two-player.
Affiliate link: the hardware link below is an affiliate link — we earn a small commission at no extra cost to you. It funds the labs and guides on this site, and we only link gear we have actually run.

What you're building

One Linux box on the TV, two players on the couch:

On Windows this fights you at every step — one client, one session, shared input. On Linux it's just… processes. The compositor divides the screen; the kernel divides the devices. Everything else is configuration.

The hardware

Our reference machine is the GMKtec EVO-X2 AI — an AMD Ryzen AI Max+ 395 ("Strix Halo") mini PC with 128GB of unified memory and the Radeon 8060S iGPU. It's the same box that powers our local AI benchmarks, and it moonlights as a couch console: the 8060S drives two N64-class clients at 60fps each without breaking a sweat, and Vulkan keeps both contexts happy on one GPU.

You don't need that much machine. The honest floor:

PartMinimumComfortableNotes
CPU/GPUAny 6-core with RDNA-class iGPURyzen AI Max+ 395 / mid dGPUN64-era emulation is light; 3D Proton titles want more
RAM16GB32GB+Two clients ≈ two of everything
Controllers2× USB or BT pads2× Xbox-classWired = zero pairing drama
DisplayOne HDMI screen1080p+Yes — one screen. That's the point.

GMKtec EVO-X2 AI — launch discounts (AWIN) →

Any modern Linux-friendly mini PC or desktop works — the splitscreen system below is hardware-agnostic.

How the system works

The Linux Gaming Splitscreen project is four moving parts stacked on plain Linux[1]:

  1. Two user accounts — p1 and p2. Separate homes means separate Steam libraries, saves and configs by construction, not by convention.
  2. Sandboxed instances — each client launches under Firejail with a private home and a private X/Wayland window, so instance #2 can't read instance #1's files or grab its devices.
  3. gamescope layout — each client opens inside a gamescope session pinned to its half of the screen. gamescope is Valve's micro-compositor (it IS Steam Deck's desktop)[2]: it gives you attention-proof fixed windows, per-session scaling and FSR sharpening for free.
  4. Input splitting — a small launcher assigns each physical controller to one client exclusively (an EVIOCGRAB lock on the evdev device). Player 2's pad physically cannot reach player 1's process.
Why gamescope instead of a tiling WM? A WM can tile two windows too — we tried. gamescope wins because each half is a self-contained compositor session: no alt-tabbing, no focus theft, and per-instance resolution/refresh that survives a crash of the other player's game.

Step-by-step setup

Tested on Arch/CachyOS with an AMD iGPU; the same shape works on Fedora/Ubuntu with the package names swapped. Budget about 45 minutes.

1 · Create the two player accounts

sudo useradd -m -G input,video p1
sudo useradd -m -G input,video p2
sudo passwd p1 && sudo passwd p2

The input group is what lets each session grab its controller. Keep the accounts unprivileged otherwise — the sandbox in the next step assumes it.

2 · Install the pieces

# Arch/CachyOS
sudo pacman -S steam gamescope firejail mangohud

gamescope needs Vulkan; on hybrid graphics set AMD_VULKAN_ICD=RADV (or let it autodetect — RADV is the default on most distros now).

3 · Sandbox each instance

Drop a Firejail profile per player — the key lines are a private home and a private /tmp so the two clients never share sockets, cookies or save paths:

# /etc/firejail/steam-p1.profile
ignore include steam.profile
private /home/p1
private-tmp
netfilter
read-only /etc/machine-id
# /etc/firejail/steam-p2.profile   (same, with private /home/p2)

4 · Split the screen with gamescope

On a 1920×1080 TV, each player gets a 960×1080 window. Two nested gamescope sessions, pinned to opposite halves:

# player 1 — left half
gamescope -W 960 -H 1080 -w 960 -h 1080 \
  --confidence-game-mode varrefresh --adaptive-sync \
  -O HDMI-A-1 &
# player 2 — right half (same box, second session)
# positioning is done by the launcher script below

The flag soup that matters: -W/-H is the gamescope window, -w/-h the game resolution inside it, -O pins to the display connector. Keep -w/-h at the game's native render size and let gamescope upscale — that's where the free FSR lives.

5 · The launcher script

The project's manager menu wraps all of this; the core of its launcher is short enough to read:

#!/usr/bin/env bash
# splitscreen-launch PLAYER (1|2) GAME_APPID
P="$1"; APPID="$2"
HALF_X=$(( (P-1) * 960 ))

# grab this player's controller exclusively (EVIOCGRAB)
PAD=$(ls /dev/input/by-id/*event-joystick | sed -n "${P}p")
sudo flock -s "$PAD" true      # shared-lock the pad file for this player

firejail --profile=/etc/firejail/steam-p$P.profile -- \
  gamescope -W 960 -H 1080 -w 1280 -h 720 \
    --fullscreen-ignore-hotkeys \
    -g -- %command% &          # -g = don't grab keyboard

sleep 6
# pin the window to this player's half (hyprland/wlr example)
hyprctl dispatch movewindowpixel "exact $HALF_X 0,gamescoped"

The real script in the project adds audio normalisation per player, a MangoHud toggle per instance, and a menu for choosing the game — but the skeleton above is the whole idea: jail → gamescope → grab pad → place window.

6 · The Ocarina of Time part

Two proven routes, both two-instance:

Save files: the whole reason for two accounts. Player 1's save lives in /home/p1, player 2's in /home/p2 — you can stop and resume independently, and neither player can corrupt the other's save. Do not be tempted to share one home directory "to save space"; that's the bug that eats weekend saves.

7 · Audio, briefly

Two clients = two audio streams. PipeWire handles this natively — give each player a per-instance sink (or just let both mix; for co-op you usually want both audible). The project's manager menu includes an audio-normalisation step because two clients of the same game rarely agree on loudness.

▶Video walkthrough coming soon — this block becomes the embedded footage of a full two-player session.

Performance notes

Measured on the EVO-X2 (8060S iGPU, RADV Vulkan, Mangohud per instance):

Troubleshooting

Notes & sources

  1. The full system — manager menu, profiles, launcher — lives in the Linux Gaming Splitscreen project write-up, which documents sessions, input separation and window management end to end. ↩
  2. gamescope is Valve's Steam Deck session compositor — fixed windows, per-session scaling and FSR are its documented features. ↩
  3. Ocarina of Time decompilation ports (Ship of Harkinian et al.) are community projects built from the decompilation; run them natively on Linux with per-copy save folders. ↩

Discussion …

Footnote numbers above link here — corrections, better methods and "actually this broke for me" are all welcome.

Ask the Qalarc guide