Can anyone share their exact settings for the Lenovo Y700? I’ve tried many configurations, but I always run into stuttering during gaming sessions with Artemis; after a few minutes, the network frame rate and render rate drift apart, causing stuttering. My goal is a smooth 60 fps. My PC has an RTX 4070, Ryzen 7 5800X3D, and 32GB of RAM; if anyone has a precise setup, it would be a huge help.

My configuration is as follows:
Tablet in standard mode (60Hz)
Game Assistant disabled

Artemis: Resolution: 1600p
Frame rate: 60fps
Bitrate: 44Mbps
Frame pacing: Balanced or PLL (no difference)
LFR: On Ultra-low latency: On
Tight VSync: On
Enforce display: On and Off (no difference)
Codec: HEVC or AV1 (no difference)

On the host: Refresh rate: 60Hz or 120Hz (depending on double refresh rate)
Nvidia App: Low latency mode: On
VSync: Off
Power mode: Performance
RTSS: 60fps

Full wireless DualSense support for Moonlight on Android and Windows

UPDATE: The post has been updated. On Android 12 and newer, an external Bluetooth adapter is no longer required for wireless DualSense functionality. A new testable Artemis Extended release is now available.

The currently attached video was recorded before native Android Bluetooth support was added, so it still demonstrates the external USB Bluetooth adapter setup. I’m planning to upload an updated video showing the new adapter-free connection and its functionality soon.

I would like to introduce my current project, which brings full wireless DualSense support to Android and Windows Moonlight clients without requiring any additional programs.

The project consists of modified versions of:

• The Moonlight Windows client
• The Artemis Android client
• The Apollo host

The full source code for all three projects is available on GitHub. Ready-to-use builds can be downloaded from the Releases section of each repository.

• Artemis Extended: https://github.com/Taveszfito/Artemis-Extended-Native-Wireless-DualSense-Features
• Apollo Extended: https://github.com/Taveszfito/Apollo-Extended
• Moonlight Extended: https://github.com/Taveszfito/moonlight-extended

How does it work?

Apollo Extended creates a virtual DualSense controller on the host, while the client handles the physical controller.

Instead of reducing everything to standard gamepad input, the stream carries DualSense-specific input and feedback in both directions. This allows the controller’s advanced features to keep working remotely.

Windows client

This is the simple part.

Connect the DualSense through Bluetooth or USB, connect to the host, and start streaming.

The Windows client also supports microphone forwarding to the host, including audio from the DualSense built-in microphone.

Additional controller-related options are available in the Extended section of the client settings.

Android client

On Android 12 and newer, the DualSense can now connect directly to the Android device through the normal Bluetooth settings.

No external Bluetooth adapter is required anymore.

The process is simply:

1. Pair the DualSense with the Android device.
2. Open Artemis Extended.
3. Connect to the Apollo Extended host.
4. Start streaming.

The controller is detected and exposed to the host as a virtual DualSense. Input and feedback are then carried in both directions through the stream.

A wired USB connection is also supported.

What works?

The current Android and Windows implementations support:

• All buttons and analog sticks
• Analog triggers
• Adaptive triggers
• Multi-touch touchpad input
• Gyroscope and motion sensors
• Conventional rumble
• Native HD haptics
• Built-in controller speaker
• Headphone jack
• Player LED control
• Lightbar color control
• Microphone LED and mute control

The controller speaker uses a dedicated audio path. DualSense speaker effects are sent separately from the normal game audio, so they are played through the controller instead of being mixed into the phone, tablet, or PC speakers.

Connecting headphones to the DualSense jack is also supported. Stream audio is automatically routed through the connected headset and returns to the previous output when the headset is unplugged.

The DualSense mute button can be used as a global client microphone mute switch in every connection mode.

Microphone support

The Android device microphone can be forwarded to the host while using a directly connected wireless DualSense.

The DualSense built-in microphone currently requires either:

• A wired USB connection, or
• The optional USB Bluetooth HCI bridge

Direct access to the DualSense microphone through Android’s standard Bluetooth HID connection is the only major limitation of the new adapter-free route.

On Windows, the DualSense built-in microphone is available through the supported controller connection.

Apollo Extended presents the forwarded microphone to Windows through a virtual Steam Streaming Microphone device.

Optional USB Bluetooth HCI bridge

Artemis Extended still includes the USB Bluetooth HCI bridge developed for earlier releases. It is no longer required for normal wireless DualSense functionality on Android 12+, but it remains available as an optional connection method.

The bridge is also currently required if you want to use the DualSense built-in microphone wirelessly on Android.

Supported adapter chipsets include:

• CSR
• Realtek
• Actions ATS2851

The chipset alone does not guarantee compatibility. Firmware differences between Bluetooth dongles can affect pairing, connection stability, or individual controller features.

Apollo Extended

Apollo Extended uses VIIPER to emulate a fully functional DualSense controller on the host.

DualSense-specific data is transported between the physical controller and the virtual controller instead of being translated into generic gamepad input.

This includes:

• Adaptive trigger feedback
• Native haptics
• Controller lighting
• Touchpad input
• Motion sensor data
• Controller speaker audio
• Microphone control and supported microphone audio

The result is essentially a complete DualSense connection transported through the Moonlight/Apollo stream.

Demo

The currently attached video shows the earlier Android setup using the optional USB Bluetooth HCI bridge.

A new video demonstrating direct Android Bluetooth pairing and adapter-free DualSense functionality is coming soon.

The latest testable release already includes the new direct wireless implementation.

Credits

Thanks to Idkiamaguy645 and the CloudPad-Android-Dualsense-Wireless project for demonstrating the Android wireless HID approach used by the new adapter-free DualSense connection.

Their existing implementation made adapter-free DualSense support in Artemis possible and much faster to integrate.

Yesterday it was working just fine, but it won't find it anymore

Hello, does anyone know how to fix faded colors on Android? 10-bit monitor, no HDR; I use Sunshine for streaming.

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

Hi all are these good numbers

I see a lot of people getting 0.2 -2ms latency

Not sure if I'm doing something wrong

Everything is set to default I think my bitrate is set to 50 mbs

Set up

Host

Ryzen 5950x

3080 Ti

Client steam machine

They are both connected to the same router via ethernet

Ax5400

Which is connected to IPS router via wan

This router manages all the devices on its own DHCP starting at 192.168.1.101

The other router it's connected to is the tp link ax1800 modem router that goes to the outside line/isp

The DHCP is turned off and only has the One wired client my main router Ax5400 connect to via the wan and to the ax5400 to Lan 1

It's 192.168.0.2 ip ( reservered )DMZ listed still gets port restriction cone NAT on test to the outside

I tried to put it in modem only mode and bridge it but couldn't get to work with my isp (sky) setting

I would have the ax1800 manage all the devices but read the ax5400 is the faster router

Note on the ax5400 I do have passive devices on the ax5300 sub net like ring door bells ,nest , Google home max device robo vacs ect CPU is usage is 10% memory is 42 % generally when not in use

Should I move all of them to the ax1800 and manage them

Would that help improve my speed

Currently the steam machine is about a meter away from the host directly connected to the ax5400 for testing I plan on moving to the living room 4k TV setup though where it will be connected to another router that is a wired extension on the same DHCP sub net any tips on how to get better stats or is this as good as it gets

Thanks in advance for any help

Pps the mother board on the host is asus x570 i running windows 10