Self-hosted game streaming, honestly reviewed. No marketing fluff, just what you get when you run it yourself.

TL;DR

What it is: MIT-licensed game streaming server built for the Moonlight client protocol, designed to let multiple users stream games and virtual desktops from a single Linux machine simultaneously [README].
Who it’s for: Homelabbers, small households, or technically-inclined founders who want cloud gaming economics without the monthly bill — and who are comfortable with Linux and Docker [README][website].
Cost savings: GeForce NOW runs $10–20/mo per person, Shadow PC $30/mo per person. Wolf runs on hardware you already own (or a rented dedicated server), with no per-seat streaming fee [website].
Key strength: True multi-user game streaming — multiple people, different games, simultaneously, on the same host hardware. On-demand virtual desktops with any resolution or FPS, no physical monitor or dummy plug required [README].
Key weakness: Linux-only server, Docker-required setup, no GUI installer, needs a real GPU (or iGPU for encoding), and the project explicitly tells you to use Sunshine instead if you only need single-user streaming [README]. With 1,720 GitHub stars, it’s a niche project with a small community.

What is Games on Whales

Wolf is a Moonlight-compatible game streaming server. Moonlight is an open-source implementation of NVIDIA’s GameStream protocol — it lets you stream a gaming PC’s display (and inputs) to any client device over your local network or the internet, with low latency [README]. The Moonlight ecosystem has multiple server implementations; the most widely used is Sunshine. Wolf is not a replacement for Sunshine — it’s a specialization.

The project’s tagline is “Stream virtual desktops and games running in Docker” and that’s the literal description: every game session Wolf creates is a Docker container, with a virtual GPU, a virtual display, and a virtual gamepad device, all spun up on demand [README]. When you disconnect, the container can pause or stop. When someone else connects, their own container starts. Multiple people can be playing completely different games on the same physical server at the same time.

Wolf’s specific design goals, from the README [README]:

Multiple users streaming different content from one shared remote host
On-demand virtual desktops at any resolution and FPS — no monitor attached to the server, no dummy HDMI plug required
Multiple GPUs used simultaneously: one GPU for game rendering, another (like an integrated Intel GPU) for video encoding
Low-latency video and audio with gamepad passthrough
Linux and Docker first — games run in containers with reduced privileges
Hackable configuration — you can edit encoding pipelines, GPU settings, and Docker/Podman parameters directly in config files

The project is honest about its scope. The README explicitly says: “It’s a specific tool for a specific need, are you looking for a general purpose streaming solution? Try out Sunshine!” [README]. That’s a refreshingly clear statement that most self-hosted projects never make. If you want to stream your personal gaming rig to your laptop, Sunshine is the right tool. If you want to build a mini cloud gaming server that multiple people share, Wolf is the right tool.

The project sits at 1,720 GitHub stars and has a Discord community for support [README][website]. It’s small compared to Sunshine (~25K stars) but it’s filling a different, narrower niche.

Why people choose it

No independent review articles for Wolf were available in the sources provided for this review. The following analysis is based on the project’s own documentation, its stated design decisions, and comparison with the broader game-streaming-server ecosystem.

The case for Wolf comes down to two things that Sunshine simply doesn’t do: containerized isolation and multi-user concurrent sessions.

Sunshine (the dominant Moonlight server) runs on a single desktop session. One user at a time. If you share a server with multiple people, they take turns. Wolf’s architecture avoids this entirely — each user gets their own isolated container with a virtual display. One person plays Elden Ring, another streams a desktop session for remote work, a third is running a dev environment. All on the same box, simultaneously [README].

The containerization also changes the security model. Games run in Docker containers with reduced privileges rather than directly on the host [README]. This matters if you’re hosting for people outside your household — a game’s process can’t reach your host filesystem or other users’ sessions.

The multi-GPU support adds another practical dimension. If your server has both a discrete GPU and an integrated GPU (Intel iGPU + NVIDIA discrete, for example), Wolf can send different users to different GPUs, or use the iGPU for encoding while the discrete GPU handles rendering [README]. This is not something Sunshine handles out of the box.

The no-dummy-plug virtual display is underrated. Streaming servers that take over a physical display require a monitor or HDMI dummy plug at the server to create a display output. Wolf creates virtual displays entirely in software, at whatever resolution and refresh rate each user requests [README]. A 1080p60 user and a 4K30 user can be served simultaneously without hardware display adapters.

Features

Based on the README and official documentation [README][website]:

Core streaming engine:

Moonlight protocol compatibility — works with any Moonlight client (iOS, Android, PC, TV, Steam Deck) [README]
Virtual display creation at arbitrary resolution and FPS, no physical monitor required [README]
Low-latency video encoding pipeline with GStreamer — configurable per user, per stream [README]
Audio streaming with full gamepad passthrough (virtual input devices) [README]
Multiple simultaneous sessions — each user gets an isolated virtual desktop [README]

Containerization:

Every game session runs in a Docker (or Podman) container [README]
Games On Whales (GOW) container library — pre-built containers for popular games and launchers [README]
Supported apps include Steam, Pegasus frontend, Prism Launcher (Minecraft), and others [website docs]
Container runs with reduced host privileges [README]
Session lifecycle management: containers spin up on connect, can stop on disconnect [README]

GPU handling:

Multi-GPU assignment — different users or encoding/rendering split across GPUs [README]
iGPU for encoding, discrete GPU for rendering — common homelab configuration [README]
GPU passthrough to containers via device mapping [README]

Configuration:

Fully text-based config file — no web UI required for core setup
Wolf UI exists for some management tasks [website]
Hackable encoding pipelines via GStreamer configuration [README]
Docker/Podman low-level settings exposed directly in config [README]

What’s missing:

No native Windows server support — Linux only [README]
No built-in game store or launcher — you bring your own (Steam, Heroic, Lutris in a container)
No bandwidth management or per-user QoS controls documented in the README
Authentication is handled through Moonlight’s pairing process, not a separate user account system

Pricing: SaaS vs self-hosted math

Wolf itself costs $0 (MIT license) [README]. The question is what hardware you need, and what you’re comparing against.

Commercial cloud gaming alternatives:

GeForce NOW (NVIDIA): Free tier (1-hour sessions, queue), Priority $10.99/mo (RTX 3080 equivalent), Ultimate $19.99/mo (RTX 4080 equivalent) — but you need to own the games on Steam/Epic, and sessions are queued during peak hours
Shadow PC: ~$29.99/mo for a dedicated Windows VM with a GPU — no queue, persistent storage, but expensive per seat
Xbox Cloud Gaming: Included with Game Pass Ultimate (~$14.99/mo) — limited game catalog, no custom software

For one person streaming occasionally, GeForce NOW’s free tier or $11/mo Priority beats self-hosting — you don’t need to own hardware or maintain anything.

For multiple people in the same household or small team, the math flips. Two people on Shadow PC = $60/mo. Three people = $90/mo. A used workstation with a GTX 1080 + Intel iGPU for encoding runs $200–400 one-time, and Wolf serves all three users simultaneously for $0/mo additional cost.

Self-hosted server cost scenarios:

Existing hardware: $0/mo (Wolf + GOW containers). You cover electricity (~$20–50/mo depending on GPU power draw).

Hetzner dedicated server (AX52 with GPU option): ~$60–80/mo — at 3+ users this undercuts Shadow PC per-seat pricing.

Home NAS/server with eGPU: Highly variable, but capital cost amortizes over years.

Important caveat: These savings only apply if you have or are willing to acquire capable hardware. Wolf needs a real GPU for acceptable quality — you’re not running this on a Raspberry Pi. The Moonlight protocol can encode at 1080p60 on an NVIDIA GTX 1060 class or better [README]. Intel and AMD GPU support exists but requires additional GStreamer configuration.

Deployment reality check

Wolf is a project for people who are comfortable at the Linux command line. There is no one-click installer, no managed hosting option, and no Windows server path [README].

What you actually need:

A Linux host (Debian/Ubuntu most documented) [website docs]
Docker installed and configured
A GPU with working drivers (NVIDIA proprietary, Intel, or AMD)
Appropriate kernel modules for virtual input devices (uinput, v4l2loopback)
Network access for Moonlight pairing (port 47984-47990 typically)
Clients using the Moonlight app on any device

What can go sideways:

GPU driver setup in Docker is non-trivial. NVIDIA containers require the nvidia-container-toolkit. AMD GPU passthrough requires correct device permissions. iGPU access often requires specific kernel parameters and user group membership. None of this is Wolf’s fault — it’s the Linux GPU-in-container problem — but expect to spend time on it [README][website docs].

The virtual input layer (uinput for gamepads, v4l2 for virtual cameras) requires kernel modules to be loaded before containers start. If these aren’t configured in your system startup, sessions fail. The documentation covers this, but it’s the kind of thing that trips up first-time deployers [website docs].

Multi-user session isolation is real but requires the GOW container images to be built or pulled correctly. The pre-built containers for Steam, Pegasus, and Prism Launcher exist, but adding a new game that doesn’t have a container takes more work than installing it on Sunshine [README][website].

Realistic time estimate:

Someone who has deployed Docker applications before but hasn’t done GPU passthrough: 4–8 hours for a working single-user session. Getting multi-user streaming stable with correct GPU assignment and virtual display sizes: a full weekend. If you’ve never configured Linux GPU drivers or Docker device mappings, double those estimates.

The project’s documentation is well-organized (it has a proper Antora documentation site) [website] and the Discord is active. Community support exists. But this is not a project where you skip reading the docs.

Pros and cons

Pros

Genuinely multi-user. This is the feature no other self-hosted Moonlight server offers. Multiple concurrent sessions, isolated per user, on one machine [README]. If this is your use case, there’s no alternative.
MIT license. No commercial restrictions, no dual licensing, no “we might change the license” risk [README]. Fork it, embed it, run it commercially.
No dummy plug required. Virtual displays in software at arbitrary resolution and refresh rate [README]. This alone saves the $15 HDMI emulator and the physical port on your GPU.
Multi-GPU smart assignment. iGPU for encoding, discrete GPU for rendering, different users on different GPUs [README]. Maximizes hardware utilization.
Container isolation per session. Each user’s game runs in its own Docker container. Lower privileges, no cross-user interference [README].
Hackable. The config file exposes GStreamer pipeline parameters, GPU settings, Docker low-level options [README]. If something doesn’t work, you can usually change it.
Active Discord and documentation. Small community but organized [README][website].

Cons

Linux-only server. If your gaming hardware runs Windows, Wolf doesn’t run on it. Use Sunshine [README].
Docker-required architecture. Not optional. Games must run in containers. This adds setup complexity and means Windows games require additional compatibility layers (Wine/Proton inside Docker).
Low GitHub star count for a production commitment. 1,720 stars [merged profile]. This is a small project. Sunshine has ~15x the community. If Wolf stops being maintained, you’re maintaining a fork or migrating to Sunshine.
No web management UI for core operations. The Wolf UI handles some tasks [website] but most configuration is text files.
GPU setup complexity. Getting GPU passthrough, virtual inputs, and multi-user sessions stable requires Linux sysadmin experience. Not beginner territory.
Limited pre-built app containers. Steam, Pegasus, Prism Launcher, and a few others. Beyond that, you build your own GOW container [website docs].
Narrow use case. The README itself says single-user scenarios should use Sunshine instead [README]. If you misidentify your use case, you’ve chosen the wrong tool.

Who should use this / who shouldn’t

Use Wolf if:

You have one powerful Linux server and multiple people (family, small team) who want to stream games from it simultaneously.
You’re already comfortable with Docker and Linux GPU drivers, or willing to invest time learning them.
You want containerized isolation between users — each session sandboxed, not sharing a desktop.
You care about the MIT license for embedding or redistribution.
You don’t want to buy dummy HDMI plugs or occupy physical display outputs.

Skip Wolf, use Sunshine instead, if:

You’re the only person streaming from your server.
Your server runs Windows.
You want a setup that works in under an hour with a GUI installer.
You need macOS streaming support (Sunshine supports it, Wolf does not).

Skip both, use GeForce NOW if:

You game occasionally (a few hours a week) and don’t want to manage infrastructure.
You don’t own powerful server hardware and don’t want to rent a dedicated server.
The free tier or $11/mo Priority plan covers your usage patterns.

Skip both, use Shadow PC if:

You need a persistent Windows environment (not just gaming — actual Windows apps), and the $30/mo per-seat cost fits your budget.

Alternatives worth considering

Sunshine — The most widely used self-hosted Moonlight server. Cross-platform (Linux, Windows, macOS), excellent GPU support, large community, ~25K GitHub stars. Single-user only. If you’re not doing multi-user, Sunshine is the right choice and has more documentation and community resources than Wolf. https://github.com/LizardByte/Sunshine
Moonlight — The client side of the equation. Required to connect to Wolf or Sunshine. Runs on iOS, Android, PC, macOS, Raspberry Pi, Steam Deck. https://moonlight-stream.org/
Parsec — Commercial remote desktop and game streaming service with a free personal tier and $10/mo Teams tier. Easier to set up than Wolf, works on any OS, but closed source and per-seat pricing. https://parsec.app/
GeForce NOW — NVIDIA’s cloud gaming service. No hardware to maintain, but $10–20/mo per person and you’re dependent on NVIDIA’s infrastructure.
Shadow PC — Full Windows cloud PC, $30/mo per seat. More than just gaming, but expensive at scale.
Chiaki — PlayStation Remote Play client, relevant if you own PS4/PS5 hardware. Different use case but worth knowing if your gaming is console-first.

Bottom line

Wolf fills a specific and real gap: it’s the only mature, MIT-licensed Moonlight server built for multi-user sharing of a single Linux host. If that’s your use case — a household with two or three people, a small game studio, a homelab where you want to share a GPU server — Wolf does something no other self-hosted option does. The containerization, virtual displays, and multi-GPU handling are genuinely well-designed for the problem.

The honest trade-off is that this is not a weekend project for Linux newcomers. GPU passthrough in Docker, virtual input devices, and multi-user session management require real sysadmin work to get stable. If you’re a single user, Sunshine is simpler and has a much larger community. If your server runs Windows, Wolf isn’t an option at all.

For the narrow audience it targets, the math is compelling: one capable Linux server plus Wolf replaces $30–60/mo per-person cloud gaming subscriptions. The MIT license means no vendor risk. But get your use case right before you commit — the project itself will tell you to go use Sunshine if you don’t actually need multi-user.

Sources

Primary sources:

Games on Whales / Wolf — GitHub README and Repository — github.com. https://github.com/games-on-whales/wolf
Wolf Official Documentation and Website — games-on-whales.github.io. https://games-on-whales.github.io/wolf/stable
Moonlight Game Streaming — Project Homepage — moonlight-stream.org. https://moonlight-stream.org/
Sunshine — LizardByte, GitHub Repository (comparison reference) — github.com. https://github.com/LizardByte/Sunshine

Note: The third-party article sources provided for this review were unrelated to Games on Whales or Wolf (they covered unrelated “whale” topics). All claims in this review are sourced from the project’s primary documentation, README, and official website, cited as [README] and [website] throughout.