A practical setup and troubleshooting guide for streaming PC games with Apollo on Windows and Artemis on Android / Google TV, based on the setup I actually use.
| Component | Setup |
|---|---|
| Host | Windows gaming PC |
| GPU | NVIDIA GeForce GTX 1650 Super 4 GB |
| RAM | 32 GB |
| Streaming host | Apollo |
| Main client | TCL C6K 55" Google TV / Android TV |
| Client app | Artemis |
| Network | Home LAN on an SLT Fiber router/network |
| Goal | Smooth low-latency couch gaming from PC to TV |
This README focuses on real setup, tuning, and troubleshooting, especially the case where the PC is fast enough but the TV/client still does not feel perfectly smooth.
Apollo and Artemis are not completely separate ideas from the better-known Sunshine + Moonlight stack. They are forks/derived projects from that ecosystem:
| Original project | Fork / derived project | Role |
|---|---|---|
| Sunshine | Apollo | PC game-streaming host |
| Moonlight Android | Artemis | Android / Android TV streaming client |
Apollo is a fork/derivative of Sunshine. It keeps the same general job — running on the gaming PC and streaming the desktop/games to compatible clients — while adding its own features such as integrated SudoVDA virtual displays, per-client permissions, clipboard sync, client-specific display identities, and tighter Artemis integration.
Artemis is a fork/derivative of Moonlight Android and was previously known as Moonlight Noir. It can connect to Apollo or Sunshine, but Apollo + Artemis are designed to work especially well together, including Apollo virtual-display and server-command integrations.
So the relationship is roughly:
Sunshine ──fork/derived──> Apollo
│ │
│ host │ host + extra Apollo features
│ │
Moonlight Android ─fork/derived─> Artemis
client client + Apollo integration
If you already understand Sunshine + Moonlight, you can think of Apollo + Artemis as an alternative forked stack built from the same open-source ecosystem, with extra features and tighter integration between the host and Android client.
Useful Apollo + Artemis features include:
- low-latency local game streaming;
- hardware video encoding;
- custom resolutions and bitrates;
- per-client permissions;
- keyboard/mouse/controller input;
- clipboard integration;
- Apollo virtual-display integration;
- client-specific display identity;
- automatic resolution/refresh-rate matching;
- HDR on compatible host/client combinations.
Apollo uses SudoVDA for its Windows virtual display.
┌──────────────────────────────────────┐
│ Windows Gaming PC │
│ │
│ Game → GPU Render → NVENC → Apollo │
│ │ │
│ SudoVDA │
└───────────────────────────┬──────────┘
│
Local network
│
┌───────────────────────────▼──────────┐
│ TCL C6K 55" Google TV │
│ │
│ Artemis │
│ ↓ │
│ Hardware video decoder │
│ ↓ │
│ TV display + audio │
└──────────────────────────────────────┘
For local streaming, the important part is the LAN path between host, router/AP, and client. Your Internet download speed is not the main factor.
- Requirements
- Install Apollo
- Open the Apollo Web UI
- SudoVDA / virtual display
- Install Artemis
- Pair Artemis with Apollo
- Client permissions
- Add Desktop and games
- Recommended settings for GTX 1650 Super
- Recommended TCL C6K settings
- Bitrate guide
- Codec guide
- Controller setup
- Latency tuning
- Fixing stutter / rough motion
- Virtual-display problems
- Black screen / game launch problems
- Network troubleshooting
- My baseline configuration
- Credits
- Windows 10/11
- Apollo
- supported NVIDIA / AMD / Intel encoder
- recent GPU driver
- local network connection
- Ethernet strongly recommended for the host
Windows PC
├── NVIDIA GTX 1650 Super 4 GB
├── 32 GB RAM
└── Apollo
The GTX 1650 Super provides hardware H.264 and HEVC encoding through NVENC, which makes it a good fit for this type of streaming.
My main client:
TCL C6K 55"
└── Google TV / Android TV
└── Artemis
Artemis can also be used on Android phones and tablets.
Best:
PC ── Ethernet ── Router/Switch ── Ethernet ── TV
Also good:
PC ── Ethernet ── Router/AP ── 5 GHz/6 GHz Wi-Fi ── TV
More difficult to keep consistent:
PC ── Wi-Fi ── Router/AP ── Wi-Fi ── TV
Every wireless hop can add jitter, interference, retransmissions, or latency variation.
Official repository:
https://github.com/ClassicOldSong/Apollo
Releases:
https://github.com/ClassicOldSong/Apollo/releases
On Windows you can also install the community-maintained WinGet package:
winget install ClassicOldSong.ApolloAfter installation, launch Apollo.
Allow it through Windows Firewall on the network profile you actually use.
Apollo normally exposes its local configuration page at:
https://localhost:47990
You may see a local HTTPS certificate warning in the browser.
From another device on the LAN, the address is normally:
https://HOST-PC-IP:47990
provided Apollo's Web UI access setting and the firewall allow LAN access.
Apollo's Windows virtual-display integration uses SudoVDA.
When working correctly, the flow is:
Artemis requests a stream
↓
Apollo creates/configures virtual display
↓
Windows sees a client-specific monitor
↓
Resolution / refresh rate match client request
↓
Game renders to that display
The display normally appears when the stream starts and disappears when it ends.
Check that the SudoVDA driver is installed and that Apollo has been restarted after installation.
Apollo's own FAQ points to SudoVDA first when no virtual display is created.
Apollo's documentation recommends removing unrelated virtual-display solutions when debugging because several virtual adapters can cause confusing monitor-selection behaviour.
Press:
Win + P
Choose:
Extend
Then close the streamed app/session and reconnect.
Windows usually remembers the display identity afterward.
Upstream Artemis Android repository:
https://github.com/ClassicOldSong/moonlight-android
Artemis was previously known as Moonlight Noir.
Install the current APK on the Android/Google TV device.
For Android TV, common options are:
- project release APK;
- ADB sideload;
- transferring the APK to the TV and installing it locally.
Open Artemis after installation.
Put the PC and TV on the same LAN.
Artemis should normally discover Apollo automatically.
If not, manually add the host PC's local IPv4 address.
Example:
192.168.1.50
Select the PC in Artemis.
Artemis displays a PIN.
Complete the pairing request through Apollo.
Apollo supports per-client permissions.
If the TV can see the host but cannot launch games or send input, check the permissions assigned to that Artemis client.
Relevant permissions can include:
- View Streams
- List Apps
- Launch Apps
- Mouse Input
- Keyboard Input
- controller/input permissions
The first paired client can have broader default access than later paired clients.
A Permission Denied message is therefore not automatically a network problem.
In Apollo's Web UI, add the apps you want to expose.
Useful first entries:
- Desktop
- Steam
- individual games
- other launchers if required
Desktop is the easiest diagnostic target.
If Desktop streams correctly but one game fails, then:
Apollo + network + Artemis
= probably working
and the problem is more likely game/display/launcher specific.
My GPU:
NVIDIA GeForce GTX 1650 Super 4 GB
Start with:
HEVC / H.265
Fallback:
H.264
The GTX 1650 Super is not an AV1 hardware-encode GPU, so AV1 is not the target for this host.
1920×1080 @ 60 FPS
Once stable:
2560×1440 @ 60 FPS
Only then test:
3840×2160 @ 60 FPS
A stable 60 FPS stream usually feels better than forcing 4K while the client decoder or LAN is struggling.
My client is the built-in Google TV platform on a TCL C6K 55".
The TV panel can support high refresh rates, but game-stream smoothness also depends on the TV's:
- MediaTek/TV SoC;
- hardware decoder;
- Android/Google TV overhead;
- Artemis frame pacing;
- picture processing;
- network interface.
So the TV can become the bottleneck even when the gaming PC has no problem rendering the game.
Resolution: 1920×1080
FPS: 60
Codec: HEVC
Bitrate: 20–35 Mbps
HDR: Off
If perfectly smooth:
Resolution: 2560×1440
FPS: 60
Codec: HEVC
Bitrate: 35–55 Mbps
Then try:
Resolution: 3840×2160
FPS: 60
Codec: HEVC
Bitrate: 50–80 Mbps
These are tuning ranges, not hard requirements.
Use Game Mode / low-latency mode when available.
While tuning, reduce or disable heavy post-processing such as:
- motion interpolation;
- noise reduction;
- excessive sharpening;
- cinema motion processing.
Those can add latency or make streamed motion feel inconsistent.
| Resolution | FPS | Good starting range |
|---|---|---|
| 720p | 60 | 10–20 Mbps |
| 1080p | 60 | 20–35 Mbps |
| 1440p | 60 | 35–55 Mbps |
| 4K | 60 | 50–80 Mbps |
Higher is not automatically better.
An unnecessarily high bitrate can increase:
- Wi-Fi retransmissions;
- decoder pressure;
- buffer bursts;
- latency spikes;
- visible stutter.
First make the stream stable. Then increase quality.
My preferred first choice.
Advantages:
- better compression than H.264;
- useful for 1440p/4K;
- good quality at lower bitrate.
If the TV's HEVC decoder path behaves badly, switch to H.264 as a test.
Use H.264 when:
- HEVC stutters;
- decode latency looks high;
- compatibility matters more than efficiency;
- you want a clean troubleshooting baseline.
If H.264 is smooth and HEVC is not, that strongly points toward the client decode path/configuration rather than raw PC performance.
AV1 is useful on newer supported GPUs, but the GTX 1650 Super does not provide modern AV1 hardware encoding.
Use the codec that your host can encode and client can decode consistently at low latency, not simply the newest codec.
Typical path:
Controller
↓
TCL / Android TV
↓
Artemis
↓
LAN
↓
Apollo
↓
Windows game
Connect the controller to the TV/client.
Then test:
- Android TV navigation;
- Artemis navigation;
- Desktop stream;
- game input;
- analog sticks/triggers.
If Android sees the controller but Windows does not, check Apollo client/input permissions.
Bluetooth is convenient. USB/wired input can be useful when diagnosing inconsistent input latency.
End-to-end latency is roughly:
controller/input
+ client-to-host network
+ game render
+ host encode
+ host-to-client network
+ client decode
+ TV display processing
Best improvements:
- Wire the host PC with Ethernet.
- Use Ethernet for the TV if that interface performs well.
- Otherwise use strong 5 GHz/6 GHz Wi-Fi.
- Enable TV Game Mode.
- Keep game FPS stable.
- Avoid excessive bitrate.
- Use hardware encoding.
- Disable unnecessary image processing.
- Pause large LAN downloads while testing.
This is the main real-world issue I investigated with my TCL C6K.
If the game looks smooth on the PC but the TV feels less smooth, the bottleneck can be anywhere here:
Game render
↓
NVENC encode
↓
LAN
↓
TV hardware decode
↓
Artemis/frame pacing
↓
TV processing/panel
Change one thing at a time.
4K60 → 1080p60
If 1080p becomes smooth, the higher-resolution decode/network path is likely part of the problem.
Example:
80 Mbps → 30 Mbps
If that helps, inspect the LAN and client decode path before increasing bitrate again.
HEVC → H.264
If H.264 is smooth, investigate HEVC decode performance/settings on the TV.
Get SDR stable first.
HDR introduces additional variables including 10-bit video and display-mode switching.
Enable Artemis's performance/statistics overlay when available.
Watch:
- FPS;
- network latency;
- packet loss;
- decode time;
- dropped frames.
High decode time suggests the client.
Network spikes suggest the LAN.
If the exact same Apollo host is smooth on another Android device but not on the TCL, the TV/client path is the likely bottleneck.
This is why a stronger external Android/Fire TV-class streaming device can sometimes outperform a television's built-in smart-TV hardware.
Check:
- SudoVDA installed;
- Apollo restarted;
- Apollo logs;
- competing virtual-display drivers.
Quit Apollo completely.
For stuck display state, Apollo maintainers have recommended removing:
Apollo install directory/
└── config/
└── display_device.state
Then start Apollo again.
Use this only when troubleshooting display-state problems.
Win + P
→ Extend
Then reconnect.
In Apollo, inspect:
Audio/Video
→ Advanced Display Device Options
Apollo includes a mode that can activate the virtual display and make it primary for the session.
Exact wording can change between versions, so use the description shown in your installed build.
If Artemis connects but the picture is black:
- test Desktop;
- confirm Windows sees the virtual display;
- inspect Apollo logs;
- try H.264;
- disable HDR;
- try 1080p60;
- update the GPU driver;
- disable third-party overlays temporarily;
- test borderless fullscreen.
Borderless fullscreen is often easier to diagnose than exclusive fullscreen.
Check:
- game monitor selection;
- Windows primary display;
- Apollo display-device configuration;
- remembered game resolution;
- HDR state;
- launcher behaviour;
- capture restrictions/anti-cheat.
On Windows:
ipconfigLook at the active Ethernet/Wi-Fi adapter.
Example:
192.168.1.x
From another LAN computer/device:
ping 192.168.1.xLook for:
- low latency;
- consistent latency;
- no packet loss.
Consistency matters more than one unusually low result.
Prefer:
- 5 GHz / 6 GHz;
- strong signal;
- uncongested channel;
- client reasonably close to router/AP.
Avoid testing while:
- another device is saturating Wi-Fi;
- large downloads are running;
- the TV has weak signal;
- both host and client are on poor Wi-Fi.
For my current setup, I start here:
HOST
Windows PC
GTX 1650 Super 4 GB
32 GB RAM
Apollo
NVENC hardware encoding
CLIENT
TCL C6K 55"
Google TV / Android TV
Artemis
TV Game Mode enabled
STREAM
1920×1080
60 FPS
HEVC
20–35 Mbps
HDR off
NETWORK
Host wired where possible
Client wired or strong 5 GHz Wi-Fi
Then increase one variable at a time:
1080p60
↓
1440p60
↓
higher bitrate
↓
4K60
↓
HDR
This makes it much easier to identify the exact point where smoothness gets worse.
| Symptom | First test |
|---|---|
| Random stutter | Lower bitrate |
| Consistently rough motion | Check decode time/frame pacing |
| High input latency | Game Mode + network |
| Black screen | Desktop + display selection |
| HEVC bad / H.264 good | Client HEVC path |
| 1080p good / 4K bad | Client/network load |
| Controller missing | Apollo input permissions |
| No virtual display | SudoVDA |
| Mirrored display | Win + P → Extend |
| Cannot launch app | Launch Apps permission |
| TV bad / another client good | TV SoC/decoder path |
- Repository: https://github.com/ClassicOldSong/Apollo
- Releases: https://github.com/ClassicOldSong/Apollo/releases
- Wiki: https://github.com/ClassicOldSong/Apollo/wiki
-
Sunshine — https://github.com/LizardByte/Sunshine
Apollo was created as a fork/derivative of Sunshine. -
Moonlight Android — https://github.com/moonlight-stream/moonlight-android
Artemis is a fork/derivative of Moonlight Android and was previously called Moonlight Noir. -
Moonlight project — https://github.com/moonlight-stream
Apollo's own documentation currently points users to Sunshine documentation for some shared concepts, which is another reason Sunshine knowledge is useful when configuring Apollo.
All software belongs to its respective authors and contributors.
This repository is only a user-written setup/troubleshooting guide.
Useful performance reports should include:
Host GPU:
Host OS:
Apollo version:
Client:
Artemis version:
Ethernet/Wi-Fi:
Resolution:
FPS:
Codec:
Bitrate:
HDR:
Network latency:
Decode time:
Problem:
- Apollo installed
- Web UI opens
- SudoVDA installed
- Hardware encoder detected
- Desktop entry works
- Games added
- Firewall allows Apollo
- Artemis installed
- Host discovered/added
- Pairing complete
- Permissions correct
- Controller works
- Performance overlay tested
- 1080p60 tested first
- HEVC tested
- H.264 tested as fallback
- Bitrate tuned
- Game Mode enabled
- SDR stable before HDR
- Higher resolutions tested incrementally
Maintained by ish4ra
If this guide helped you, consider starring the repository.