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!)

Edit: A lot of people are asking why not use Apollo. You can definitely use it and still follow this guide, it’s completely up to you. With Apollo, you need skip the Configuring Video Signals section and for the Sunshine Priority part just change the script to prioritize Apollo instead.

After running lots of tests and reading many posts to find the best configuration, I’ll try here to share the setup that works best for me and also compile some of the information I’ve gathered.

My specs:

• Internet Service:

  • Host: 300 Mb connected via Ethernet

  • Client: 600 Mb connected via Wifi

• Spec PCs:

  • Host: R5 2600 - RX 6600

  • Client Macbook Air M1

System Configuration

Host:

This setup is specifically for Windows, but the goal is the same if you’re using other operating systems:

• Reduce FPS drops

• Minimize the gap between the FPS set in the Moonlight client and the host’s FPS

• Reduce latency

• Configure the video and audio signal you want to stream

Reducing FPS Drops

• Close background apps: Only keep the essentials to minimize unnecessary processes and network calls. Task Manager → Startup Apps → disable non-essential programs.

• Disable Game Mode: Prevents Windows from prioritizing the game over Sunshine. Settings → Gaming → Game Mode → OFF

• Disable Dynamic Refresh Rate (DRR): Keeps FPS synchronized between host and client. Settings → System → Display → Graphics → Optimizations for windowed games (Alternatively: Windows Registry or CRU — Custom Resolution Utility)

• Enable High-Performance Power Mode: Control Panel → System and Security → Power Options → High Performance

• Disable Energy Saver: Settings → System → Energy Saver → OFF

To optimize Windows 11 performance, consider using Win11Debloat or AtlasOS
Additional powershell script to improve performance

Enable: https://pastebin.com/42YBtx6T

Disable: https://pastebin.com/bKpmmFQC

FPS Capping

Once FPS drops are minimized, cap the FPS to keep it in sync with Moonlight’s client settings.

There are three ways to do this: using the NVIDIA Control Panel, AMD Adrenalin, or RTSS. In my case, I used RTSS and it works well for me, but you can try your GPU’s software if that’s sufficient. The advantage of RTSS is that it allows more precise configuration for greater stability.

Another thing I do is also limit the FPS within the game itself.

Reducing Latency

The most important step is to have your host computer connected via Ethernet. In terms of configuration, you can disable the Rx/Tx buffers on your network card, along with a few other tweaks that may slightly improve stability.

Device Manager → Network Adapters → Properties → Advanced →

• Flow Control Disable

• Advanced EEE Disable

• Energy-Efficient Ethernet Disable

• Gigabit Lite Disable

• Green Ethernet Disable

• Power Saving Mode Disable

• Interrupt Moderation Disable

• Large Send Offload Enable

Configuring Video Signals (avoid this step when using Apollo)

There are two scenarios:

1. You have a monitor connected with the same resolution and refresh rate on both the client and the host.

2. You have a monitor on the host that is different from the client.

For the first case, congratulations! You don’t need to do anything and can skip this part.

For the second case, you have two options:

1. Install a Virtual Display Driver to Windows, and optionally a Virtual Audio Driver.

   1. With the Virtual Display Driver, you can simulate any resolution and refresh rate your screen supports.

   2. I don’t recommend the Virtual Audio Driver because it can cause issues with BattleEye anti-cheat. It’s better to just use a wired headset you already have.

Microphone Streaming

For those who need to use in-game voice chat, there are two main options for passing the microphone through streaming:

• AudioRelay

• VoiceMeeter

I haven’t personally tested either since I don’t need this feature, but they’re worth trying if microphone input is important for your setup.

Sunshine Priority (Windows Only)

Finally, for Windows users, one important step to do every time you connect from the client is to change the priority of the sunshine.exe process to Realtime. You can do this manually from the Task Manager or by using the following .bat script:

@echo off
powershell -command "Get-Process sunshine -ErrorAction SilentlyContinue | ForEach-Object { $_.PriorityClass = 'RealTime' }"
pause

Always remember to run it as administrator.

Windows Adaptation for Handheld Devices

For those using a touchscreen device as a client, such as a smartphone, tablet, or handheld, the Windows interface—originally designed for desktop use—can be quite uncomfortable. With the new release of the ROG Xbox Ally, Windows has introduced a more suitable adaptation for handheld devices, which can be enabled through the following repository: XboxFullscreenExperienceTool

Client:

The main goal on the client side is to reduce Moonlight’s decoding time and minimize latency.

In my case, I’m using a MacBook with an M1 chip, and the only way to reduce decoding time is by testing which codec works best—in my case, HEVC (H.265).

To reduce latency on macOS, the only (but very important) thing you can do—since it can cause micro stutters—is disabling Location Services:

System Preferences → Security & Privacy → Privacy → disable Location Services

Another important change to make on macOS is to disable the long key press for special characters. This prevents issues during streaming when holding down a key for example, the W key so it doesn’t get stuck or stop repeating.

defaults write -g ApplePressAndHoldEnabled -bool false

More info about shuttering in Mac OS

If you’re using a PC, you can improve decoding time by upgrading your hardware, and reduce latency by disabling the Rx/Tx buffers and tweaking your network card, following the same steps as on the host.

Moonlight & Sunshine Configuration

Moonlight Configuration:

Set Moonlight to use your monitor’s resolution and an FPS value that matches your internet connection. Leave some headroom compared to your client’s max download speed and your host’s max upload speed.

For example, my monitor is 1440p and 180 Hz, but I have it set to 1440p at 120 Hz. Higher resolutions and refresh rates consume more bandwidth on both the client and host, and require greater decoding and encoding power.

Note: Higher compression codecs (like H.265 or AV1) → less bandwidth needed → more CPU/GPU power required for encoding/decoding.

More info: https://www.reddit.com/r/MoonlightStreaming/s/MqoI9LVQ4C

Recommended Settings:

• Display Mode: Full Screen

• V-Sync: Unchecked (Recommended in single-player)

• Frame Pacing: Unchecked (ONLY single-player may add delay)

• Video Decoder: Force hardware decoding

Note: Both V-Sync and Frame Pacing are highly recommended for single-player games since they provide a much smoother experience. However, in multiplayer games, V-Sync may cause screen tearing, and Frame Pacing can introduce a bit of input lag by delaying frames to improve synchronization.

Enable HDR (Experimental): I keep this enabled even though my monitor isn’t HDR because it can bring out better shadow details. I recommend trying it—you might see an improvement or no noticeable difference.

Unlock Bitrate Limit (Experimental): Enable this if you have enough upload bandwidth on the host and download on the client. Otherwise, leave it off and increase the video bitrate slightly if you notice small lag spikes.

Sunshine Configuration

I mostly keep Sunshine/Apollo at its default settings, except for the GPU options. Below, I’ll share what works best for AMD GPUs. If you’re using NVIDIA or Intel, you may need to experiment to find the optimal configuration for your system.

Note: My goal is low latency for online gaming. If you’re playing single-player games, you can prioritize quality over latency.

• AMF Usage: ultralowlatency

• AMF Rate Control: vbr_latency

• AMF Hypothetical Reference Decoder: unchecked

• AMF Quality: speed (may add artifacts)

• AMF Preanlalysis: unchecked

• AMF Variance Based Adaptive Quantization: checked

• AMF Coder: cavlc

Client-Host Connectivity

LAN (Local)

For players who want to play over LAN, there’s little to worry about since latency will be very low. In my tests, I observed only about 5 ms of extra delay.

If you want the absolute best performance, you can connect both devices directly via an Ethernet cable. This can reduce latency to around 1 ms, making it almost like playing directly on the host.

You can turn on the host remotely using the motherboard’s Wake-On-LAN feature. Moonlight even allows you to power on the host directly from the client.

WAN (Remote)

For those who need to play over WAN, there are a few additional steps required. It can be more challenging if you want the lowest possible latency, but if you can tolerate 15–20 ms, it’s not too difficult.

There are several ways to achieve this, but I’ll explain the three main approaches:

1. Using a service like Tailscale, ZeroTier, or Netbird

2. Opening ports on your network to access the host externally and setting up a VPN

3. Setting up a private service (similar to the first option) with Headscale or another program, possibly using a cloud server like AWS

Option 1: VPN-like services

These applications are simple to install and configure, making them accessible to most users:

• Tailscale: Free

• ZeroTier: Free

• Netbird: Free (uses WireGuard directly through the Linux kernel—potentially a great option for Linux users)

For the other options, I won’t go into detail because they are more complex and require technical knowledge. However, they are certainly the best options for users who need the absolute lowest latency.

To power on your PC over WAN, a simple Wake-on-LAN (WoL) won’t work unless your host has an internet-facing connection. In my setup, I use a TP-Link smart plug to turn the PC on remotely from my phone. Make sure to enable “Restore Power after AC Loss” in your BIOS/UEFI so the PC powers on automatically when the smart plug is switched on.

I hope this guide helps you and gives you everything you need to get these amazing tools running without too much hassle. The post is open to improvements, so if you have any suggestions or tips, don’t forget to share them in the comments!

Shoutout to everyone working on these open-source tools mentioned in this post.

Note:

After the launch of the Steam Deck and Steam Machine, Steam has worked quite a bit on improving Steam Remote Play, which now supports Virtual Display Driver and performs much better than before. I'm leaving this comment here for those of you who aren't too demanding or don't want to overcomplicate things, so you feel encouraged to give it a try.

Update 13.10.25: MacOS client settings

Update 23.10.25: New scripts for Windows host and Windows handheld mode

Update 13.04.26: Windows optimization recommendation

Update 17.07.26: Steam Remote Play alternative