Self-hosted game streaming has quietly become the cheapest way to play a full PC library on a Steam Deck, a phone, or a living-room TV without paying a monthly cloud gaming fee. Two open-source projects sit at the center of that setup: Sunshine, the LizardByte-maintained host that popularized the format, and Apollo, a fork built by developer ClassicOldSong that rewrites how the host handles displays and HDR. Both pair with the free Moonlight client, both are free to run, and both turn any Windows, Linux, or Mac machine into a personal GeForce NOW. The difference shows up the moment you plug in a second monitor, enable HDR, or try to match your host’s resolution to whatever screen you’re streaming to.
As of September 2026, Sunshine’s GitHub repository carries 41,027 stars and 2,097 forks, with a commit pushed the same day this article was researched. Apollo’s repository sits at 10,849 stars and 427 forks, with its most recent code push landing in late May 2026. Those numbers alone tell part of the story, but they don’t explain why a growing slice of the Moonlight community switched hosts in the first place, or why some longtime Sunshine users have no reason to follow. This comparison breaks down the specs, the encoding pipeline, the HDR handling that started the fork, real installation steps for both, and a migration path if you decide to switch.
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 Apollo and Sunshine Actually Are
Both projects are “host” software. You install one on the PC that owns the games, and it streams video, audio, and input over your local network or the internet to a Moonlight client running on nearly anything: Android, iOS, Steam Deck, Apple TV, a Bazzite handheld, or another PC. Neither project touches your game library or your Steam account directly. They capture the desktop or a specific application, encode it with your GPU’s hardware encoder, and push the stream to whatever device requested it.
Sunshine describes itself on its own project page as a “self-hosted game stream host for Moonlight,” offering low-latency streaming with hardware encoding support across AMD, Intel, and Nvidia GPUs, plus a software encoding fallback for machines without a compatible GPU. It’s the reference implementation that most Moonlight setup guides point to, and it ships official builds for Windows, Linux (via Docker and Flatpak), and macOS.
Apollo describes itself as “a self-hosted desktop stream host for Artemis (Moonlight Noir),” a companion Moonlight fork with its own UI tweaks. Functionally, Apollo speaks the same GameStream-style protocol as Sunshine, so any standard Moonlight client can connect to it too. The distinguishing feature, and the reason the fork exists at all, is a built-in virtual display driver that automatically creates a screen matching your client’s resolution, refresh rate, and HDR state the moment you connect, then tears it down when you disconnect.
The Fork Story: Why Apollo Split From Sunshine
Apollo was created by developer ClassicOldSong as a fork of Sunshine, with the first upstream merge landing in the project’s history around September 2025 and continued syncing since. According to a technical breakdown hosted on DeepWiki, Apollo was forked specifically “to address specific limitations in virtual display handling, multi-user permission modeling, and client-specific configuration persistence” that existed in mainline Sunshine at the time.
The pain point that drove adoption is simple to describe. Streaming a game with Sunshine to a device with a different resolution or refresh rate than your host’s physical monitor traditionally meant plugging in a dummy HDMI adapter, manually setting a custom resolution, or accepting a mismatch that Moonlight would then scale or letterbox. A widely-shared 2024 thread in the r/MoonlightStreaming community, titled “Apollo fork of Sunshine is amazing,” laid out the appeal directly: Apollo “automatically generates a virtual display on the host computer that matches the specifications of the display being streamed to, including resolution, refresh rate, and whether it’s SDR or HDR.” No dummy plug, no manual display juggling, no guessing.
Apollo’s release notes also point to a second motivation tied to a Sunshine GitHub issue (#4078) describing a problem where “communication is not encrypted, audio stream not client-separated.” That issue shaped Apollo’s early focus on tightening per-client audio isolation and connection security, on top of the display work. None of this means Sunshine stood still. LizardByte’s team kept shipping through 2025 and 2026, and Sunshine has since closed much of the display-matching gap through its own configuration options, but Apollo’s automatic approach remains the more hands-off experience for Windows users who stream to a rotating set of devices.
LizardByte, the organization behind Sunshine, maintains a small family of related open-source tools beyond the streaming host itself, including packaging and documentation infrastructure that Sunshine’s Docker and Flatpak builds rely on. That broader organizational structure is part of why Sunshine’s release cadence has stayed steady: multiple maintainers share the load, rather than one developer carrying the whole project. Apollo, by contrast, is primarily the work of a single maintainer building on top of that upstream base, syncing improvements from Sunshine while adding the Windows-specific display and Artemis integration on top. That structural difference explains a lot about the gap in stars, forks, and release frequency between the two projects without implying anything negative about either one’s code quality.
Apollo vs Sunshine: Full Specs Comparison
The table below lines up both projects on the specs that matter most for a home streaming setup, pulled from each project’s GitHub repository, README documentation, and the live GitHub API as of September 2026.
| Spec | Apollo | Sunshine |
|---|---|---|
| Developer | ClassicOldSong | LizardByte |
| License | GNU GPL v3 | GNU GPL v3 |
| Repo created | July 29, 2024 | December 15, 2021 |
| GitHub stars (Sept 2026) | 10,849 | 41,027 |
| GitHub forks (Sept 2026) | 427 | 2,097 |
| Open issues (Sept 2026) | 332 | 151 |
| Latest tagged release | v0.4.6 (July 2025) | v2026.906.222525 (Sept 6, 2026) |
| Most recent commit push | May 21, 2026 | September 8, 2026 |
| Primary client | Artemis (Moonlight Noir) | Standard Moonlight |
| Built-in virtual display | Yes (Windows only) | No, native driver required |
| Auto HDR display matching | Yes | Manual configuration |
| Hardware encoding | AMD, Intel, Nvidia | AMD, Intel, Nvidia |
| Software encoding fallback | Yes | Yes |
| Official Windows build | Yes (WinGet, Chocolatey) | Yes (installer) |
| Official Linux build | Limited (no virtual display yet) | Yes (Docker, Flatpak) |
| Official macOS build | Not documented | Yes |
| Price | Free, open source | Free, open source |
Two rows deserve a second look. Sunshine’s issue count sits lower than Apollo’s despite having roughly four times the user base implied by star count, which tracks with a larger, more established maintenance team working through a backlog. Apollo’s release cadence tells a more complicated story: its last formally tagged version dates to July 2025, yet the repository kept receiving commits well into 2026, meaning day-to-day builds have moved past what the tagged release number suggests. If you install Apollo, expect to build from source or grab a nightly rather than assume the tagged release reflects the current feature set.
Encoding, Codecs, and GPU Support
Neither project reinvents video encoding. Both lean on the same hardware encoders already built into modern GPUs: Nvidia’s NVENC, AMD’s AMF, and Intel’s Quick Sync Video (QSV). Because Apollo pulls in Sunshine’s upstream encoding code on every merge, the two share an effectively identical codec baseline: H.264 for maximum client compatibility, HEVC (H.265) for better quality per bit, and AV1 on GPUs whose drivers expose an AV1 hardware encoder, meaning recent Nvidia RTX 40/50-series, AMD RDNA 3/4, and Intel Arc-class silicon.
Where they diverge is configuration surface, not codec support. Sunshine exposes its encoder settings through a browser-based web UI reachable at https://localhost:47990 after installation, with per-application overrides for bitrate, frame pacing, and codec preference. Apollo carries the same web UI structure inherited from Sunshine, then layers its virtual display controls on top, so switching between the two doesn’t mean relearning the interface. If your GPU already handles AV1 encoding under Sunshine, it will do the same under Apollo, because the underlying FFmpeg-based pipeline hasn’t materially changed between the fork point and today.
HDR and Virtual Display: The Feature That Started It All
This is the section that actually separates the two projects for most users. Sunshine streams whatever your host’s physical (or manually configured) display outputs. If your gaming PC drives a 1440p 165Hz monitor and you connect from a phone that wants 1080p60, Sunshine either scales down from the native output or requires you to change your desktop resolution before streaming, which knocks your physical monitor out of sync while you play remotely.
Apollo’s README states plainly that it ships a “built-in Virtual Display with HDR support that matches the resolution/framerate config of your client automatically,” adding that “Virtual Display support is Windows only” for now, with Linux support “planned” but not yet shipped. In practice, when a Moonlight client connects to Apollo, the host spins up a virtual monitor sized and configured to exactly match that client’s screen, including whether the client supports HDR, and tears it back down on disconnect. Your physical display, if you have one plugged in, is left alone.
An XDA Developers piece covering the Apollo-Moonlight combination summed up the practical effect: Apollo “automatically creates a virtual display to match your chosen device’s resolution, aspect ratio and refresh rate,” and its “improved HDR support over Sunshine makes it all look even prettier.” That’s a real, testable difference, not marketing language. If you stream to devices with mismatched screens (a Steam Deck OLED at 1280×800 90Hz one day, a phone at 2400×1080 120Hz the next), Apollo removes a manual step every single session. If you always stream to the same client at the same resolution, or you run headless on a fixed dummy plug already, the advantage narrows considerably.
Moonlight Client Compatibility Across Platforms
Because Apollo and Sunshine both implement the same GameStream-style protocol that Moonlight expects, client-side compatibility is nearly identical across the two. The differences that do exist come down to which client app you pair with, not the underlying connection.
| Client platform | Works with Sunshine | Works with Apollo | Notes |
|---|---|---|---|
| Android (Moonlight) | Yes | Yes | Standard Moonlight app from Google Play or F-Droid |
| iOS / iPadOS (Moonlight) | Yes | Yes | Available on the App Store |
| Steam Deck / SteamOS / Bazzite (Moonlight) | Yes | Yes | Runs as a Flatpak on Deck’s desktop mode |
| Apple TV (Moonlight) | Yes | Yes | tvOS app, best paired with a physical controller |
| Windows / macOS / Linux desktop (Moonlight) | Yes | Yes | Useful for testing before deploying to a handheld |
| Artemis (Moonlight Noir) | Partial | Yes, full support | Artemis is built specifically to pair with Apollo’s virtual display |
| Web browser (Moonlight Web) | Yes | Yes | Depends on the specific Moonlight Web build in use |
The one row worth flagging is Artemis. It’s technically a Moonlight fork in its own right, built to pair tightly with Apollo’s HDR-aware virtual display and pairing model. Artemis can often connect to a stock Sunshine host too, since the underlying protocol hasn’t diverged, but you lose the automatic display-matching behavior that makes the pairing worthwhile in the first place. If you’re committing to Apollo, pairing it with Artemis rather than standard Moonlight gets you the full feature set the developer intended.
Controller, Audio, and Multi-Client Handling
Both hosts forward gamepad input from the Moonlight client to the host PC as part of the core streaming protocol, and both support multiple simultaneous input devices for local co-op-style setups. Neither project’s public documentation names a specific virtual controller driver brand, so treat controller emulation as functionally equivalent between the two rather than a differentiator worth switching over.
Audio is where Apollo’s fork history adds a genuine, documented edge. Apollo’s own release notes reference Sunshine issue #4078, describing a scenario where “communication is not encrypted, audio stream not client-separated.” Apollo’s development addressed that gap directly, aiming for per-client audio isolation so a second connected user doesn’t hear or interfere with a first user’s audio stream. If your household runs Moonlight from more than one device against the same host, that isolation work is a legitimate reason to look at Apollo over stock Sunshine, though Sunshine has continued closing security and isolation gaps in its own 2026 releases.
Multi-client behavior also affects how many people can stream from one host at once. Neither project is designed as a commercial multi-tenant service. Both expect a single primary user per session in most configurations, with a second client typically limited to spectating or a manually configured co-op arrangement rather than two fully independent game sessions running in parallel. If you need true simultaneous multi-user gaming from one machine, that’s a job for a dedicated cloud gaming platform with per-seat GPU allocation, not a self-hosted Sunshine or Apollo box.
Platform Support: Windows, Linux, and macOS
Sunshine is the more genuinely cross-platform of the two. Its Docker image on Docker Hub ships tagged builds like lizardbyte/sunshine:v2026.907.203631-ubuntu-22.04, updated within a day of this article’s research, and its Flatpak package received a runtime update to org.kde.Platform 6.11 on September 7, 2026. Combined with native macOS and Windows installers, Sunshine is the host to reach for if your setup spans more than one operating system, or if you want to run it inside a container on a home server or NAS.
Apollo is, today, a Windows-first project. Its headline virtual display feature only works on Windows, and the project’s own documentation lists Linux virtual display support as a future goal rather than a shipped feature. You can still build and run Apollo’s base streaming components on Linux, but you’d be giving up the exact feature that makes Apollo worth choosing over Sunshine in the first place. macOS support isn’t documented for Apollo at all. If your host machine runs anything other than Windows, Sunshine is the more complete, better-supported option without much of a debate.
How to Install Apollo on Windows
Apollo’s Windows installation is deliberately simple, distributed through two mainstream Windows package managers rather than a standalone installer download. Open an elevated PowerShell window (right-click PowerShell, “Run as administrator”) and run one of the following.
Using WinGet (built into Windows 10 and 11):
winget install ClassicOldSong.ApolloOr, if you already use Chocolatey as your package manager:
choco upgrade apollo -yAfter installation, Apollo launches a background service and a web-based configuration UI, typically reachable at https://localhost:47990, mirroring Sunshine’s layout since Apollo inherited that interface from its parent project. From there, set up a PIN pairing code, install the Moonlight or Artemis client on your target device, enter the PIN when prompted, and the virtual display will generate automatically on your first successful connection. No manual resolution changes, no dummy HDMI plug required.
How to Install Sunshine
Sunshine’s installation path depends on your operating system. On Windows, download the official installer from the Sunshine releases page and run it like any other application. It installs as a background service that starts automatically on boot.
On Linux, the most consistent path is Docker, using the current image tag published on Docker Hub:
docker pull lizardbyte/sunshine:v2026.907.203631-ubuntu-22.04
docker run -d --name sunshine \
--device /dev/dri \
-p 47989-47990:47989-47990 \
-p 48010:48010/udp \
lizardbyte/sunshine:v2026.907.203631-ubuntu-22.04Flatpak users on most desktop Linux distributions can instead run flatpak install flathub dev.lizardbyte.app.Sunshine, which pulls the same underlying build packaged for sandboxed desktop use. Once running, Sunshine’s setup mirrors Apollo’s: open the web UI, generate a pairing PIN, connect from a Moonlight client, and start streaming. Because both projects share this same configuration layer, moving between them later doesn’t require learning a second interface from scratch.
Port Forwarding and Remote Access Setup
Streaming across your home Wi-Fi is straightforward with either host, since both devices sit on the same local network and discover each other automatically once paired. Streaming from outside your home network, say from a phone on cellular data or a laptop at a coffee shop, requires opening ports on your router so incoming connections can reach your host PC.
Both Apollo and Sunshine need the same port set forwarded: TCP 47984-47990 for the web UI and pairing handshake, TCP 48010 for RTSP control, and UDP 47998-48000 plus 48010 for the actual audio and video stream. Log into your router’s admin panel, create a port forwarding rule pointing each of those ports at your host PC’s local IP address, and, ideally, assign that PC a static local IP or a DHCP reservation so the forwarding rule doesn’t break after a reboot.
Once ports are open, Moonlight or Artemis can connect using your home’s public IP address, though most users pair a dynamic DNS service with their router so the address stays reachable even after an ISP-assigned IP change. Neither Apollo nor Sunshine includes a built-in relay or NAT traversal service comparable to what a commercial cloud gaming platform runs behind the scenes, so remote access is entirely dependent on your own router configuration working correctly. If port forwarding isn’t an option on your network, a self-hosted VPN like WireGuard or Tailscale connecting back to your home network is the more common workaround, letting Moonlight treat the remote connection as if it were local.
Troubleshooting Common Setup Problems
Most first-time setup issues with either host trace back to a handful of repeatable causes rather than deep software bugs. Here’s what tends to go wrong and how it typically gets resolved.
- Pairing PIN fails or times out. This almost always means the client and host aren’t actually reaching each other on the network, most commonly because they’re on different VLANs, a guest Wi-Fi network with client isolation enabled, or a firewall blocking the pairing port. Confirm both devices show the same local subnet before troubleshooting further.
- Stream connects but shows a black screen. On Sunshine, this usually means no display is available for capture, common on headless servers without a dummy HDMI plug or a configured virtual display. Apollo’s automatic virtual display is specifically designed to avoid this failure mode on Windows.
- Choppy video despite a fast network. Check whether hardware encoding is actually active in the host’s web UI. If the GPU driver is outdated or the selected encoder isn’t supported, both projects fall back to software encoding, which is far more CPU-intensive and prone to dropped frames on anything but a high-end processor.
- Audio drops out after a few minutes. Often tied to Windows power-saving settings suspending the audio device. Disabling USB selective suspend and audio device power management in Windows’ power plan settings resolves this on both hosts.
- Controller input lags behind video. Usually a Wi-Fi signal strength issue on the client side rather than a host-side problem, since input travels over the same connection as the video stream. Switching the client to 5GHz or 6GHz Wi-Fi, or a wired connection where possible, is the most reliable fix.
Security and Privacy: What Changes When You Self-Host
Running your own streaming host trades the security model of a commercial cloud gaming service for one you’re responsible for maintaining yourself. Neither Apollo nor Sunshine sends your gameplay, screen contents, or account credentials to a third-party server. Everything stays on your own network unless you explicitly forward ports or set up remote access, which is a meaningful privacy advantage over cloud services that route your session through a provider’s data center.
That local-only default flips the moment you open your router to the internet for remote play. Any forwarded port is a potential entry point, and both projects rely on you pairing a device with a PIN before it can stream, which prevents casual drive-by access but doesn’t replace the deeper protections a managed service provides, like automatic security patching or DDoS mitigation at the network edge. Apollo’s early development explicitly targeted a documented Sunshine weakness around unencrypted, non-client-separated audio streams (GitHub issue #4078), which is worth knowing if you’re evaluating either project for a household where multiple people connect simultaneously. Keeping either host updated to its latest build, using a strong pairing PIN, and avoiding indefinite port forwarding when you’re not actively using remote access are the practical steps that matter most regardless of which project you choose.
Community Support and Documentation
Sunshine’s larger community translates directly into easier troubleshooting. With 41,027 GitHub stars and an organization backing the project, Sunshine benefits from years of accumulated setup guides, a well-populated Discord community linked from its official documentation, and enough GitHub issue history that most common problems already have a documented fix. When something breaks, a search of Sunshine’s issue tracker or the LizardByte documentation site usually turns up an answer within minutes.
Apollo’s support surface is smaller and more concentrated. With 332 open issues against a codebase maintained primarily by ClassicOldSong, response times can vary more than with Sunshine’s larger team, and the r/MoonlightStreaming subreddit tends to be the more active venue for peer troubleshooting than Apollo’s own repository. That’s not disqualifying. It just means Apollo users should expect to lean on community forums and the GitHub issue tracker more heavily than on official, frequently-updated documentation, at least until the project’s next formal release closes the gap between its shipped features and its last tagged version.
Performance and Real-World Reports
Neither LizardByte nor ClassicOldSong publishes a formal latency benchmark suite, and no independent lab has run a controlled frame-by-frame comparison between the two hosts as of this writing, so treat any specific millisecond figure you see elsewhere with caution. What does exist is a consistent pattern across community reporting and reviewer testing.
The r/MoonlightStreaming thread that introduced many users to Apollo focused entirely on display-matching convenience rather than raw speed, describing the experience as functioning “similarly to Sunshine” with the virtual display as the standout addition, not a latency win. XDA Developers’ coverage of the pairing reached a similar conclusion: the appeal is picture quality and setup friction, with the outlet noting streamed games run “near-zero latency” close to native performance, a characterization that applies to both hosts since they share the same encoding pipeline. A Yahoo Tech piece covering open-source streaming alternatives to paid cloud gaming services likewise treated the underlying performance of Sunshine-based hosts as effectively interchangeable, again pointing to setup and feature differences as the deciding factor rather than frame timing.
The honest takeaway: because Apollo inherits Sunshine’s encoding pipeline on every upstream merge, your actual streaming latency depends far more on your network, your GPU’s encoder, and your client device than on which fork you picked. Choose based on the display and audio features, not an expectation of a faster stream.
What Self-Hosted Streaming Actually Costs
Both Apollo and Sunshine are free, open-source software with no subscription tier, no usage cap, and no per-device licensing fee. The real cost of this setup is the hardware and electricity behind it, and it’s worth comparing against what a paid cloud gaming subscription runs for the same use case.
| Setup | Upfront cost | Monthly cost | Notes |
|---|---|---|---|
| Apollo or Sunshine on existing gaming PC | $0 | ~$3-8 in electricity | Free if you already own the PC and GPU |
| Budget dedicated host PC (RTX 4060-class) | $700-900 one time | ~$5-10 in electricity | NVENC AV1 support included |
| Cloud GPU rental for self-hosting (spot pricing) | $0 | Roughly $0.20-$0.60/hr on-demand | Pay only while streaming, cost varies by provider and GPU tier |
| GeForce NOW Ultimate (for comparison) | $0 | $19.99/mo | No hardware required, capped hours in some tiers |
| Shadow PC (for comparison) | $0 | $0-$55/mo depending on plan | Rents you a full remote Windows PC |
For anyone who already owns a capable gaming PC, Apollo and Sunshine both turn a sunk hardware cost into a free personal cloud gaming service, the electricity draw of running a background service is negligible next to a $19.99-a-month subscription. The calculus only shifts if you’re buying hardware specifically to host, in which case a modest GPU with hardware AV1 encoding pays for itself against a GeForce NOW Ultimate subscription within roughly a year of steady use.
Real-World Use Cases
Both hosts show their strengths in specific, repeatable scenarios rather than abstract benchmarks. Here’s where each one earns its place.
- Living room streaming to an HDR OLED TV. Apollo’s automatic HDR-aware virtual display means connecting a Moonlight client on an Nvidia Shield or Apple TV to a gaming PC in another room produces correctly tone-mapped HDR without touching Windows display settings first.
- Steam Deck or Bazzite handheld as a Moonlight client. Streaming from a desktop to a Steam Deck running Bazzite or SteamOS works identically on either host, since the Deck connects as a standard Moonlight client regardless of which project is running server-side.
- Multi-OS home lab. A household running a Linux home server for game hosting alongside a Windows gaming rig benefits from Sunshine’s genuine cross-platform Docker and Flatpak support, something Apollo doesn’t yet match outside Windows.
- Streaming to a phone on a different network daily. Someone who streams from their gaming PC to a phone at work one day and a tablet at home the next benefits most from Apollo’s per-client resolution matching, since each device gets its own correctly-sized virtual display automatically.
- Renting a cloud GPU instance as a personal cloud gaming box. Spinning up a Windows cloud instance with an Nvidia GPU and installing Sunshine (or Apollo, if Windows-based) turns a pay-by-the-hour cloud server into a personal, on-demand alternative to a commercial service, with Sunshine’s Docker support making Linux-based cloud instances simpler to automate.
- Multi-user household streaming setup. A shared gaming PC serving two or more people who stream to separate devices at the same time benefits from Apollo’s documented work on per-client audio separation, addressing the exact isolation gap that originally motivated the fork.
- Backup access while traveling. A gamer who leaves a desktop running at home and streams to a laptop from a hotel gets the same core experience from either host, but Sunshine’s more mature documentation makes diagnosing a connection issue from an unfamiliar network easier without local hands-on access to the machine.
None of these scenarios require exotic hardware. A mid-range GPU from the last three to four years with a working hardware encoder covers every use case above, and the same host installation serves all of them simultaneously since neither project limits you to a single paired device.
Migration Guide: Switching Between Apollo and Sunshine
Because both projects share the same underlying configuration structure, moving from one to the other is far less disruptive than switching to a completely different streaming stack. Follow these steps for a clean migration in either direction.
- Note your current pairing and app list. Open your existing host’s web UI at
https://localhost:47990and record any custom application entries, resolution overrides, and encoder settings you’ve configured, since these don’t automatically carry over between separately installed services. - Uninstall the current host cleanly. On Windows, use “Add or Remove Programs” for Sunshine, or run
winget uninstall ClassicOldSong.Apollofor Apollo, to avoid both services fighting over the same network ports (47989-47990 and 48010). - Install the new host. Follow the WinGet, Chocolatey, Docker, or Flatpak steps outlined earlier in this article for whichever project you’re switching to.
- Re-open the required firewall ports. Both hosts need TCP 47984-47990 and UDP 47998-48000 plus 48010 open on Windows Firewall or your Linux firewall of choice. Windows installers typically prompt for this automatically, while Docker and Flatpak setups may require a manual rule.
- Re-pair every Moonlight client. Because the underlying service identity changes, each device running Moonlight or Artemis needs to remove the old host entry and pair again using a fresh PIN generated by the new host’s web UI.
- Rebuild your per-application settings. Re-enter any custom launch commands, resolution overrides, or bitrate caps you noted in step one.
- Test with your most demanding client first. Connect from whichever device has the highest resolution or HDR requirement to confirm the new host handles it the way you expect before relying on it for daily use.
The whole process typically takes under 20 minutes on a single host machine, and running both is technically possible if you configure them on different ports, though most users find it simpler to commit to one and remove the other to avoid input or audio device conflicts.
Pros and Cons at a Glance
Apollo pros: automatic HDR-aware virtual display eliminates dummy HDMI plugs, per-client audio isolation addresses a documented Sunshine security gap, simple WinGet and Chocolatey installation on Windows, shares Sunshine’s familiar web UI.
Apollo cons: Windows-only for its headline virtual display feature, smaller community with roughly a quarter of Sunshine’s GitHub stars, last formally tagged release dates to mid-2025 despite ongoing commits, no documented macOS support.
Sunshine pros: genuinely cross-platform with native Windows, Linux, and macOS support, Docker and Flatpak packaging for server and container deployments, larger community and faster, more consistent tagged release cadence, backed by an established open-source organization.
Sunshine cons: no built-in automatic virtual display, matching a client’s resolution and HDR state still requires manual configuration or a dummy HDMI adapter, historically slower to close the specific audio-isolation gap that Apollo was built to fix.
The Verdict: Which One Should You Run?
Pick Sunshine if your host runs Linux or macOS, if you want the more actively tagged and broadly documented project (41,027 stars and a same-day commit history versus Apollo’s 10,849 stars and a stale tag), or if you’re deploying inside Docker on a home server. It remains the safer default recommendation for most Moonlight setups precisely because of that platform reach and release consistency.
Pick Apollo if your host runs Windows and you regularly stream to devices with different resolutions, refresh rates, or HDR capabilities, since the automatic virtual display genuinely removes a manual step every session. Households streaming to multiple devices at once also gain real value from Apollo’s audio-isolation work, a direct response to a documented weakness in Sunshine’s original design.
Neither choice locks you in. Both are free, both speak the same Moonlight-compatible protocol, and migrating between them (detailed above) takes about 20 minutes. Start with Sunshine if you’re new to self-hosted streaming and want the more established path, then try Apollo specifically if you find yourself fighting HDR or resolution mismatches on Windows.
Frequently Asked Questions
Is Apollo safe to use instead of Sunshine?
Yes. Apollo is an open-source fork released under the same GNU GPL v3 license as Sunshine, with its source code publicly available on GitHub. It was created specifically to address a documented Sunshine issue around unencrypted, non-client-separated audio streams, so its security posture in that area is arguably improved rather than weakened.
Can I run Apollo and Sunshine on the same PC?
Technically yes, if you configure them to use different network ports, but both projects default to the same port range (47989-47990 and 48010), so running them simultaneously without reconfiguration will cause conflicts. Most users install one, test it, and only install the other after removing the first.
Does Apollo work on Linux or Steam Deck as a host?
Apollo’s core streaming components can be built on Linux, but its signature virtual display feature is Windows-only as of September 2026, with Linux support listed as planned but not yet shipped. If you want to host from a Linux machine or a Steam Deck, Sunshine is the more complete option today.
Which one is better for streaming HDR games?
Apollo, on Windows. Its built-in virtual display automatically matches the connecting client’s HDR capability, while Sunshine requires you to configure HDR output manually to match whatever device you’re streaming to.
Do I need a powerful GPU to run either one?
Both rely on your GPU’s hardware video encoder rather than the GPU’s gaming performance directly, so any Nvidia, AMD, or Intel GPU from the last several years with NVENC, AMF, or QSV support will encode a stream smoothly. Your actual gaming performance still depends on the GPU rendering the game itself.
Is Moonlight required to connect to Apollo or Sunshine?
You need a Moonlight-compatible client. Standard Moonlight works with both hosts. Apollo also supports Artemis, a Moonlight fork (“Moonlight Noir”) with additional client-side features tuned specifically for Apollo’s virtual display and pairing behavior.
Which one should Steam Deck owners use as a client?
The client-side choice doesn’t depend on the host. A Steam Deck running standard Moonlight can connect to either Apollo or Sunshine without issue, so pick the host based on your host PC’s operating system and whether you value Apollo’s HDR display matching.
Will Apollo ever be merged back into Sunshine?
There’s no official announcement of a merger as of September 2026. Apollo continues pulling changes from Sunshine’s upstream repository on its own schedule, keeping the two projects compatible at the protocol level, but they remain separately maintained with different priorities: Sunshine focused on cross-platform reach, Apollo focused on Windows display handling.
Related Coverage
- Sony's 50-Page ToS Says You Never Own PS Games [2026]
- Best Emulators for Windows PC: 8 Systems in 12 Steps [2026]
- Android Studio vs Genymotion vs BlueStacks: 640MB Gap [2026]
- Ares Emulator Setup: 20 Systems in 12 Steps [2026]
- Metacritic vs OpenCritic vs Steam: 1-Point Bonus Gap [2026]
