I’ve been testing a bunch of different Moonlight/GameStream projects lately while working on Artemis Switch, so I figured I’d put the main ones I’ve come across in one place.

If you’re trying to fix stuttering, improve frame pacing, use a virtual display, or just try something beyond the usual Sunshine + Moonlight setup, there are quite a few interesting forks and alternatives now.

Hosts

• NVIDIA GameStream The original implementation everything grew out of. NVIDIA discontinued it, but it’s still the foundation of the protocol Moonlight uses.
• Sunshine The standard open-source GameStream host and probably still the best baseline if you just want something stable and widely supported.
• Apollo A Sunshine fork with much better virtual-display integration. It can automatically create and match a display to the client resolution and refresh rate, which makes it really nice for headless setups.
• Vibeshine A more experimental Sunshine fork focused on Windows capture, display automation, frame pacing, RTSS integration, and other latency/performance tweaks.
• Vibepollo Basically brings a lot of the Vibeshine ideas into Apollo. This has been one of my favorite hosts so far. I already liked Apollo’s virtual-display setup, and Vibepollo adds a lot of the capture and frame-pacing work I was looking for.
• Foundation-Sunshine Another Sunshine fork with things like additional HDR support, audio improvements, encoder changes, and a redesigned web UI.
• Wolf / Games on Whales A very different approach. It’s focused on Linux and Docker, with games running in isolated containers and support for multiple remote clients using the same physical machine.
• Punktfunk I recently tried Punktfunk too, and so far I’m pretty impressed. It feels really good and honestly might be even better than Vibepollo for my setup. I haven’t tested its custom protocol yet though, so I don’t want to make a full latency or quality comparison until I’ve tried that part properly.

Clients

• Official Moonlight Still the baseline. Available basically everywhere and usually the first client I use when comparing performance.
• StreamLight A Moonlight fork with a much more console/gamepad-oriented interface. Together with StreamTweak it also adds host monitoring, Tailscale integration, remote controls, shutdown/update commands, etc.
• Artemide Android-focused Moonlight fork with things like ultra-low-latency modes, direct presentation, and FSR presets.
• Artemis / Moonlight Noir Apollo’s Android-oriented companion client. It works really nicely with Apollo-style virtual displays and host management.
• Moonlight V+ Another Android fork experimenting with things like frame generation and extra host-side tools.
• Artemis Switch This is the fork I’m currently working on. It’s based on Moonlight-Switch but focuses specifically on improving the native Horizon OS experience: presentation timing, lower latency, FSR/RCAS filtering, adaptive pacing, and reducing the small stutters that become really noticeable on the Switch.
• Moonlight-Switch The original Switch client and the upstream project Artemis Switch is based on.

Separate alternative: Parsec

Parsec is worth mentioning too, although I’d put it in a separate category since it isn’t really part of the Moonlight/GameStream ecosystem.

It uses its own streaming stack, but if the main goal is simply low-latency remote gaming, it’s still a useful comparison point.

What I’ve personally tested

I’ve spent a decent amount of time switching between:

Hosts: Sunshine, Apollo, Vibepollo, and Punktfunk
Clients: Moonlight-Switch, Artemis Switch, Artemis Android, and regular Moonlight Android

That testing is actually one of the reasons I started working on Artemis Switch.

On the Switch, tiny differences in decoding, presentation timing, buffering, network behavior, and frame pacing can make a surprisingly big difference.

For a while, Vibepollo was probably the host I liked the most, mainly because I get Apollo’s great virtual-display workflow together with the newer capture and pacing improvements.

After trying Punktfunk, though, I’m not as sure anymore. So far it looks really good, and I might actually prefer it, but I still need to test the custom protocol before comparing them properly.

And on the client side, I obviously have a soft spot for Artemis. 😅

My goal with Artemis Switch is basically to bring more of that polished Apollo/Artemis experience to the native Switch client while continuing to squeeze as much smoothness and as little latency as possible out of Horizon OS.

There isn’t really one universally “best” setup though. Hardware, GPU, network, display refresh rate, decoder, client OS, capture method, and even the game itself can change what works best.

If I missed a Sunshine/Apollo/Moonlight fork, experimental client, or some obscure streaming project you’re using, drop it below. I’d genuinely like to try more of them.

Links:

• Sunshine: https://github.com/LizardByte/Sunshine
• Apollo: https://github.com/ClassicOldSong/Apollo
• Vibeshine: https://github.com/Nonary/vibeshine
• Foundation-Sunshine: https://github.com/AlkaidLab/foundation-sunshine
• Wolf: https://github.com/games-on-whales/wolf
• Punktfunk: https://docs.punktfunk.unom.io/
• StreamLight: https://github.com/FoggyBytes/StreamLight
• Artemis / Moonlight Noir: https://github.com/ClassicOldSong/moonlight-android
• Moonlight V+: https://github.com/qiin2333/moonlight-vplus
• Artemis Switch: https://github.com/antoinebou12/Artemis-Switch
• Moonlight-Switch: https://github.com/XITRIX/Moonlight-Switch
• Parsec: https://parsec.app/

If you are looking to tweak your streaming setup, fix stuttering, or find a headless virtual display solution, you don't have to stick strictly to the baseline Sunshine + official Moonlight setup.

Here is a breakdown of the active forks, alternative hosts, and FFmpeg-powered clients currently in the ecosystem based on what the community and developers are running right now.

🖥️ Hosts & Servers (The Senders)

• NVIDIA GameStream: The original foundation that started it all. Officially deprecated by NVIDIA, but the bedrock of the protocol.
• Sunshine: The modern, open-source standard GameStream compatibility baseline that replaced NVIDIA's official host.
• Apollo: A Sunshine fork featuring capability-gated extensions and built-in virtual display support using SudoVDA. It is great for headless setups and auto-matches the resolution/framerate of your client.
• Vibeshine: A highly active, AI-enhanced Sunshine fork focusing heavily on display automation, Windows Graphics Capture running as a service (which allows full framerate capture of frame-generated titles without VRAM crashes), and strict RTSS frame pacing integration.
• Vibepollo: An Apollo fork that integrates Vibeshine's features (like the native virtual display driver and HDR handling) right into the Apollo architecture. This is highly recommended if you already use Apollo but want tighter frame pacing.
• Foundation-Sunshine: A fork by AlkaidLab that adds HDR10/HDR Vivid, advanced audio support, optimized encoders, and a modernized control panel.
• Wolf (Games on Whales): A completely different streaming server built from the ground up for Linux and Docker. It allows you to share a single host machine with multiple remote clients simultaneously by running games inside isolated containers.
• Punktfunk: A newer, highly experimental low-latency streaming host/client protocol if you want to test out a completely different capture approach.

📱 Clients & Receivers (The Players)

• Official Moonlight PC / Mobile: The standard baseline client for PC, macOS, Linux, iOS, Apple TV, Android, etc. (The PC Qt version heavily utilizes FFmpeg and libplacebo for decoding and rendering).
• StreamLight: A massive Moonlight fork that completely overhauls the UI for gamepads. When paired with "StreamTweak" on the host, it unlocks deep integration like built-in Tailscale, live host metrics/NIC speed matching, remote pause, and the ability to remotely trigger Windows Updates and shutdown.
• Artemide: Highly recommended for Android users. It features ultra-low latency (ULL), direct presentation, and built-in FSR presets (Performance/Balanced/Quality).
• Artemis / Moonlight Noir: Apollo’s dedicated Android companion client, offering excellent host UX and virtual display integration.
• Moonlight V+: An alternative Android fork that adds frame-generation support and extra host tools.
• Artemis Switch: A Moonlight-Switch fork focusing on Switch-specific video presentation, FSR/RCAS filtering, and adaptive low-latency pacing.
• Moonlight-Switch: The original upstream Switch client that Artemis is built on.

A little about my setup and testing: I actually work on the Artemis Switch fork, looking at multiple optimizations to eliminate stuttering and improve low-latency pacing on the console. Because of that, I’ve personally tested almost all these major combinations to see what actually works. My testing stack includes:

• Hosts: Sunshine, Apollo, and Vibepollo.
• Clients: Moonlight-Switch, my Artemis Switch fork, the Artemis companion client, and standard Moonlight Android.

I like vibepollo and Artemis

Let me know if I missed any niche forks or experimental branches you guys are using!

(Note: I had an AI help format this post to make sure links were laid out clearly!)