A gaming PC sitting idle in the living room is a wasted asset. Sunshine and Moonlight turn that PC into a personal game streaming server, letting you play your existing library on a Steam Deck in bed, a phone on the train, or a laptop at a relative’s house, all without paying a cloud gaming subscription. Search interest in this open-source pairing has climbed steadily since NVIDIA shut down its own GameStream service in 2023, and it remains one of the most searched self-hosted streaming setups among PC gamers in 2026: Shattered.io’s own Sunshine setup guide had logged roughly 40,000 views by August 2026, most recently revised on August 26, 2026, while a widely-shared Reddit “Ultimate Guide” to Moonlight and Sunshine, first posted to r/MoonlightStreaming in October 2025 and refreshed with 12 key tips in January 2026, distills the whole project down to a single goal: stable, low-latency game streaming from hardware you already own.
Unlike a subscription service, nothing about this setup depends on a company keeping a data center running or a pricing tier staying the same. The software is free, the source code is public, and the only hardware requirement is a PC you probably already own. That trade-off comes with real homework though: you’re the one responsible for network configuration, encoder settings, and security, jobs a cloud provider normally handles for you. This guide covers all three in enough detail that a first attempt should work, not just a simplified version that breaks the moment you leave your home Wi-Fi.
This guide walks through the full setup: installing the Sunshine host on Windows or Linux, connecting Moonlight clients, tuning encoder and bitrate settings, configuring controllers and audio, and opening remote access safely once your local network works. Tech Insider’s own 12-step walkthrough, last updated October 2026, still budgets around 75 minutes for a first-time setup, less if you only need local streaming and skip the remote access steps, though completion times vary by guide: Shattered.io’s Italian edition of the same 12-step process, updated August 14, 2026, reports a faster 40 minutes as of July 2026. Everything here uses free, actively maintained open-source software, no subscription required. As of October 2026, this 12-step sequence still holds up as the reference version of the process, since neither project has restructured its core setup flow.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Sunshine and Moonlight Actually Do
Sunshine as Host, Moonlight as Client
Sunshine is the host application. It runs on the PC with the graphics card and the installed games, captures the screen, encodes it in real time, and sends it over the network. Moonlight is the client. It runs on whatever device you want to play on and decodes that stream while sending your inputs back to the host. Between them, the two apps recreate the low-latency streaming experience that NVIDIA GameStream used to offer, minus the requirement to own a Shield console. If you want the deeper technical background on how the host-client relationship works, our explainer on what Sunshine and Moonlight actually are covers the architecture in more depth than this walkthrough does.
Sunshine is built by an open-source group called LizardByte and published on GitHub, where the project has passed 40,083 stars. Moonlight predates Sunshine by several years. It started as a GameStream-compatible client and pivoted to supporting Sunshine as its primary host once NVIDIA discontinued the original service. Both projects still ship regular updates, so this guide references install commands and package names rather than pinning a specific version number that will be outdated within a few months. As a snapshot, the newest Sunshine build on the LizardByte release list is reportedly v2026.1018.5342, dated October 18, 2026 and marked as a pre-release, and Moonlight’s latest stable desktop client is v6.2.0, released October 4, 2026, but the current stable release and full changelog are always available from the official Sunshine documentation if you want to check what’s new before installing; the official Moonlight-stream Wiki’s own setup page was last revised on August 26, 2026 specifically to reflect whichever Sunshine version is newest on GitHub at any given time, so it’s worth cross-checking there too.
Which Builds and Hardware to Trust Right Now
Sunshine’s release list moves quickly, so it pays to know which build you are installing. The available evidence does not identify a confirmed latest stable version, and v2026.1018.5342 should be used only if you are comfortable with pre-release software. If you would rather stay on a stable Sunshine build, install the version the official documentation points to and update from there. Moonlight’s desktop client is the steadier half of the pair: the desktop Moonlight step should reference v6.2.0, released October 4, 2026.
The official LizardByte pages also set a floor for the host GPU. For FreeBSD and Linux, the listed NVIDIA requirement is GeForce RTX 2000 series or higher. For AMD, the pages list Video Coding Engine 3.1 or higher in one entry and Video Coding Engine 3.4 or higher in another, so check which entry applies to the codec you plan to use before buying a card or upgrading an older one.
Moonlight’s origins explain why the pairing is so widely supported today. Moonlight was created by Case Western Reserve University students as a project at the MHacks hackathon in 2013 and further developed at MHacks and HackCWRU in 2014. One more thing worth knowing before you search for paid options: a release page displays “Enterprise-grade 24/7 support” under “Available Add-ons,” but no price or purchasable plan details are shown there, so there is nothing to buy to follow the steps in this guide.
Self-Hosted Streaming vs. Paying for Cloud Gaming
Before committing 75 minutes to this setup, it helps to see what the paid alternatives cost. If you already own a gaming PC, Sunshine and Moonlight cost nothing beyond electricity. If you don’t, a cloud gaming subscription might genuinely be the faster option, and our cloud gaming setup guide walks through those services directly.
| Option | Approximate Monthly Cost (2026) | What You Need |
|---|---|---|
| Sunshine + Moonlight (self-hosted) | $0 subscription, just power and internet | A gaming PC you already own |
| NVIDIA GeForce NOW Priority | Around $10 | Just an internet connection |
| NVIDIA GeForce NOW Ultimate | Around $19.99 | Internet connection, no local hardware |
| Xbox Game Pass Ultimate (Xbox Cloud Gaming) | $22.99 in the US | Xbox/Microsoft account |
| PlayStation Plus Premium (cloud streaming) | $17.99 | PlayStation account |
| Amazon Luna+ | $9.99 | Amazon account |
| Shadow (full remote Windows PC) | Roughly $30 to $33 | Internet connection only |
These figures come from published 2026 pricing comparisons and change often, so check current rates directly with each provider such as NVIDIA’s GeForce NOW page or Xbox’s Game Pass page before deciding. The math still favors self-hosting for anyone who already owns a capable GPU: a single month of Shadow costs more than the electricity a gaming PC uses in an entire year of casual streaming.
Sunshine and Moonlight vs. Parsec and Other Self-Hosted Tools
How Parsec Compares
Sunshine and Moonlight aren’t the only self-hosted streaming option, just the most widely recommended free one. Parsec is the closest comparison. It offers a similar host-and-client model with a smoother initial setup experience and a polished interface, but its free tier limits some features that Sunshine gives away entirely, and Parsec’s most reliable low-latency mode has historically leaned toward its paid Warp tier for teams and power users. Sunshine trades a bit of setup polish for being fully open-source, free without exception, and more configurable at the encoder level.
Where Steam Remote Play Fits In
Steam’s own Remote Play, built directly into the Steam client, is worth a mention too. It works well for streaming between two devices that both already run Steam, but it lacks Moonlight’s broader device support (no native Apple TV or Fire TV client, for instance) and doesn’t expose the same depth of encoder and bitrate control that Sunshine does. If your entire library lives in Steam and you only ever stream to another Windows or Linux PC, Steam Remote Play is a fine zero-install alternative. For streaming to a phone, a Steam Deck, a TV, or a launcher outside Steam, Sunshine and Moonlight remain the more flexible choice, which is the main reason this guide focuses on them.
Prerequisites and System Requirements
Sunshine and Moonlight both install in minutes, but a few requirements determine whether the stream is smooth or unwatchable. The host PC does the heavy lifting, so its hardware matters more than the client’s.
Host Hardware That Matters Most
The GPU generation on the host matters more than raw horsepower here. NVIDIA’s NVENC encoder saw real quality-per-bitrate improvements across the Turing and Ampere generations compared with the older Kepler-era hardware the minimum spec still technically allows, which is part of why RTX 30-series and newer is the recommended tier rather than just “any NVIDIA card.” AV1 encoding narrows the field further: it’s only available on RTX 40-series and newer from NVIDIA, RDNA 3 and newer from AMD, and current Intel Arc GPUs, so a host built before those generations should plan around HEVC as its practical ceiling instead of waiting on hardware it doesn’t have.
| Component | Minimum | Recommended |
|---|---|---|
| Host GPU | Any GPU with a hardware encoder (NVIDIA Kepler+, AMD GCN+, or Intel with Quick Sync) | NVIDIA RTX 30-series or newer for NVENC quality and AV1 support on 40-series+ |
| Host OS | Windows 10 (64-bit) or a modern 64-bit Linux distribution | Windows 11 or SteamOS/Bazzite for handheld hosts |
| Host CPU | Quad-core, mid-range from the last 6 years | 6+ cores so encoding doesn’t compete with the game for CPU time |
| Host network | Gigabit Wi-Fi | Wired Gigabit Ethernet |
| Client device | Any device with a Moonlight build available | 5GHz Wi-Fi or Ethernet for the client too |
| Internet upload (for remote play) | 15 Mbps upload from the host | 35+ Mbps upload for 4K remote streaming |
Supported Client Devices
Moonlight clients exist for Windows, macOS, Linux, Android, iOS and iPadOS, Apple TV, Android TV, Fire TV, Steam Deck, and several Android-based handhelds, and a remote-gaming roundup from February 2025 specifically singled out Android TV, Apple TV, and Steam Deck as the three client platforms worth setting up first alongside a Windows host running the sunshine-windows-installer.exe package. Always install the current release from your platform’s app store or from the official Moonlight site rather than an old cached download, since older client builds sometimes lose compatibility with newer Sunshine encoder options; treat v5.0 as the practical floor and update anything older before you start. The current desktop client, v6.2.0, carries forward the HDR streaming with software decoding that arrived in v6.1.0, on top of the existing hardware-decode path, which matters for the HDR notes later in this guide; on Windows, v6.2.0 requires Windows 10 version 1809 or later, so a client that hasn’t been updated in a while is worth refreshing before you start pairing.
Step 1: Install Sunshine on a Windows Host
Installing via Winget
Most people run the Sunshine host on a Windows gaming PC, since that’s where the game library and the GPU already live. The fastest install method is through winget, the package manager built into modern Windows.
winget install LizardByte.SunshineManual Installer and First Boot
If winget isn’t available or the install fails, grab the installer directly from the Sunshine GitHub Releases page instead. Run it with administrator rights. The installer typically prompts to add Windows Firewall exceptions and to install a virtual audio and virtual controller driver, both of which you should accept, since later steps depend on them. Reboot once the installer finishes, even if it doesn’t explicitly ask, because the driver installs sometimes need a restart to register properly.
After reboot, Sunshine should appear as a running service in the system tray. If the icon isn’t there, open the Start menu and launch Sunshine manually once, then revisit Step 3 to configure it to start automatically going forward.
Step 2: Install Sunshine on Linux, SteamOS, or a Steam Deck
Flatpak and Distro Packages
Linux hosts are a solid option too, especially for a dedicated streaming box that isn’t running Windows at all. The cleanest cross-distribution method is Flatpak, though Ubuntu users can also grab the distro-specific sunshine-ubuntu-24.04-amd64.deb package directly, the exact install path a July 2026 Ubuntu 24.04 setup guide walks through step by step. The release notes dated September 6, 2026 also reportedly introduced official stable and beta DEB/RPM repositories, along with improved AMD/Intel VA-API controls and Wayland/PipeWire capture compatibility, so Linux hosts can now receive updates through a repository instead of re-downloading a package by hand. The October 18 pre-release channel also reportedly expanded package coverage to Alpine Linux 3.24, openSUSE Leap 16.0, openSUSE Tumbleweed, and Ubuntu 26.10. Coverage extends beyond the big distros too: a Raspberry Pi Forums thread, most recently edited August 25, 2026, documents adding a dedicated apt repository and the moonlight-qt package to a Pi back in May 2025, and a DTPTips install guide, last updated December 2025, spans three OS families for Sunshine specifically, Windows, Arch, and Debian/Ubuntu, so the client side of this pairing runs on considerably more hardware than a typical gaming rig.
# Flatpak install (works across most modern distros)
flatpak install flathub dev.lizardbyte.sunshine
# Debian/Ubuntu-based systems can also use the .deb package
# from the Sunshine GitHub Releases page:
sudo apt install ./sunshine.debBazzite and Handheld Shortcuts
On Bazzite and other SteamOS-alternative distributions built for handhelds, there’s usually an even simpler path through a bundled helper script.
ujust setup-sunshineLinux hosts need a display attached, even a cheap dummy HDMI plug, because most desktop environments won’t render a GPU output with nothing connected. That single detail causes more failed Linux setups than any other step, so don’t skip it if the host runs headless.
Which Host OS Should You Actually Pick?
Windows remains the easier default for most people, mainly because the vast majority of PC games and anti-cheat systems are built and tested against it first. If your library leans heavily on newer competitive titles with kernel-level anti-cheat, Windows avoids a category of compatibility headaches that Linux hosts sometimes run into through Proton.
Linux earns a real advantage in two specific cases. First, a dedicated streaming box that never needs a monitor, keyboard, or desktop environment beyond what’s required to run Sunshine tends to boot faster and use less idle power than a full Windows install. Second, if the host is a handheld running SteamOS or Bazzite that already spends most of its life in Linux, adding Sunshine on top means one less operating system to maintain. For a primary gaming desktop with a mixed library, Windows is still the safer starting point, and you can always add a second Linux host later for a specific use case once the basics are working.
Step 3: Complete Initial Sunshine Configuration
Opening the Web UI for the First Time
With Sunshine running, open a browser on the host PC and go to its local web interface.
https://localhost:47990The browser will warn about an untrusted certificate. That’s expected, Sunshine generates a self-signed certificate for its local HTTPS connection, so click through the advanced warning to proceed. On first load, Sunshine asks you to create a username and password for the web UI. Pick a real password here, not something you’d reuse elsewhere, since this login also protects remote access later in the guide.
Checking That the Service Is Running
Once logged in, check the “PIN” tab exists and the status indicator shows the service running. A successful first load looks roughly like this in the terminal log if you started Sunshine manually instead of through the tray icon:
Info: Nvenc encoder detected
Info: Configuration loaded
Info: Web UI listening on port 47990
Info: Ready to accept Moonlight connectionsConfirming the Right GPU Is Selected
Under Configuration in the web UI, confirm the correct GPU is selected as the encoding adapter if the PC has more than one (common on laptops with both integrated and discrete graphics). Streaming from the integrated GPU by mistake is a frequent source of poor quality on laptop hosts.
Step 4: Install Moonlight on Every Client Device
Where to Get Moonlight on Each Platform
Now install Moonlight wherever you plan to play. Desktop clients (Windows, macOS, Linux) come from the official site or your distro’s package manager. Mobile clients (Android, iOS/iPadOS) come from the Play Store or App Store. Steam Deck users can grab Moonlight through Discover, the Deck’s built-in Flatpak store, without leaving Game Mode. Apple TV and Fire TV both have Moonlight builds in their respective app stores as well.
Start With a Phone, Not a TV Across the Room
Install Moonlight on more than one device if you can before moving on. Testing the pairing flow on a phone first, before trying it on a TV across the room, makes troubleshooting far easier because you’re not walking back and forth between rooms to read error messages.
Step 5: Pair Moonlight With Your Sunshine Host
The Pairing Flow
Open Moonlight on the client. It should auto-discover the host PC on the local network within a few seconds and list it by computer name. Tap or click that entry to start pairing. Moonlight generates a four-digit PIN and displays it on screen.
Switch back to the Sunshine web UI on the host at https://localhost:47990, open the PIN tab, and type in the code Moonlight just showed you within about 30 seconds. Submit it, and the client should confirm pairing within a couple of seconds. The PIN window is short by design, so if it expires before you finish typing, just restart the pairing process from the client side rather than troubleshooting further.
When Pairing Breaks
Pairing is tied to the specific Sunshine installation, not just the IP address. If you reinstall Sunshine or wipe the host’s configuration, every client needs to re-pair from scratch.
Step 6: Add Games and Desktop Streaming Targets
By default, Sunshine offers a generic “Desktop” stream target, which mirrors the whole screen. That works, but adding specific games and launchers gives Moonlight a proper grid of cover art and lets Sunshine auto-detach cleanly when you exit a game. Configuration lives in Sunshine’s apps.json file, editable either through the web UI’s Applications tab or by hand.
Editing apps.json Directly
{
"env": {},
"apps": [
{
"name": "Desktop",
"image-path": "desktop.png"
},
{
"name": "Steam Big Picture",
"cmd": "steam://open/bigpicture",
"auto-detach": "true"
}
]
}Adding “Steam Big Picture” as its own entry is worth doing even if you don’t add individual games, since Steam’s own library and controller layouts handle per-game launching for you from there. If you use a separate launcher like Playnite to unify Steam, Epic Games Store, and GOG in one library, point a Sunshine app entry at that instead and it becomes your single streaming hub for every storefront.
Step 7: Tune Video, Encoder, and Bitrate Settings
This is the step that separates a smooth stream from a blurry, stuttering one. Sunshine’s Configuration tab in the web UI exposes encoder, resolution, frame rate, and bitrate, and each interacts with the others.
Choosing Between H.264, HEVC, and AV1
| Codec | Hardware Path | Best For | Client Requirement |
|---|---|---|---|
| H.264 | NVENC, AMD AMF, Intel Quick Sync, or software fallback | Maximum compatibility with older clients and TVs | Supported on virtually every Moonlight build |
| HEVC (H.265) | NVENC, AMF, Quick Sync | Better quality at the same bitrate, good for 4K | Client device needs HEVC decode support |
| AV1 | NVIDIA RTX 40-series+, AMD RDNA 3+, Intel Arc | The most efficient option on newest hardware | Both host and client GPUs must support AV1 |
HEVC is commonly cited as roughly 30 to 40 percent more bandwidth-efficient than H.264 at equivalent visual quality, which matters most once you’re streaming outside your own LAN. Start with HEVC if both host and client support it, and fall back to H.264 only if a specific device refuses to decode HEVC cleanly.
Setting a Starting Bitrate for Each Device
# sunshine.conf (partial example)
encoder = nvenc
adapter_name = 0
output_name = 0
fps = [60, 90, 120]
resolutions = [1280x800, 1920x1080, 2560x1440, 3840x2160]
min_log_level = infoFor bitrate, a rough starting point is 20 Mbps for 1080p60, 35 to 50 Mbps for 1440p60, and 50 Mbps or higher for 4K60. These are starting points, not fixed rules. Raise the number if the picture looks soft on a fast connection, or lower it the moment you see stutter, since an overshot bitrate on a marginal network causes worse problems than a conservative one. For anyone chasing high frame rates specifically, a 2025 Windows 11 setup guide (its configuration gist last refreshed in September 2025) walks through pushing Sunshine’s NVENC encoder to a full 120 fps, which is achievable on a wired LAN but demands real headroom above the 1080p60 starting bitrate here. Moonlight’s own bitrate slider goes up to 500 Mbps, a ceiling introduced in the v6.1.0 client and still present in the current v6.2.0 release, but that ceiling exists for high-end wired LAN streaming, not something a typical home or remote connection can sustain.
Sunshine’s Configuration tab sets a single global bitrate by default, but treating that as the final answer is a common mistake. A Steam Deck on home Wi-Fi, a phone tethered to cellular data, and a wired Windows laptop have different useful ceilings, and a bitrate tuned for the laptop will overshoot what the phone’s connection can sustain. The numbers above apply to a typical wired 1080p or 1440p session. Step 12 further down breaks the same settings out by device and connection type, and that per-device table, not a single global number, is what actually holds up once more than one client is in regular use.
Step 8: Configure Audio and Controller Passthrough
Getting Audio Right
Audio should work immediately in most cases, since Sunshine captures whatever the host’s default playback device is producing. If sound doesn’t come through on the client, check that Sunshine’s virtual audio device is actually set as the Windows default output, not just enabled. Windows sometimes reverts the default device after a driver update or a Bluetooth speaker reconnects.
Getting Controllers Right
Controllers need a virtual gamepad driver on the host so games see Moonlight’s input as a real, locally-connected controller rather than network traffic. On Windows, Sunshine’s installer normally sets up a driver such as ViGEmBus automatically. If a controller pairs with the client but games don’t register any input, reinstalling that driver and restarting Sunshine resolves it in most cases. Bluetooth controllers connected directly to the client device (rather than the host) generally give the lowest added latency, since the client only has to translate button presses instead of relaying them from a separately connected Bluetooth controller on the host end.
Step 9: Test Everything on Your Local Network First
Test Every Device on the Local Network Before Going Remote
Don’t skip straight to remote access. Confirm the whole chain works on your home Wi-Fi or Ethernet before adding the internet, port forwarding, or a VPN into the mix, since that keeps troubleshooting simple: if it doesn’t work locally, the problem is host configuration, not networking.
This applies to every client device individually, not just the first one you set up. A phone that streams cleanly on local Wi-Fi doesn’t guarantee a tablet or a laptop will behave the same way, since each device runs its own Moonlight decoder, its own display scaling, and sometimes its own Wi-Fi radio with different range and interference characteristics. Pair and test each device on the local network on its own, confirm the stats overlay looks healthy for that specific device, and only then move on to enabling remote access for it. Skipping this per-device check is one of the more common reasons a setup that worked perfectly for one device suddenly looks broken when a second or third device joins, when the actual cause is a device-specific issue that local testing would have caught immediately.
Reading the Stats Overlay
Launch a game through Sunshine from the client and press the Moonlight stats overlay shortcut, Ctrl+Alt+Shift+S, to check real numbers instead of guessing from how the stream looks. A healthy local stream shows something close to this:
Decoder: Hardware (NVDEC)
Resolution: 1920x1080
Frame rate: 60 fps
Network latency: 4-9 ms
Decode time: 2-4 ms
Frames dropped: 0%Network latency under 10 milliseconds is typical for a wired LAN. Anything consistently above 30 to 40 milliseconds on a local network points to a Wi-Fi problem on one end, not a Sunshine or Moonlight setting, so check the physical connection before touching the encoder configuration again.
Understanding the Latency Budget Behind a Smooth Stream
Where Each Millisecond Goes
The number Moonlight’s overlay reports as “network latency” is only one slice of the delay you actually feel between pressing a button and seeing it happen on screen. The full chain runs through input capture on the client, network transit, decode on the host’s encoder, the game rendering a new frame, encoding that frame back, network transit again, and decode on the client. Each stage adds a few milliseconds, and they all stack.
This is why two setups can report similar network latency numbers but feel completely different to play on. A host with an older GPU and no hardware encoder available spends extra time on software encoding, adding delay that never shows up in the “network latency” figure at all, only in how sluggish the game feels. That’s the practical reason Step 7’s encoder selection matters as much as raw bandwidth: a fast network paired with slow software encoding still feels worse than a modest network paired with proper hardware encoding.
What the Numbers Feel Like in Practice
As a rough feel guide, total round-trip delay under about 20 milliseconds is close to indistinguishable from playing locally for most people. Between 20 and 50 milliseconds, fast-paced competitive games start to feel slightly off even though slower, story-driven games remain perfectly playable. Above 50 to 60 milliseconds, most players notice the delay in any genre, which is the point where lowering resolution or bitrate in favor of responsiveness usually beats chasing a sharper picture.
Step 10: Set Up Secure Remote Play Over the Internet
Once local streaming works cleanly, you have two realistic ways to reach it from outside your home network: port forwarding, or a VPN. Port forwarding is simpler but exposes ports directly to the internet. A VPN takes a bit more setup but keeps everything private.
Option A: Port Forwarding
Log into your router and forward Sunshine’s streaming ports to the host PC’s local IP address, or, if the router supports it, let Sunshine request those ports automatically over UPnP instead of entering them by hand. An ITechGuides remote-streaming article, published August 2026 and updated September 8, 2026, lays out three distinct WAN access methods for a Sunshine host paired with a Moonlight client: UPnP, manual port forwarding, and an overlay-network VPN, and manual port entry remains the more reliable of the first two on routers where UPnP is flaky or disabled outright. Give that PC a static local IP first (either a DHCP reservation in the router or a manual static assignment) so the forwarding rule doesn’t break the next time it reconnects. Sunshine’s documentation lists its current required TCP and UDP port ranges, and it’s worth checking that list directly since default ports can shift between releases. Do not forward the web UI port (47990) to the internet. It only needs to be reachable on the local network.
Option B: A VPN Instead of Port Forwarding
If your ISP uses CGNAT (common on many mobile and some cable connections), port forwarding won’t work at all, since there’s no public IP pointed directly at your router. A VPN sidesteps that entirely by creating a private tunnel back to your home network instead of opening ports to the public internet. WireGuard is the fastest, leanest option for this, and our WireGuard VPN setup guide covers the full configuration if you want to go that route. Tailscale, built on top of WireGuard, trades a little control for a much simpler setup process if you’d rather not manage keys and configs by hand.
# Example: connecting to a Moonlight host over a WireGuard
# tunnel address instead of a forwarded public port
moonlight pair 10.10.0.4
moonlight stream 10.10.0.4 "Steam Big Picture" -1080 -60fps -bitrate 20000With a VPN running on the client, you connect to the host’s private tunnel address exactly as if you were on the same LAN, and no ports need to be opened to the public internet at all. For most home setups, this is the safer default, and it’s the approach worth trying first if your router even hints at supporting CGNAT.
Step 11: Harden Sunshine’s Security Settings
A Baseline Hardening Checklist
Once any part of this setup touches the public internet, treat the host PC like a small server, not a personal desktop. A few concrete steps matter here. Use a strong, unique password for the Sunshine web UI, not something reused from another account. Keep Sunshine updated, since streaming hosts that sit untouched for months are exactly the kind of software that misses security patches. Never forward the web UI port externally, only the streaming ports need to reach the internet, and only if you’re using port forwarding rather than a VPN in the first place.
Isolating the Host Account
If the host PC also stores anything sensitive, consider a separate Windows user account dedicated to streaming, so a compromised game or mod can’t casually reach unrelated files. This sounds like overkill for a home setup, but it costs nothing to configure and removes an entire category of risk for a PC that’s now reachable from outside your home network.
Step 12: Fine-Tune Settings by Device and Network
Why Bitrate Should Be Set Per Device, Not Globally
A single global bitrate and resolution setting rarely suits every device you’ll stream to. A Steam Deck on home Wi-Fi and a phone on hotel Wi-Fi have completely different tolerances for bandwidth and jitter, so it’s worth keeping a mental (or written) profile for each.
The practical reason comes down to how differently each device reaches the host. A Steam Deck on home Wi-Fi and a laptop on wired Ethernet are both local, but their radios, drivers, and decode hardware behave differently even on the same network, and a phone on hotel Wi-Fi or cellular is dealing with congestion and jitter a home connection never sees. Setting one bitrate for all of them means picking a number low enough not to break the weakest connection, which wastes quality on every device that could handle more, or a number high enough for the strongest connection, which stutters on everything else. Configuring bitrate per device, the way the table below breaks it out, avoids that compromise: each profile matches what that specific device and connection can actually sustain, instead of forcing every client through the same ceiling.
Starting Profiles by Device
| Client Device | Connection | Resolution | Bitrate | FPS |
|---|---|---|---|---|
| Steam Deck | Home Wi-Fi/LAN | 800p (native panel) | 15-20 Mbps | 60 |
| Android phone | Home Wi-Fi, 5GHz | 1080p | 15 Mbps | 60 |
| Apple TV 4K | Wired Ethernet adapter | 4K | 40-50 Mbps | 60 |
| iPad, away from home | Cellular or remote Wi-Fi (via VPN) | 1080p | 10-15 Mbps | 60 |
| Windows laptop | Wired Ethernet | 1440p or 4K | 30-50 Mbps | 60-120 |
| Hotel or public Wi-Fi | Shared, unpredictable WAN | 720p-1080p | 8-10 Mbps | 30-60 |
Steam Deck and Handheld Considerations
Matching a Steam Deck’s stream resolution to its native 800p panel instead of pushing 1080p saves bandwidth and avoids extra scaling work on both ends, and a PC-to-TV walkthrough last refreshed in March 2026 notes that pairing a single Steam Deck to a single television is still the setup most readers actually land on, rather than juggling the full multi-device profile table above. A FutureTweets Steam Deck streaming article, updated September 8, 2026, recommends a 20-30 Mbps bitrate range specifically when a Deck is pushed to 1080p60 instead of its native panel resolution, which lines up with the more conservative 15-20 Mbps profile in the table above for Deck-native 800p. For a deeper look at squeezing more runtime out of Deck-class hardware while streaming, see our Steam Deck and ROG Ally battery optimization guide, since remote play is one of the heavier battery drains on these devices.
Common Pitfalls When Setting Up Sunshine and Moonlight
Most failed setups trace back to one of a handful of repeat mistakes. Checking against this list before opening a support forum thread saves a lot of time.
- Assuming the firewall exception installed correctly. Installers usually add the rule, but antivirus software or a manual firewall reset can silently remove it later.
- Streaming over Wi-Fi on the host PC. The host should be wired whenever possible. Client-side Wi-Fi matters far less than host-side Wi-Fi.
- Setting bitrate above what the network can sustain. A higher number doesn’t guarantee better quality if the connection can’t deliver it consistently, and the result is worse than a lower, stable bitrate.
- Running an outdated GPU driver. Sunshine silently falls back to slow software encoding if it can’t detect a working hardware encoder, and the stream becomes unwatchable without an obvious error message explaining why.
- Forwarding the web UI port to the internet. Only the streaming ports need external access. The web UI should stay local-only or reachable exclusively through a VPN.
- Forgetting that pairing doesn’t survive a host reinstall. Every client needs to re-pair after wiping or reinstalling Sunshine, which catches people off guard when only one of several devices suddenly stops connecting.
Troubleshooting Sunshine and Moonlight Problems
When something doesn’t work, the fix is almost always one of these. Work through the row that matches your symptom before assuming the whole setup is broken.
| Symptom | Likely Cause | Fix |
|---|---|---|
| Host doesn’t appear in Moonlight’s list | Discovery traffic blocked by firewall, or client and host are on different subnets | Add the host manually by IP address, check router client isolation settings |
| PIN is rejected during pairing | PIN expired before you finished typing it | Restart pairing from the client and enter the PIN immediately |
| Black screen after connecting | Headless host has no display attached for the GPU to render to | Attach a dummy HDMI plug or enable a virtual display option |
| No audio on the client | Wrong default playback device selected on the host | Set Sunshine’s virtual audio device as the Windows default output |
| Controller connects but doesn’t work in-game | Virtual controller driver missing or not registered | Reinstall the virtual gamepad driver and restart Sunshine |
| High latency or stutter on local network | Host is on Wi-Fi, or the encoder fell back to software mode | Move the host to wired Ethernet, confirm hardware encoding is active |
| Works at home, fails when away | Router isn’t forwarding ports, or ISP uses CGNAT | Forward the correct ports, or switch to a WireGuard/Tailscale VPN |
| Resolution stuck lower than expected | Bitrate too low for the target resolution, or client display scaling | Raise the configured bitrate and check the client’s display settings |
| “Address already in use” on startup | Another process, or a previous Sunshine instance, already holds the port | Close the conflicting app, or reboot the host |
| Smooth on LAN, choppy over the internet | Host’s upload bandwidth can’t sustain the configured bitrate | Lower the bitrate and resolution for a dedicated WAN profile |
Advanced Tips for Power Users
Once the basic setup runs reliably, a few extra configuration steps make the whole system feel less like a workaround and more like a real appliance.
Autostart on Boot
On Windows, Sunshine’s installer typically registers it as a service that starts automatically, so a restart doesn’t require walking over to the PC. On Linux, a systemd user service accomplishes the same thing.
# ~/.config/systemd/user/sunshine.service
[Unit]
Description=Sunshine self-hosted game stream host
[Service]
ExecStart=/usr/bin/sunshine
Restart=on-failure
[Install]
WantedBy=graphical-session.targetsystemctl --user enable --now sunshine.serviceMultiple Simultaneous Clients
Sunshine can serve more than one paired client, though only one can actively stream at a time on a single GPU in most configurations. This is still useful for a household where different people stream from the same host PC at different times without re-pairing each visit.
HDR Passthrough
Moonlight and Sunshine support HDR streaming end to end. HDR streaming with software decoding arrived in the v6.1.0 Moonlight client and carries forward in the current v6.2.0 release, so HDR no longer strictly requires a client device with HDR-capable hardware decode. It still requires an HDR-capable display on both sides. If colors look washed out or oddly saturated on an HDR TV, try disabling HDR passthrough first to confirm whether the base stream looks correct before troubleshooting further.
Multi-Host Setups
Nothing stops you from running Sunshine on more than one PC (a desktop and a laptop, for instance) and switching between them from the same Moonlight client. Each host pairs separately and shows up as its own entry in Moonlight’s list, which is useful if your household has more than one gaming PC and you want streaming access to whichever one happens to be free.
Complete Working Project: A Full Home Streaming Rig
The Reference Configuration
Putting every step together, here’s what a finished setup looks like end to end: a Windows gaming PC running Sunshine as an autostarting service, wired into the router over Gigabit Ethernet, with HEVC encoding enabled on an NVENC-capable GPU. Three Moonlight clients are paired: a Steam Deck for the living room, an Android phone for casual play elsewhere in the house, and a laptop that connects remotely through a WireGuard tunnel when traveling.
The combined configuration looks roughly like this once every step in the guide has been applied.
// apps.json - streaming targets
{
"env": {},
"apps": [
{ "name": "Desktop", "image-path": "desktop.png" },
{ "name": "Steam Big Picture", "cmd": "steam://open/bigpicture", "auto-detach": "true" },
{ "name": "Playnite Fullscreen", "cmd": "playnite://playnite/showfullscreen", "auto-detach": "true" }
]
}
# sunshine.conf - host encoder and stream settings
encoder = nvenc
adapter_name = 0
fps = [60, 90, 120]
resolutions = [1280x800, 1920x1080, 2560x1440, 3840x2160]Final Checklist
Use this checklist to confirm nothing was skipped before calling the project finished:
- Sunshine installed and set to start automatically with the host PC
- Host connected over wired Ethernet, not Wi-Fi
- Web UI password set to something unique, not reused from another account
- Every client device paired and tested locally before adding remote access
- HEVC or AV1 enabled where both host and client support it
- Bitrate profiles set per device rather than one global value
- Remote access configured through a VPN, or through port forwarding with only streaming ports exposed
- Web UI port confirmed not forwarded to the internet
That’s a complete, working, self-hosted game streaming setup, built entirely from free software and hardware you likely already own.
Frequently Asked Questions
Is Sunshine and Moonlight actually free?
Yes. Both are open-source projects with no license fee and no subscription. The only ongoing cost is the electricity the host PC uses while streaming, which is minor compared to any cloud gaming subscription in the comparison table above.
Do I need an NVIDIA graphics card?
No. Sunshine supports NVIDIA’s NVENC, AMD’s AMF, and Intel’s Quick Sync hardware encoders, plus a software fallback if none of those are available. NVIDIA GPUs tend to have the most mature encoder support and the widest codec options, including AV1 on 40-series cards and newer, but AMD and Intel hosts work fine for H.264 and HEVC streaming.
What’s the actual difference between Sunshine and Moonlight?
Sunshine is the host software that runs on the gaming PC and does the encoding. Moonlight is the client software that runs on the device you’re playing on and does the decoding. You need both, installed on two different machines, for streaming to work.
Can I stream over the internet, not just at home?
Yes, through either port forwarding or a VPN, both covered in Step 10 above. A VPN such as WireGuard or Tailscale is the safer default, and it’s the only option that works if your internet provider uses CGNAT, which blocks traditional port forwarding entirely.
Is it safe to expose Sunshine to the internet?
It’s reasonably safe if you follow the hardening steps in this guide: a strong unique password, the web UI never forwarded externally, and Sunshine kept up to date. A VPN-based setup is safer still, since nothing is directly exposed to the public internet at all.
Why did people stop using NVIDIA GameStream?
NVIDIA discontinued GameStream in 2023, ending official support for streaming from a GeForce Experience-managed PC to a Shield device. Moonlight, which originally targeted GameStream hosts, shifted its primary support to Sunshine, and that combination has since become the standard free option for self-hosted PC game streaming.
Does this work on a Steam Deck or ROG Ally?
Yes, on both, as a client. Install Moonlight from Discover on Steam Deck or from a Windows or alternate-OS install on ROG Ally, pair it with your host, and stream to it like any other device. Neither handheld needs to run Sunshine itself unless you specifically want to stream games installed on the handheld out to some other device, which is a less common use case.
How is this different from GeForce NOW or Xbox Cloud Gaming?
Cloud services stream games from data center hardware you don’t own, using their GPU time, and charge a recurring fee for it. Sunshine and Moonlight stream from your own PC instead, using your own game library and your own hardware, with no subscription and no server-side game ownership restrictions. The tradeoff is that your host PC has to be powered on, and stream quality depends on your home network rather than a data center’s connection.
Should I test every client device locally before enabling remote access?
Yes. Pair and test each device on your home network first, whether it’s a phone, a tablet, a TV, or a laptop, and only turn on port forwarding or VPN access for it afterward. Every device runs its own Moonlight decoder and its own network stack, so one device working locally doesn’t guarantee the next one will, and testing locally first keeps troubleshooting narrowed down to one variable instead of several at once.
Should every device use the same bitrate?
No. Bitrate holds up better when it’s set per device rather than as one global value. A Steam Deck on home Wi-Fi, a wired Windows laptop, and a phone on hotel Wi-Fi can each sustain a different bitrate, and pushing the same number to all three either wastes quality on the stronger connections or stutters on the weaker one. The device profile table in Step 12 above gives starting points for the most common client types.
