Game Streaming: Sunshine, Moonlight, and Steam Link

Introduction

Imagine playing the latest AAA games on your tablet while lounging on the couch, or gaming on your laptop in bed with zero performance compromises. What if your aging office PC could suddenly run Cyberpunk 2077 at max settings? Game streaming makes this possible by offloading the heavy lifting to your gaming PC or homelab server while streaming the video to any device in your home.

In 2025, game streaming has matured dramatically. NVIDIA’s GameStream (now discontinued) paved the way, but open-source alternatives like Sunshine have not only matched but exceeded commercial solutions. Combined with the Moonlight client ecosystem, you can achieve sub-10ms latency streaming that feels indistinguishable from playing locally - all for free, with complete control over your data.

The use cases are compelling:

Living room gaming: Play PC games on your TV without moving your gaming rig
Multi-room access: Game anywhere in your house from any device
Work-from-home gaming: Use your work laptop for gaming (don’t tell your boss)
Laptop battery life: Stream demanding games without draining your portable device
Future-proofing: Upgrade your gaming server, stream to any device for years

Unlike cloud gaming services (GeForce NOW, Xbox Cloud Gaming) which have subscription fees, data caps, and limited game libraries, self-hosted game streaming gives you unlimited playtime on games you already own, with zero ongoing costs and complete privacy.

By the end of this guide, you’ll:

Understand the game streaming landscape (Sunshine, Moonlight, Steam Link)
Install and configure Sunshine server on Windows/Linux
Set up Moonlight clients on multiple devices (Android, iOS, PC, Raspberry Pi)
Optimize for lowest possible latency (competitive gaming viable)
Configure multi-monitor and HDR streaming
Integrate with Steam for seamless game launching
Stream from your homelab gaming VM
Troubleshoot common issues (network, encoding, input lag)

Real-world performance: On a proper network setup (wired ethernet, WiFi 6), you can achieve:

Latency: 5-15ms (competitive gaming viable)
Resolution: Up to 4K60 or 1080p120
Bitrate: 50-150 Mbps (adjust for your network)
Quality: Visually lossless with H.265 encoding

Let’s build your personal game streaming infrastructure.

Prerequisites

Hardware Requirements

Host PC/Server (the machine that runs games):

GPU:
- NVIDIA GTX 900 series or newer (recommended for NVENC)
- AMD RX 400 series or newer (AMF encoder)
- Intel 7th gen or newer (QuickSync)
CPU: 4 cores minimum (6+ for AAA games)
RAM: 16GB minimum (32GB recommended for smooth multitasking)
Network: Gigabit ethernet strongly recommended

Client Devices (where you play):

Android: Phone/tablet (Android 5.0+)
iOS: iPhone/iPad (iOS 13+)
PC: Windows, Linux, macOS
TV: Android TV, Raspberry Pi, NVIDIA Shield
VR: Oculus Quest (via Moonlight)

Network Requirements:

For 1080p60 gaming:

Ethernet: Gigabit (1000 Mbps) host to router
WiFi: WiFi 5 (AC) minimum, WiFi 6 strongly recommended
Latency: Under 5ms ping on local network

For 4K60 or 1080p120:

Ethernet: Required on both host and client
Router: Gigabit switch, QoS support
Bandwidth: 100+ Mbps free capacity

Software Prerequisites

Host PC:

OS: Windows 10/11, Linux (Ubuntu 20.04+), macOS
GPU Drivers: Latest NVIDIA, AMD, or Intel drivers
Games: Installed and working on host PC

Network Requirements:

Router: Port forwarding capability (for outside-home streaming)
No CGNAT: Some ISPs use carrier-grade NAT which blocks external streaming
Static local IP: For the host PC (set in router DHCP reservation)

Knowledge Assumptions

You should be comfortable with:

Basic Windows/Linux system configuration
Installing software and drivers
Basic networking (IP addresses, ports, WiFi vs ethernet)
Gaming PC setup

Helpful but not required:

Firewall configuration
GPU encoding concepts
Network performance tuning

Understanding Game Streaming Technology

Before jumping into installation, let’s understand how game streaming works and the available solutions.

How Game Streaming Works

The streaming pipeline:

Game Rendering (Host PC)
         ↓
GPU Encodes Video (H.264/H.265/AV1)
         ↓
Network Stream (UDP, low latency)
         ↓
Client Decodes Video (Hardware decoder)
         ↓
Display on Screen
         ↑
Input (Controller/Keyboard) sent back to Host

Key components:

Capture: Game output is captured from GPU framebuffer
Encode: GPU’s hardware encoder (NVENC, AMF, QuickSync) compresses video
Transmit: Encoded stream sent over network (typically UDP)
Decode: Client device’s hardware decoder decompresses video
Display: Video displayed with minimal latency
Input: Controller/keyboard input sent back to host with low latency

Total latency breakdown:

Capture: ~1ms
Encode: 1-5ms (hardware encoder)
Network: 1-10ms (local network)
Decode: 1-5ms (hardware decoder)
Display: 1-16ms (depends on client display refresh rate)
Total: 5-40ms (competitive with local gaming below 20ms)

Sunshine vs. Moonlight vs. Steam Link

Sunshine (Server Software):

What it is: Open-source game streaming host (server)
Runs on: Windows, Linux, macOS
Encoding: NVENC (NVIDIA), AMF (AMD), QuickSync (Intel), software (CPU)
Features:
- Up to 4K120 streaming
- HDR support
- Multi-monitor streaming
- Custom resolution and refresh rates
- Game/app launching
- Controller passthrough
License: Free and open-source (GPL v3)

Moonlight (Client Software):

What it is: Open-source game streaming client
Runs on: Windows, Mac, Linux, Android, iOS, Raspberry Pi, more
Decoding: Hardware-accelerated on most platforms
Features:
- Low-latency input
- Controller support (Xbox, PlayStation, generic)
- Touch screen controls (mobile)
- Keyboard/mouse streaming
License: Free and open-source (GPL v3)

Steam Link:

What it is: Valve’s official game streaming solution
Limitations: Only streams Steam games
Pros: Easy setup, integrated with Steam
Cons: Higher latency than Sunshine/Moonlight, less flexible

Comparison Matrix:

Feature	Sunshine + Moonlight	Steam Link
Streaming Quality	Up to 4K120	Up to 4K60
Latency	5-15ms typical	15-30ms typical
Non-Steam Games	✅ Yes	❌ No (workarounds exist)
HDR Support	✅ Yes	❌ No
Multi-Monitor	✅ Yes	⚠️ Limited
Custom Resolutions	✅ Yes	❌ No
Controller Support	✅ Excellent	✅ Excellent
Setup Complexity	Medium	Easy
Open Source	✅ Yes	❌ No

Our recommendation: Use Sunshine + Moonlight for maximum flexibility and performance. Use Steam Link if you only play Steam games and want simplest setup.

Hardware Encoding: NVENC vs AMF vs QuickSync

NVIDIA NVENC (Best Overall):

Quality: Excellent (especially 7th gen on RTX 30/40 series)
Performance Impact: ~1-3% GPU usage
Latency: Lowest (1-3ms encode time)
Supported GPUs: GTX 900 series and newer
Max Resolution: 4K120 (on RTX 30/40 series)

AMD AMF (Good Alternative):

Quality: Good (improving with each generation)
Performance Impact: ~2-5% GPU usage
Latency: Low (2-5ms encode time)
Supported GPUs: RX 400 series and newer
Max Resolution: 4K60 (on RX 6000/7000 series)

Intel QuickSync (Budget Option):

Quality: Acceptable for casual gaming
Performance Impact: Minimal (uses iGPU)
Latency: Moderate (3-7ms encode time)
Supported CPUs: 7th gen Intel and newer
Max Resolution: 4K60

Performance Comparison (encoding 1080p60):

NVENC: ~1ms latency, excellent quality
AMF: ~2ms latency, good quality
QuickSync: ~5ms latency, acceptable quality
Software (x264): ~15ms latency, best quality (not viable for real-time)

Recommendation: NVIDIA GPU with NVENC for best experience.

Installing Sunshine Server

Let’s install Sunshine on your gaming PC/server.

Windows Installation

Step 1: Download Sunshine

Visit: https://github.com/LizardByte/Sunshine/releases

Download: sunshine-windows-installer.exe (latest release)

Step 2: Run Installer

Run sunshine-windows-installer.exe as Administrator
Installation Location: Default C:\Program Files\Sunshine (recommended)
Firewall: Allow when prompted (required for streaming)
Service Installation: ✅ Check “Install as Windows Service” (recommended)
Start on Boot: ✅ Check “Start Sunshine on system boot”
Click Install

Step 3: Initial Configuration

Sunshine installs and starts automatically. Access web UI:

Open browser to: https://localhost:47990
Security Warning: Accept certificate (self-signed, normal)
Create Credentials:
- Username: admin (or your choice)
- Password: (strong password)
Save credentials - you’ll need these to access settings

Step 4: Configure Basic Settings

In Sunshine Web UI (https://localhost:47990):

Configuration → Audio/Video

Resolution: 1920x1080
FPS: 60
Bitrate: 30000 kbps (30 Mbps)
Encoder: NVENC (for NVIDIA), AMF (for AMD)
Video Codec: H.265 (better quality) or H.264 (better compatibility)

Configuration → Input

Virtual Input: Enabled
Controller Emulation: Enabled (allows controller passthrough)

Configuration → Network

Port: 47989 (default, change if needed)
HTTPS Port: 47984 (web UI access)
UPnP: Disabled (not needed for local streaming)

Save Configuration

Step 5: Add Games/Applications

Applications Tab → Add New Application

Example: Steam:

Application Name: Steam Big Picture
Command: "C:Program Files (x86)Steamsteam.exe" -bigpicture
Working Directory: C:Program Files (x86)Steam
Image: (upload Steam icon, optional)

Example: Specific Game (non-Steam):

Application Name: Cyberpunk 2077
Command: "C:GamesCyberpunk 2077indCyberpunk2077.exe"
Working Directory: C:GamesCyberpunk 2077ind

Example: Desktop Streaming:

Application Name: Desktop
Command: (leave empty - streams desktop)

Save Application

Linux Installation (Ubuntu/Debian)

Step 1: Add Sunshine Repository

# Add repository
wget -qO - https://apt.lizardbyte.dev/lizardbyte.gpg | sudo gpg --dearmor -o /usr/share/keyrings/lizardbyte-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/lizardbyte-archive-keyring.gpg] https://apt.lizardbyte.dev $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/lizardbyte.list

# Update package lists
sudo apt update

Step 2: Install Sunshine

# Install Sunshine
sudo apt install -y sunshine

# Enable and start service
sudo systemctl enable sunshine
sudo systemctl start sunshine

Step 3: Configure Sunshine

Access web UI: https://localhost:47990

Create admin credentials, then configure as in Windows section above.

Step 4: Configure X11 Capture (if using X11)

# Allow Sunshine to capture display
xhost +local:

# Make persistent (add to ~/.bashrc):
echo "xhost +local:" >> ~/.bashrc

Step 5: Add Applications

Example for Steam on Linux:

Application Name: Steam
Command: steam -bigpicture

Docker Installation (Advanced)

docker-compose.yml:

version: '3.8'

services:
  sunshine:
    image: lizardbyte/sunshine:latest
    container_name: sunshine
    restart: unless-stopped

    # Network mode host (required for streaming)
    network_mode: host

    # GPU access
    devices:
      - /dev/dri:/dev/dri  # Intel/AMD GPU
      # For NVIDIA, use runtime: nvidia instead

    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      - SUNSHINE_USER=admin
      - SUNSHINE_PASS=your-password-here

    volumes:
      - ./sunshine/config:/config
      - /tmp/.X11-unix:/tmp/.X11-unix  # X11 socket for display capture
      - ./sunshine/apps:/apps

    # For NVIDIA GPU:
    # runtime: nvidia
    # environment:
    #   - NVIDIA_VISIBLE_DEVICES=all
    #   - NVIDIA_DRIVER_CAPABILITIES=all

Start container:

docker compose up -d

Access web UI: https://YOUR-SERVER-IP:47990

Installing Moonlight Clients

Now let’s install Moonlight on your client devices.

Windows Client

Download: Visit: https://moonlight-stream.org/

Download: MoonlightSetup.exe

Install:

Run installer
Follow wizard (default settings fine)
Launch Moonlight

Add Host:

Moonlight automatically scans local network
Your Sunshine PC should appear (hostname or IP)
Click on it
Enter PIN displayed in Sunshine Web UI
Pairing complete!

Android Client

Install from Google Play: https://play.google.com/store/apps/details?id=com.limelight

Setup:

Open Moonlight app
Tap + to add PC
Enter Sunshine PC’s IP address (e.g., 192.168.1.100)
Enter PIN from Sunshine Web UI
Paired!

Controller Setup:

Connect Bluetooth controller (Xbox, PlayStation, etc.)
Moonlight auto-detects
Test in Moonlight settings

iOS/iPadOS Client

Install from App Store: https://apps.apple.com/app/moonlight-game-streaming/id1000551566

Setup:

Same as Android (add PC, enter PIN)

Controller Support:

Xbox controllers: Bluetooth pairing works
PlayStation controllers: Bluetooth pairing works
Backbone One: Plug-and-play on iPhone

Raspberry Pi Client (for TV streaming)

Install Moonlight on Raspberry Pi:

# Update system
sudo apt update && sudo apt upgrade -y

# Install Moonlight
curl -1sLf 'https://dl.cloudsmith.io/public/moonlight-stream/moonlight-qt/setup.deb.sh' | sudo bash
sudo apt install -y moonlight-qt

# For console-only streaming (no desktop):
sudo apt install -y moonlight-embedded

Launch:

# GUI version:
moonlight

# Or console version (auto-launch games):
moonlight stream -app "Steam Big Picture" YOUR-PC-IP

Auto-start on boot:

# Create systemd service
sudo nano /etc/systemd/system/moonlight.service

[Unit]
Description=Moonlight Game Streaming
After=network.target

[Service]
Type=simple
User=pi
ExecStart=/usr/bin/moonlight stream -app "Steam Big Picture" 192.168.1.100
Restart=on-failure

[Install]
WantedBy=multi-user.target

sudo systemctl enable moonlight.service
sudo systemctl start moonlight.service

macOS Client

Download: https://github.com/moonlight-stream/moonlight-qt/releases

Download: Moonlight-VERSION-macOS.dmg

Install:

Open DMG
Drag Moonlight to Applications
Launch and pair as above

Optimizing for Low Latency

Now let’s fine-tune for competitive gaming performance.

Network Optimization

1. Use Wired Ethernet on Host (Critical)

WiFi on host PC adds 5-20ms of jitter. Ethernet is non-negotiable for best performance.

# Test network latency
ping 192.168.1.100  # Your gaming PC
# Should be under 2ms consistently

2. WiFi 6 for Client (if not using ethernet)

WiFi 5 (AC) is acceptable but WiFi 6 (AX) provides:

Lower latency (1-5ms improvement)
Better performance in congested environments
Higher bandwidth for 4K streaming

3. Enable QoS (Quality of Service) on Router

Most routers (example: ASUS, Netgear):

Access router admin panel (usually 192.168.1.1)
Navigate to QoS or Traffic Control
Enable QoS
Prioritize: Gaming PC’s IP address
Ports to prioritize: UDP 47998-48010
Save settings

Example (ASUS router):

QoS → Gaming Mode → Enabled
Highest Priority: 192.168.1.100 (Gaming PC)

4. Disable Bandwidth-Heavy Background Services

On streaming PC:

Pause cloud backups (OneDrive, Dropbox)
Pause Windows Update
Close background downloads

5. Use 5GHz WiFi (never 2.4GHz for streaming)

2.4GHz is too congested and slow. Always use 5GHz.

Sunshine Server Optimization

Configuration → Audio/Video:

For competitive gaming (lowest latency):

Resolution: 1920x1080
FPS: 120 (if client supports)
Bitrate: 50000 kbps (50 Mbps)
Video Codec: H.264 (lower latency than H.265)
Encoder: NVENC H.264
Min QP: 20
Max QP: 35 (lower = better quality, higher bitrate)
Adaptive Bitrate: Enabled

For balanced quality/latency:

Resolution: 1920x1080
FPS: 60
Bitrate: 30000 kbps
Video Codec: H.265 HEVC
Encoder: NVENC HEVC

For 4K streaming (quality-focused):

Resolution: 3840x2160
FPS: 60
Bitrate: 100000 kbps (100 Mbps)
Video Codec: H.265 HEVC

Advanced Encoder Settings:

Configuration → Audio/Video → Advanced:

Slices per frame: 4 (reduces latency)
Number of Reference Frames: 0 (lowest latency)

Moonlight Client Optimization

Settings → Streaming:

Resolution: Match host or lower
FPS: 60 or 120
Bitrate: Automatic (or match server setting)
Video Decoder: Hardware (never software!)
Video Codec: H.264 for latency, H.265 for quality
Packet Size: 1024 (default)

Settings → Input:

Optimize Game Settings: Enabled (auto-configures games for streaming)
Mouse Acceleration: Disabled
Controller Rumble: Enabled

Settings → Host:

Enable HDR: Only if both host and client support
Multi-controller: Enabled (if using multiple controllers)

Windows Host Optimizations

1. Disable Game DVR (Xbox Game Bar)

# Run PowerShell as Administrator
Set-ItemProperty -Path "HKCU:SoftwareMicrosoftWindowsCurrentVersionGameDVR" -Name "AppCaptureEnabled" -Value 0

Or via Settings:

Settings → Gaming → Xbox Game Bar → Off
Settings → Gaming → Captures → Background recording → Off

2. Set High-Performance Power Plan

powercfg /setactive 8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c

Or via GUI:

Control Panel → Power Options → High Performance

3. Disable Unnecessary Background Apps

Task Manager → Startup → Disable:

OneDrive
Adobe updaters
Cloud sync services
Anything not essential

4. Enable Hardware-Accelerated GPU Scheduling

Settings → Display → Graphics Settings → Hardware-Accelerated GPU Scheduling → On

Requires:

Windows 10 version 2004 or newer
NVIDIA GTX 10 series or newer / AMD RX 5000 series or newer

Latency Testing & Measurement

Measure total latency:

Using Moonlight overlay:

Moonlight Settings → On-Screen Display → Stats Overlay → Enabled
Shows real-time latency, bitrate, packet loss

Manual measurement:

Set up phone camera recording both host monitor and client display
Display a millisecond timer on host
Record video
Analyze frame-by-frame difference between host and client

Target latencies:

Excellent: Under 10ms total
Good: 10-20ms (competitive gaming viable)
Acceptable: 20-30ms (casual gaming)
Poor: Over 30ms (noticeable delay)

Advanced Configuration

Multi-Monitor Streaming

Scenario: Stream only your gaming monitor (not all monitors).

Sunshine Configuration:

Identify monitor index:
- Windows: Right-click desktop → Display Settings
- Note which monitor is #1, #2, etc.
Configure per-application:

Application → Advanced → Output:

Display Output: 1  # Stream only monitor 1

Or stream all monitors:

Display Output: -1  # All monitors (panoramic)

HDR Streaming

Requirements:

Host GPU: HDR-capable (NVIDIA 10 series+, AMD RX 5000+)
Host Display: HDR monitor connected
Client: HDR-capable display (modern phones, tablets, TVs)
Network: 80+ Mbps bandwidth

Enable in Sunshine:

Configuration → Audio/Video:

HDR: Enabled
Video Codec: H.265 HEVC (H.264 doesn't support HDR)
Bitrate: 80000 kbps minimum for 1080p HDR

Enable in Moonlight:

Settings → Streaming → Enable HDR: On

Launch HDR game, Moonlight will stream in HDR!

Custom Resolutions & Refresh Rates

Stream at non-standard resolutions (e.g., ultrawide):

Sunshine → Configuration → Audio/Video:

Resolution: Custom
Width: 3440
Height: 1440
FPS: 60

Stream at high refresh rates (competitive gaming):

Resolution: 1920x1080
FPS: 144 (or 165, 240 if supported)

Note: Client device must support decoding at that refresh rate.

Wake-on-LAN Support

Wake your gaming PC remotely before streaming.

Enable WoL on Gaming PC:

Windows:

Device Manager → Network Adapters → Your Ethernet Adapter
Right-click → Properties
Power Management:
- ✅ Allow this device to wake the computer
- ✅ Only allow a magic packet to wake the computer
Advanced:
- Wake on Magic Packet: Enabled

BIOS Settings:

Enable “Wake on LAN” or “Resume by PCI-E Device” in BIOS

Configure in Moonlight:

Get PC’s MAC address:

ipconfig /all
# Note "Physical Address" for ethernet adapter

Moonlight → Host Settings → Wake-on-LAN:
- MAC Address: AA:BB:CC:DD:EE:FF
- Enable WoL

Now Moonlight can wake PC before streaming!

External (Internet) Streaming

Stream from outside your home network.

Security Warning: This exposes your PC to the internet. Use strong passwords and keep software updated.

Method 1: Port Forwarding (Direct)

On your router:

Forward UDP ports 47998-48010 to gaming PC’s local IP
Forward TCP port 47984 (HTTPS web UI)

In Sunshine:

Configuration → Network → External IP: your-public-ip

Connect from outside:

Moonlight → Add PC manually → Enter public IP

Method 2: VPN (Recommended - More Secure)

Set up Tailscale or WireGuard:

Connect client to home network via VPN
Stream over VPN as if on local network
No port forwarding needed
Encrypted tunnel

See our Tailscale guide for setup.

Steam Integration

Steam Link (Alternative Client)

If you prefer Steam Link client:

Install Steam Link:

Android: https://play.google.com/store/apps/details?id=com.valvesoftware.steamlink
iOS: https://apps.apple.com/app/steam-link/id1246969117
Raspberry Pi: sudo apt install steamlink

Setup:

Launch Steam Link app
It auto-discovers gaming PC running Steam
Enter PIN displayed in Steam
Done!

Pros:

Easy setup
Great Steam integration

Cons:

Higher latency than Moonlight
Only streams Steam games
Limited customization

Launching Steam Games via Sunshine

Auto-launch specific Steam games:

In Sunshine → Applications → Add:

Application Name: Cyberpunk 2077
Command: "C:Program Files (x86)Steamsteam.exe" -applaunch 1091500

Find Steam App ID:

Right-click game in Steam library
Properties → Updates
App ID shown at top

Or from URL: https://store.steampowered.com/app/1091500/ ← App ID is 1091500

Non-Steam Games in Sunshine

Add non-Steam games for easy launching:

Epic Games Store:

Application Name: Fortnite
Command: "com.epicgames.launcher://apps/Fortnite?action=launch&silent=true"

GOG Galaxy:

Application Name: The Witcher 3
Command: "C:Program Files (x86)GOG GalaxyGamesThe Witcher 3indwitcher3.exe"

Battle.net:

Application Name: Overwatch
Command: "battlenet://WTCG"  # Specific to each game

Troubleshooting Common Issues

“No Host Found” or Connection Failed

Diagnosis:

# From client, ping gaming PC
ping 192.168.1.100

# Check if Sunshine is running
# On Windows:
tasklist | findstr sunshine

# Check firewall
# Windows Firewall must allow Sunshine (UDP 47998-48010)

Solutions:

1. Firewall blocking:

# Windows PowerShell (Administrator)
New-NetFirewallRule -DisplayName "Sunshine" -Direction Inbound -Program "C:Program FilesSunshinesunshine.exe" -Action Allow

2. Wrong network:

Ensure client and host on same network/VLAN
Disable VPN on client (if testing locally)

3. Sunshine service not running:

# Windows:
net start SunshineService

# Linux:
sudo systemctl start sunshine

High Latency / Input Lag

Check Moonlight stats overlay:

Latency over 30ms = problem
Packet loss over 1% = network issue

Solutions:

1. Network congestion:

Close bandwidth-heavy applications
Use ethernet instead of WiFi
Enable QoS on router

2. Wrong encoder:

Switch to H.264 (lower latency than H.265)
Ensure hardware encoding (not software)

3. Client device too slow:

Lower resolution to 720p60
Ensure hardware decoding enabled in Moonlight

4. Game settings:

Disable V-Sync in game
Lower graphics settings to maintain high FPS

Stuttering / Frame Drops

Symptoms:

Smooth for seconds, then stutters
FPS drops visible in Moonlight stats

Solutions:

1. Bitrate too high:

Lower bitrate: 20 Mbps instead of 50 Mbps
Use adaptive bitrate

2. CPU bottleneck on host:

Check Task Manager while streaming
If CPU at 100%, lower game settings or upgrade

3. GPU encoder saturated:

Multiple streams or screen recordings running?
Close OBS, Discord screen share, etc.

Poor Video Quality / Artifacts

Symptoms:

Blocky image
Compression artifacts
Blurry text

Solutions:

1. Increase bitrate:

1080p60: 30-50 Mbps
1440p60: 50-80 Mbps
4K60: 80-150 Mbps

2. Adjust QP values (quality parameters):

Lower Min QP for better quality
Sunshine → Configuration → Video Encoder → Min QP: 18 (from 20)

3. Switch codec:

H.265 provides better quality than H.264 at same bitrate
Trade: slightly higher latency

Audio Issues

No audio:

Check Windows sound settings (is correct device selected?)
Sunshine → Configuration → Audio → Virtual Audio Device: Enabled
Moonlight → Settings → Audio → Enabled

Audio crackling:

Lower audio bitrate in Sunshine
Check network packet loss
Try different audio codec (Opus vs AAC)

Audio out of sync:

This is rare with Moonlight
Restart both Sunshine and Moonlight
Check for extreme network latency

Use Cases & Examples

Living Room Gaming PC

Setup:

Gaming PC in office (wired ethernet)
Android TV or Raspberry Pi on living room TV (WiFi 6 or ethernet)
Moonlight installed on TV device
Bluetooth controllers paired

Result: Play PC games on big screen TV, zero PC move required.

Multi-Room Access

Setup:

Central gaming server in homelab (Proxmox VM with GPU passthrough)
Sunshine installed on VM
Moonlight on:
- Bedroom tablet
- Living room TV
- Office laptop

Result: Play demanding games anywhere in house from thin clients.

Portable Gaming

Setup:

Gaming desktop at home
Gaming laptop while traveling
WireGuard VPN for secure connection

Result: Access home gaming PC from anywhere (hotel, coffee shop, friend’s house).

Couch Co-op Gaming

Setup:

Sunshine with multi-controller support
Multiple controllers paired to Moonlight client
Local co-op games (Overcooked, It Takes Two, etc.)

Result: Couch co-op on TV while gaming PC stays in office.

Next Steps

Expand your setup:

Add Raspberry Pi clients to every TV
Set up WireGuard VPN for external streaming
Create Sunshine application profiles for each family member
Integrate with Home Assistant for automation

Related homelabbing.io guides:

“Proxmox GPU Passthrough for Gaming VMs”
“Tailscale VPN: Secure Remote Access”
“Hardware Transcoding for Media Streaming”

Conclusion

You now have a professional game streaming infrastructure that rivals commercial solutions - completely free and under your control.

Key takeaways:

Sunshine + Moonlight provides lowest latency streaming
Hardware encoding (NVENC) is critical for performance
Network quality matters more than internet speed
Sub-10ms latency is achievable on good networks
Works with any game, not just Steam

Your homelab can now:

Stream AAA games to any device in your home
Extend gaming to non-gaming devices
Provide multi-room access to your gaming PC
Save money vs. buying multiple gaming PCs

Game from anywhere. Your homelab, your rules.

Quick Reference

Essential URLs

Sunshine Web UI: https://localhost:47990
Sunshine GitHub: https://github.com/LizardByte/Sunshine
Moonlight: https://moonlight-stream.org/

Default Ports

Sunshine Streaming: UDP 47998-48010
Sunshine Web UI (HTTPS): TCP 47984
Sunshine Web UI (HTTP): TCP 47989

Recommended Settings (1080p60)

Bitrate: 30-50 Mbps
Encoder: NVENC H.264
FPS: 60
Slices: 4
Reference Frames: 0

Performance Targets

Latency: Under 15ms (excellent)
Packet Loss: Under 0.5%
Frame Drops: Under 1%
Network Ping: Under 2ms (local)

Last updated: December 16, 2025 Author: homelabbing.io Difficulty: Intermediate Time to complete: 75 minutes

Happy streaming!