On this page
How to Play Ocarina of Time Splitscreen on Linux
What you're building
One Linux box on the TV, two players on the couch:
- Two full game clients — each player launches their own instance, with their own saves, their own settings and their own controller. Nothing is shared.
- A split window layout — the screen divides into two fixed halves, one
per player, via
gamescopewindow placement. - Hard input separation — each controller is grabbed exclusively by one client, so P2's inputs can never leak into P1's game.
- Sandboxed sessions — each client runs in its own jail with its own home directory, so the two Steams (or two game instances) can't touch each other's data.
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:
| Part | Minimum | Comfortable | Notes |
|---|---|---|---|
| CPU/GPU | Any 6-core with RDNA-class iGPU | Ryzen AI Max+ 395 / mid dGPU | N64-era emulation is light; 3D Proton titles want more |
| RAM | 16GB | 32GB+ | Two clients ≈ two of everything |
| Controllers | 2× USB or BT pads | 2× Xbox-class | Wired = zero pairing drama |
| Display | One HDMI screen | 1080p+ | 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]:
- Two user accounts —
p1andp2. Separate homes means separate Steam libraries, saves and configs by construction, not by convention. - 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.
- 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.
- Input splitting — a small launcher assigns each physical controller to
one client exclusively (an
EVIOCGRABlock on the evdev device). Player 2's pad physically cannot reach player 1's process.
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:
- Native port (recommended): the Ocarina of Time decompilation ports (Ship of Harkinian and friends)[3] run natively on Linux — no Proton needed. Give each player their own copy in their own home directory (the portable-mode builds keep saves/configs next to the binary), launch each copy inside that player's gamescope half, and hand each player their controller. This is how we play: two instances, synced randomizer seeds, zero input crosstalk. Co-op and race seeds are a community staple — check the port's own docs for current options.
- Through Steam: put a copy in each player's Steam library (family sharing covers one purchased copy across the two accounts) and let each sandboxed Steam instance run it under Proton. Use this when you want Steam Remote Play-style overlays or achievements per player.
/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.
Performance notes
Measured on the EVO-X2 (8060S iGPU, RADV Vulkan, Mangohud per instance):
- N64-class ports: 60fps locked in both halves, GPU utilisation under 30% — this workload is trivial for modern iGPUs.
- Each gamescope session renders independently, so one client hitching doesn't stall the other (separate swapchains, separate queues).
- If a heavier 3D title dips: drop each half's render resolution
(
-w 640 -h 720) and let gamescope FSR upscale. The TV does the rest. - Watch VRAM carve on Strix Halo boxes if the machine also runs local AI — the mini PC guide covers the carve trade-off.
Troubleshooting
- Controller controls both games — the EVIOCGRAB didn't take. Check the
pad mapping with
ls /dev/input/by-id/; Bluetooth pads change enumeration order between boots, so bind by ID not index. - Steam wants to "log in elsewhere" — two instances need two accounts. One purchased game + Steam Family Sharing covers the second player.
- gamescope refuses to start — it needs the Vulkan + libliftoff stack;
on Arch install
gamescopefresh rather than a months-old cache, and checkvulkaninfosees your iGPU first. - One half is laggy, the other fine — that's a display refresh policy
mismatch; force both sessions to the same mode with
--confidence-game-mode varrefreshor fixed refresh.
Notes & sources
- 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. ↩
- gamescope is Valve's Steam Deck session compositor — fixed windows, per-session scaling and FSR are its documented features. ↩
- 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.