Cloud gaming services are convenient, but they cost a monthly fee, cap your resolution, and lock you out of the games you already own. Moonlight game streaming flips that model on its head: it turns the gaming PC you already paid for into your own private streaming server, then beams your full Steam, Epic, Battle.net and emulator library to a laptop, phone, tablet, TV, or handheld anywhere on your network – at up to 4K 120fps with HDR and near-zero subscription cost.

The magic happens with two open-source tools working together: Sunshine, the streaming host that runs on your gaming PC, and Moonlight, the client that runs on the device in your hands. This tutorial walks through the entire sunshine moonlight setup in 12 numbered steps, from installation to a tuned 4K HDR living-room stream – complete with code, firewall rules, internet streaming, and a troubleshooting table for the eight problems people hit most. Set aside about 30–45 minutes, and budget extra time only if you also want to stream over the internet.

What Is Moonlight Game Streaming? Sunshine and Moonlight Explained

Moonlight game streaming began life as an open-source reimplementation of NVIDIA’s GameStream protocol – the technology that originally powered the NVIDIA Shield. When NVIDIA announced in 2022 that it was discontinuing GameStream in GeForce Experience, with the feature fully removed in early 2023, the community needed a host that did not depend on NVIDIA’s closed software. That host is Sunshine.

Sunshine is a free, open-source game-streaming host maintained by the LizardByte project and released under the GPL-3.0 license. It runs on Windows, Linux, and macOS, captures your screen and audio, encodes the video stream in real time using your GPU’s hardware encoder, and serves it to any Moonlight client. Crucially, Sunshine is GPU-agnostic: it works with NVIDIA, AMD, and Intel graphics, whereas the old GameStream host only worked on NVIDIA cards. That single change is why sunshine game streaming has become the default self-hosted solution in 2026.

Moonlight is the other half. It is the open-source client that decodes the stream, displays it, and sends your controller, keyboard, and mouse input back to the host. Moonlight clients exist for nearly every platform you can imagine: Windows, macOS, Linux, Android, iOS, tvOS (Apple TV), Android TV, the Steam Deck, the Raspberry Pi, and even web browsers through experimental builds. The desktop and handheld client most people use is moonlight-qt.

The result is a fully self-hosted alternative to GeForce Now or Xbox Cloud Gaming. You own the hardware, you own the games, and the only ongoing cost is the electricity to run your host PC. Latency on a wired local network is typically single-digit to low-double-digit milliseconds – low enough for fast-paced shooters and fighting games, which is something no internet cloud service can promise. If you want to see how the hosted services compare, our best cloud gaming guide for 2026 breaks down the paid options side by side.

Prerequisites: Hardware, Network, and Software Versions

Before you start the sunshine moonlight setup, confirm you have the right hardware and software in place. Game streaming is far more sensitive to your network than to raw GPU power, so do not skip the networking requirements – they are where the majority of streaming problems originate.

Component	Minimum	Recommended (4K HDR)
Host GPU encoder	NVIDIA GTX 900-series, AMD RX 400, or Intel UHD (Quick Sync)	NVIDIA RTX 40/50, AMD RX 7000/9000, or Intel Arc (AV1 encode)
Host CPU	Quad-core (software fallback only)	6-core or more for game + encode overhead
Host RAM	8 GB	16 GB or more
Host OS	Windows 10, Ubuntu 22.04, macOS 12	Windows 11, Ubuntu 24.04, latest macOS
Network (local)	5 GHz Wi-Fi	Gigabit Ethernet on both ends
Client device	Any Moonlight-supported platform	Hardware HEVC/AV1 decode + HDR display
Recommended bitrate	20 Mbps (1080p60)	80–150 Mbps (4K60)

On the software side, download the current release of Sunshine from the official LizardByte GitHub repository, and the latest moonlight-qt build for your client. Both are free. Throughout this tutorial we reference the latest stable releases of each rather than pinning to a specific build number, because both projects ship frequent updates and the web UI layout is stable across recent versions.

• Sunshine (host): github.com/LizardByte/Sunshine – Windows installer, Linux packages, and Docker images.
• Moonlight (client): github.com/moonlight-stream/moonlight-qt and the app stores listed at moonlight-stream.org.
• Official docs: the Sunshine documentation covers per-platform installation notes.

One networking note that matters: both your host and client should ideally be on the same subnet for automatic discovery. If you have a guest network, an IoT VLAN, or AP isolation enabled on your router, Moonlight may fail to find the host automatically – you will need to add it by IP address, which we cover later in this guide.

How the Sunshine Host and Moonlight Client Work Together

Understanding the data flow makes troubleshooting far easier. When you launch a stream, four things happen in a continuous loop, dozens of times per second.

1. Capture: Sunshine grabs the host’s display output and game audio. On Windows it uses the Desktop Duplication API; on Linux it uses KMS, X11, or a Wayland capture path depending on your desktop environment.
2. Encode: The captured frames are compressed by your GPU’s dedicated media engine – NVENC on NVIDIA, AMF/VCE on AMD, or Quick Sync on Intel – into an H.264, HEVC (H.265), or AV1 bitstream. Hardware encoding is what keeps latency low and frees the GPU’s shader cores for the game itself.
3. Transmit: The encoded video and audio are streamed over your network using a low-latency RTSP-based protocol on a set of dedicated TCP and UDP ports.
4. Decode and return input: Moonlight decodes the bitstream on the client GPU, displays it, and ships your controller, keyboard, and mouse events back to Sunshine, which injects them as virtual input on the host.

Because the host does the heavy lifting, the client can be almost anything – a budget Android phone, an old laptop, a Raspberry Pi, or a gaming handheld. This is exactly why people pair Moonlight with a Steam Deck or ROG Ally: the handheld becomes a thin client for a far more powerful desktop. If you are weighing those handhelds, our Steam Deck vs ROG Ally comparison is worth a read before you commit.

The security model is simple but important: Sunshine exposes an HTTPS web UI protected by a username and password, and every Moonlight client must be paired once using a four-digit PIN before it can stream. Nothing streams until that handshake is complete, so even if a device finds your host on the network, it cannot connect without being explicitly authorized.

Step 1–2: Install Sunshine on the Host PC

Step 1 – Download and install Sunshine. On Windows, grab the latest .exe installer from the LizardByte releases page and run it. During installation, accept the prompt to install the virtual gamepad driver (ViGEm) – without it, controller input from your clients will not work. The installer also offers to add Sunshine as a service that starts with Windows, which you want for a set-and-forget host.

On Linux, install the package that matches your distribution. The project ships .deb, .rpm, an AppImage, and a Flatpak. For a Debian or Ubuntu host:

# Download the latest .deb from the LizardByte releases page, then:
sudo apt install -y ./sunshine.deb

# Allow Sunshine to use KMS capture without running as root (Linux):
sudo setcap cap_sys_admin+p $(readlink -f $(which sunshine))

# Start Sunshine
sunshine

On a Flatpak install the command differs slightly:

flatpak install -y flathub dev.lizardbyte.app.Sunshine
flatpak run dev.lizardbyte.app.Sunshine

Step 2 – Open the web UI and create your account. Sunshine is configured entirely through a local web interface. With Sunshine running, open a browser on the host and navigate to:

https://localhost:47990

Your browser will warn you that the connection is not private. This is expected – Sunshine uses a self-signed certificate for its local web UI. Click through the warning (Advanced → Proceed). On first launch you are prompted to create an administrator username and password. Choose a strong password; this account protects every setting on your host, including the apps it will run. The expected result is the Sunshine dashboard, which looks something like this when the host is healthy:

Sunshine Dashboard
------------------
Status: Running
Version: (latest)
Encoder: nvenc (hevc, av1 supported)
GPU: NVIDIA GeForce RTX 4070
Active streams: 0
Paired clients: 0

If the Encoder line reads software instead of nvenc, amf, or quicksync, stop here and fix it before continuing – software encoding adds large amounts of latency and CPU load. The fix is almost always installing or updating your GPU driver, which we cover in the troubleshooting section.

Step 3–4: Configure the Sunshine Web UI and Encoder

Step 3 – Pick the right encoder. In the Sunshine web UI, open the Configuration page and go to the Audio/Video tab. Sunshine auto-detects a hardware encoder, but it is worth confirming the choice. Use this priority order based on the GPU in your host:

Host GPU	Encoder setting	Best codec
NVIDIA RTX 20/30	nvenc	HEVC
NVIDIA RTX 40/50	nvenc	AV1 (or HEVC)
AMD RX 6000	amf	HEVC
AMD RX 7000/9000	amf	AV1
Intel Arc	quicksync	AV1
Older iGPU / no HW encoder	software	H.264 (last resort)

AV1 is the newest codec and delivers the best image quality per megabit, but it requires both a host GPU that can encode AV1 (RTX 40/50, RX 7000/9000, Intel Arc) and a client that can decode it. If either side cannot handle AV1, fall back to HEVC, which nearly every device from the last several years supports. Leave the codec on “Auto” and Moonlight will negotiate the best mutually supported option per session.

Step 4 – Set a sane default resolution and frame rate. Sunshine does not force a single output mode; instead it changes the host resolution to match what the Moonlight client requests. However, the host display must support the mode you request. For a first test, leave the defaults and confirm a 1080p60 stream works before you push to 4K. In the Configuration → General tab, it is also worth enabling these options:

• Start Sunshine on boot – so the host is always ready.
• Notification on pairing – so you see when a new client requests access.
• UPnP – only if you plan to stream over the internet without a VPN; leave it off for local-only or VPN-based streaming for better security.

Save your changes and restart Sunshine when prompted. A restart is required for encoder and network changes to take effect. At this point the host is configured; the next steps make it reachable.

Step 5–6: Open Firewall Ports and Set a Static IP

Step 5 – Allow Sunshine through the firewall. The Windows installer normally adds firewall rules automatically, but third-party security suites and Linux firewalls often do not. Sunshine uses a documented block of ports in the 47984–48010 range across both TCP and UDP. The video, audio, and control streams travel over UDP, so opening only TCP is a classic mistake that produces a black screen.

# Windows (run PowerShell as Administrator)
New-NetFirewallRule -DisplayName "Sunshine TCP" -Direction Inbound `
 -Protocol TCP -LocalPort 47984-48010 -Action Allow
New-NetFirewallRule -DisplayName "Sunshine UDP" -Direction Inbound `
 -Protocol UDP -LocalPort 47998-48010 -Action Allow

# Linux with UFW
sudo ufw allow 47984:48010/tcp
sudo ufw allow 47998:48010/udp
sudo ufw reload

Step 6 – Give the host a static IP or DHCP reservation. Moonlight remembers a paired host by its IP address. If your router hands the host a new IP after a reboot, Moonlight will report the host as offline. Prevent this by reserving the host’s IP in your router’s DHCP settings (recommended, because it survives OS reinstalls) or by setting a static IP on the host itself. Find the host’s current address first:

# Windows
ipconfig | findstr IPv4

# Linux / macOS
ip addr show | grep "inet " | grep -v 127.0.0.1

Note the address – for example 192.168.1.50 – and create a DHCP reservation for the host’s MAC address in your router. This single step eliminates the most common “my host keeps disappearing” complaint. While you are in the router, confirm that AP isolation and client isolation are disabled on the network both devices use, or automatic host discovery will silently fail.

Step 7–8: Install Moonlight and Pair Your Client

Step 7 – Install the Moonlight client. Grab Moonlight for your device. On Windows, macOS, and most Linux desktops, download moonlight-qt. On a Steam Deck, switch to Desktop Mode and install Moonlight from the Discover store (it ships as a Flatpak). On Android and iOS, install Moonlight from the respective app store. On Apple TV, install it from the tvOS App Store.

# Linux desktop or Steam Deck (Flatpak)
flatpak install -y flathub com.moonlight_stream.Moonlight
flatpak run com.moonlight_stream.Moonlight

Step 8 – Pair the client with the host. Open Moonlight on the client. If both devices are on the same subnet, your Sunshine host appears automatically as a tile, labeled with the host PC’s name. Click it. Moonlight generates a four-digit PIN and displays it on the client screen. Now switch to the Sunshine web UI on the host (or any device that can reach https://HOST-IP:47990), open the PIN tab, and enter that PIN.

Moonlight (client) shows:
 Enter this PIN on your host: 0492

Sunshine Web UI -> PIN tab:
 PIN: [ 0492 ]
 Device name: living-room-deck
 -> Send

Result:
 Pairing successful. Client "living-room-deck" added.

If the host does not appear automatically – common on segmented networks – click “Add Host Manually” in Moonlight and type the host’s static IP address. Pairing then proceeds with the same PIN exchange. Once paired, the client remembers the host permanently; you only pair each device once. You should now see your app list, which by default contains a “Desktop” entry and a “Steam Big Picture” entry. Launch “Desktop” as a connectivity test: if you see your host’s desktop on the client with responsive mouse movement, your core moonlight game streaming pipeline is working.

Step 9–10: Add Steam, Desktop, and Custom Game Apps

Step 9 – Understand the Applications list. Every tile you see in Moonlight is an “application” defined on the Sunshine host. An application is just a command Sunshine runs when you launch that tile, plus optional commands to run before and after the session. The default “Steam Big Picture” tile launches Steam in its controller-friendly mode, which is the single most useful entry for couch streaming.

Step 10 – Add a custom launcher. To add your own, open Configuration → Applications in the Sunshine web UI and click “Add New”. Give it a name, then set the command. For example, to launch a specific game directly through Steam by its App ID:

Application Name: Elden Ring
Command: steam://rungameid/1245620
Image: (optional cover art path)

# A "Prep" command can set the host resolution before launch
# and a separate "Undo" command can restore it on exit.
Prep -> Do: (set display to 3840x2160 @ 60)
Prep -> Undo: (restore display to native)

You can point an application at any launcher – Epic Games, the Battle.net client, an emulator front-end like EmulationStation, or a plain executable. This is what makes Sunshine so flexible compared with proprietary cloud services: anything that runs on your PC can be a streamable tile. If your library leans heavily on emulators, our EmuDeck tutorial pairs nicely with a Moonlight setup, letting you stream a full retro library to any room in the house.

One pitfall to flag here: if you add a game that needs a specific resolution, use Sunshine’s Prep commands to switch the host display mode rather than changing it manually, so the host returns to normal when the stream ends. Otherwise you may walk back to your PC and find it stuck at 4K on a 1080p monitor.

Step 11–12: Tune Resolution, Bitrate, and HDR for 4K60

Step 11 – Set the stream resolution and frame rate in Moonlight. Streaming quality is configured on the client, not the host. In Moonlight’s Settings, choose your resolution, frame rate, and bitrate. Start conservative and climb. These are sensible starting bitrates for a wired or strong 5/6 GHz connection:

Resolution	Frame rate	Starting bitrate	Codec
1080p	60 fps	20 Mbps	HEVC
1080p	120 fps	40 Mbps	HEVC/AV1
1440p	60 fps	40 Mbps	HEVC/AV1
4K	60 fps	80–120 Mbps	HEVC/AV1
4K	120 fps	120–150 Mbps	AV1

Higher bitrate improves clarity but increases the chance of network congestion and dropped frames. If you see compression artifacts in dark scenes, raise the bitrate. If you see stutter or the stream drops, lower it. The “V-Sync” and “Frame pacing” toggles in Moonlight smooth out micro-stutter at a tiny latency cost; most people leave frame pacing on.

Step 12 – Enable HDR. For a true 4K HDR stream, three conditions must all be met: the host GPU must encode HDR (modern NVIDIA, AMD, and Intel GPUs do), the game and host OS must have HDR enabled, and the client display must support HDR. In Moonlight, tick the “HDR” option in Settings. On the host, enable HDR in Windows display settings (or your distro’s equivalent). When everything lines up, you get a 10-bit HDR stream end to end. A common pitfall: leaving Windows HDR on at the desktop makes the host’s own monitor look washed out – use Sunshine’s per-app Prep commands to toggle HDR only during the stream if that bothers you.

Streaming Over the Internet (WAN) with Tailscale

Local streaming is the easy case. Streaming over the internet – from a hotel, a friend’s house, or a coffee shop – is where people get stuck, because exposing Sunshine’s ports directly to the internet via port forwarding is a security risk you should avoid. The clean, safe answer in 2026 is a mesh VPN, and Tailscale is the most popular choice because it is free for personal use and requires no port forwarding at all.

Tailscale builds an encrypted WireGuard-based network between your devices, giving each one a stable private IP that works anywhere. Install it on both the host and the client, sign in with the same account on both, and the two devices can reach each other as if they were on the same LAN.

# On the host (Linux example)
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

# Get the host's Tailscale IP (looks like 100.x.y.z)
tailscale ip -4

Install the Tailscale app on the client too (Windows, macOS, Linux, Android, and iOS are all supported), sign in, then in Moonlight use “Add Host Manually” and enter the host’s 100.x.y.z Tailscale IP instead of its LAN address. Pair as normal. You are now streaming over an encrypted tunnel with no open ports on your home router. Expect higher latency than local streaming – your real-world internet upload speed and distance to the host become the limiting factor, so drop the bitrate to 15–30 Mbps for remote play and prefer HEVC for its better low-bitrate quality. For comparison with the latency of commercial services, see how GeForce Now and Xbox Cloud Gaming stack up.

Controller Setup and Input Latency Tuning

Sunshine injects controller input on the host through a virtual gamepad driver – ViGEm on Windows, uinput on Linux. From the game’s perspective, a virtual Xbox 360 or DualShock controller is plugged into the host, and Moonlight maps your real client controller onto it. This is why the ViGEm install in Step 1 was non-negotiable: skip it and your buttons do nothing.

For the lowest possible input latency, work through this checklist in order – each item shaves a few milliseconds, and together they are the difference between “playable” and “competitive”:

• Wire both ends. Ethernet on host and client beats even the best Wi-Fi for consistency. If the client cannot be wired, use 5 GHz or 6 GHz Wi-Fi and stand close to the access point.
• Cap the in-game frame rate to your stream’s frame rate. Rendering 200 fps when you stream 60 just wastes GPU budget and adds heat.
• Match host and client refresh rate to avoid pacing conflicts. A 60 fps stream to a 60 Hz display is smoother than 60 fps to a 144 Hz display with V-Sync fighting it.
• Enable Game Mode on the client TV. On many TVs this cuts display processing latency dramatically.
• Prefer wired controllers on the client. Bluetooth controllers add their own wireless latency on top of the stream.

Moonlight also supports passing through keyboard and mouse with raw input, which matters for shooters. If you intend to play mouse-driven games, enable “Capture system keyboard shortcuts” so that key combos like Alt+Tab go to the host rather than the client, and the game receives the precise relative mouse movement it expects.

Common Pitfalls to Avoid in Your Sunshine Moonlight Setup

Most failed setups trace back to a small set of repeat offenders. Avoid these and you sidestep the majority of forum threads about sunshine game streaming not working.

• Pitfall 1 – Opening only TCP ports. The video stream is UDP. A black screen with working audio, or an instant disconnect, almost always means UDP is blocked. Re-check the firewall rules from Step 5.
• Pitfall 2 – Leaving the encoder on software. If Sunshine reports a software encoder, your CPU is doing the encoding and latency will be terrible. Update the GPU driver and confirm the encoder line reads nvenc, amf, or quicksync.
• Pitfall 3 – Dynamic host IP. Without a DHCP reservation, the host changes address and Moonlight loses it. Reserve the IP (Step 6).
• Pitfall 4 – AP/client isolation. Guest networks and IoT VLANs block device-to-device traffic, so the host never appears. Put both devices on the same trusted network, or add the host by IP.
• Pitfall 5 – Headless host with no display. Sunshine needs something to capture. A truly headless PC needs a virtual display driver or an HDMI dummy plug, or capture fails with a blank or 640×480 output.
• Pitfall 6 – Port forwarding to the open internet. Never expose Sunshine’s ports directly. Use Tailscale or another VPN instead – it is both easier and far safer.
• Pitfall 7 – Mismatched HDR settings. Enabling HDR on only one side produces washed-out or oversaturated color. All three of host, game, and client must agree.

Troubleshooting: 8 Fixes for Moonlight Streaming Problems

When a stream misbehaves, work through this table from top to bottom. The symptoms are ordered roughly by how often they occur in real setups.

Symptom	Likely cause	Fix
Host not found in Moonlight	Different subnet / client isolation / dynamic IP	Add host by static IP; disable AP isolation; set DHCP reservation
Black screen, audio works	UDP ports blocked or no decode support	Open UDP 47998–48010; switch codec from AV1 to HEVC
Connects then drops instantly	Encoder mismatch or firewall on UDP	Set encoder explicitly; verify UDP rules; restart Sunshine
Stutter / dropped frames	Bitrate too high for the network	Lower bitrate; switch Wi-Fi to 5/6 GHz; wire the connection
High input latency	Wi-Fi, uncapped FPS, or Bluetooth pad	Wire both ends; cap in-game FPS; use a wired controller
Controller not detected	ViGEm/uinput driver missing	Reinstall Sunshine and accept the gamepad driver
Washed-out colors	HDR enabled on one side only	Match HDR across host, game, and client – or disable everywhere
Encoder shows “software”	GPU driver too old or headless host	Update GPU driver; add a virtual display or dummy plug

If you are still stuck, Sunshine writes a detailed log you can read from the web UI’s Troubleshooting page. The log records which encoder initialized, which capture method is active, and any errors during a session – it is the fastest way to see whether a problem is on the capture, encode, or network side. On Linux, you can also run Sunshine from a terminal to watch the log live as you start a stream.

Advanced Tips: Multi-Monitor, Audio Routing, and Per-App Settings

Once the basics work, a few advanced tweaks make the experience feel professional rather than hacked together.

Streaming a single monitor on a multi-display host

If your host has two or three monitors, Sunshine by default captures the primary display. In the Audio/Video configuration you can set the “Output Name” to the specific display you want to stream, so the client sees only your main gaming monitor instead of a stretched capture spanning all of them. On Windows you can find the display’s identifier with the dxgi-info helper bundled with Sunshine; on Linux you specify the output connector name.

Per-application resolution and HDR with Prep commands

Prep commands run before and after each app launches. Use them to switch the host into the exact mode a game wants – for example, force 4K 120 Hz HDR for a single-player showcase title, then restore the desktop to 1440p when the session ends. This keeps your host usable as a normal PC while still giving each streamed game its ideal output. Pair this with a virtual display driver and you can even stream at a resolution your physical monitor does not support.

Audio routing without disturbing the host

By default Sunshine streams whatever the host plays, which means the host speakers also make noise. Sunshine can install a virtual audio sink so the stream gets audio while the host stays silent – handy when someone else is using the gaming PC’s room. Enable the virtual audio sink option during setup, then select it as the host’s default output. The remote stream gets full sound; the physical PC stays quiet.

Complete Working Project: A Tuned 4K Living-Room Stream

Let us tie everything together into one concrete, repeatable build: streaming your RTX-powered desktop in the office to a TV in the living room, at 4K60 HDR, with a wired controller. This is the configuration that “just works” for most people.

1. Host: Windows 11 desktop with an RTX 40-series GPU, latest driver, Sunshine installed as a service with ViGEm. Encoder set to nvenc, codec Auto (AV1 capable).
2. Network: Host wired to the router over Gigabit Ethernet. The living-room client (an Android TV box or a mini PC) is also wired. A DHCP reservation pins the host to 192.168.1.50.
3. Firewall: TCP 47984–48010 and UDP 47998–48010 allowed inbound on the host.
4. Client: Moonlight installed, paired once via PIN. Settings: 4K, 60 fps, 100 Mbps, HDR on, frame pacing on, V-Sync on.
5. App: A “Steam Big Picture” tile for couch browsing, plus a Prep command that sets the host to 3840×2160 @ 60 Hz HDR on launch and restores 1440p on exit.
6. Controller: A wired Xbox controller plugged into the client, mapped automatically through ViGEm on the host.

The result is a console-like experience: power on the TV box, open Moonlight, launch Steam Big Picture, and within a couple of seconds you are looking at your full PC library on the big screen, controller in hand, with the desktop’s full horsepower behind every frame. Total latency on this wired 4K setup typically lands in the low tens of milliseconds – indistinguishable from playing at the desk for everything short of competitive esports. And unlike a cloud subscription, the only recurring cost is the electricity the host already uses. If you eventually want a dedicated streaming box that lives in the office, a compact build like Valve’s upcoming hardware (see our Steam Machine breakdown) makes an excellent always-on Sunshine host.

Related Coverage

• Best Cloud Gaming 2026: 5 Services Compared
• GeForce Now vs Xbox Cloud Gaming 2026
• Steam Deck vs ROG Ally 2026: Tested
• EmuDeck Tutorial: Steam Deck Emulation in 12 Steps
• Steam Machine 2026: 6x Deck Power
• Mobile Gaming 2026 Hub

Frequently Asked Questions

Is Moonlight game streaming free?

Yes. Both Sunshine (the host) and Moonlight (the client) are free and open source. There is no subscription, no account requirement, and no per-stream cost. The only things you pay for are the hardware you already own and the electricity to run the host PC, which makes it dramatically cheaper than a cloud gaming subscription over time.

Do I need an NVIDIA GPU to use Sunshine?

No. Unlike the old NVIDIA GameStream, Sunshine works with NVIDIA (NVENC), AMD (AMF), and Intel (Quick Sync) hardware encoders. Any reasonably modern GPU with a hardware encoder will stream well. You only fall back to slow software encoding if your GPU has no media engine at all.

Can I stream over the internet, not just my home network?

Yes, and the recommended way is a mesh VPN such as Tailscale rather than port forwarding. Install Tailscale on both host and client, then add the host in Moonlight by its Tailscale IP. This avoids opening any ports on your router and encrypts the connection. Expect higher latency than local streaming, so lower the bitrate for remote play.

What is the difference between Moonlight and GeForce Now?

GeForce Now is a commercial cloud service: NVIDIA runs the hardware in a data center and you pay a subscription. Moonlight streams from your own PC at home, so you keep full control, pay no subscription, and can play any game you own – but you supply and power the host hardware yourself. For a head-to-head of the paid services, see our cloud gaming comparison.

Why is my Moonlight stream a black screen?

A black screen with working audio almost always means the UDP video ports are blocked by a firewall, or the client cannot decode the chosen codec. Open UDP ports 47998–48010 on the host, and try switching the codec from AV1 to HEVC in Moonlight’s settings. A headless host with no display attached can also produce a black or tiny capture – add a virtual display driver or HDMI dummy plug.

Can I use Moonlight on a Steam Deck or phone?

Absolutely. Moonlight has native clients for the Steam Deck (via the Discover store), Android, iOS, Apple TV, Raspberry Pi, and desktop operating systems. The Steam Deck and phones make excellent clients because the host does all the rendering – a low-power handheld can display a high-end PC game it could never run natively.

How much bandwidth does Moonlight game streaming use?

It depends on the bitrate you set. A 1080p60 stream is comfortable at around 20 Mbps, while a 4K60 stream typically uses 80–150 Mbps. On a local gigabit network this is trivial; over the internet it is the main constraint, which is why remote streaming usually drops to 15–30 Mbps and favors the HEVC codec for its better quality at lower bitrates.

Is Sunshine safe to run on my gaming PC?

Sunshine is open source and widely used by the community, and it requires PIN-based pairing plus a password-protected web UI before any device can stream. The main security advice is simple: do not port-forward Sunshine directly to the internet. Keep it on your local network or behind a VPN like Tailscale, and only pair devices you trust.