# Sunshine + Moonlight Remote Gaming

Stream and play PC games remotely with near-zero latency using Sunshine (host) and Moonlight (client) on Clore.ai's GPU-powered servers.

{% hint style="info" %}
**Sunshine** is an open-source, self-hosted game streaming server with 20,000+ GitHub stars. **Moonlight** is the free, open-source client that connects to it. Together they rival GeForce NOW — at a fraction of the cost.
{% endhint %}

***

## What Is Sunshine + Moonlight?

**Sunshine** is a fork of the original Moonlight/GameStream stack, now fully independent and actively maintained by LizardByte. It captures your GPU output, encodes it in real-time using H.264/H.265/AV1, and streams it over the network with ultra-low latency.

**Moonlight** is the client app available for Windows, macOS, Linux, Android, iOS, Raspberry Pi, and even some smart TVs.

### Why Use It on Clore.ai?

* **Rent a high-end GPU** (RTX 4090, A100, etc.) at spot pricing
* **Stream AAA games** from the cloud to any device — even a cheap laptop
* **No GeForce NOW subscription** needed — you control the hardware
* **Game modding, AI-assisted gameplay**, or game development testing on powerful hardware

***

## Prerequisites

| Requirement      | Details                                   |
| ---------------- | ----------------------------------------- |
| Clore.ai account | With sufficient CLORE balance             |
| GPU server       | NVIDIA GPU (for NVENC encoding) preferred |
| Moonlight client | Installed on your local device            |
| SSH access       | For initial setup                         |

***

## Step 1: Rent a GPU Server on Clore.ai

1. Go to [clore.ai](https://clore.ai) → **Marketplace**
2. Filter by **GPU type**: RTX 3080 or better recommended for 1080p/60fps streaming
3. Look for servers with ports **22**, **47990**, and **48010** available
4. Select a server and proceed to order

{% hint style="warning" %}
**Port requirements**: Sunshine needs ports 47990 (HTTPS web UI) and 48010 (streaming). Make sure these are listed in the server's available ports before ordering.
{% endhint %}

### Recommended GPU for Streaming

| Resolution | Target FPS | Minimum GPU     |
| ---------- | ---------- | --------------- |
| 1080p      | 60 fps     | RTX 3060        |
| 1440p      | 60 fps     | RTX 3080        |
| 4K         | 60 fps     | RTX 3090 / 4080 |
| 1080p      | 120 fps    | RTX 4070+       |

***

## Step 2: Deploy Sunshine via Docker

### Docker Compose (Recommended)

Create a file `docker-compose.yml`:

```yaml
version: "3.8"

services:
  sunshine:
    image: lizardbyte/sunshine:latest
    container_name: sunshine
    restart: unless-stopped
    privileged: true
    network_mode: host
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=UTC
      - SUNSHINE_USERNAME=admin
      - SUNSHINE_PASSWORD=your_secure_password
    volumes:
      - ./sunshine-config:/config
      - /tmp/.X11-unix:/tmp/.X11-unix:rw
      - /dev/dri:/dev/dri
    devices:
      - /dev/dri:/dev/dri
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
```

### Start the Container

```bash
# Pull and start
docker compose up -d

# Check logs
docker compose logs -f sunshine

# Verify it's running
docker ps | grep sunshine
```

{% hint style="success" %}
**First boot**: Sunshine takes \~30 seconds to initialize. Watch the logs for "Sunshine started successfully" before proceeding.
{% endhint %}

### Single Docker Command (Quick Start)

```bash
docker run -d \
  --name sunshine \
  --restart unless-stopped \
  --privileged \
  --network host \
  -e SUNSHINE_USERNAME=admin \
  -e SUNSHINE_PASSWORD=changeme \
  -v $(pwd)/sunshine-config:/config \
  -v /tmp/.X11-unix:/tmp/.X11-unix \
  --device /dev/dri:/dev/dri \
  --gpus all \
  lizardbyte/sunshine:latest
```

***

## Step 3: Configure Sunshine Web UI

1. Open your browser and navigate to:

   ```
   https://<your-clore-server-ip>:47990
   ```
2. Accept the self-signed certificate warning
3. Log in with the credentials you set (`admin` / `your_secure_password`)

{% hint style="warning" %}
**HTTPS only**: Sunshine's web UI runs on HTTPS. Your browser will show a certificate warning — this is expected. Click "Advanced" → "Proceed" to continue.
{% endhint %}

### Web UI Sections

| Section           | Purpose                               |
| ----------------- | ------------------------------------- |
| **Pin**           | Pair with Moonlight client            |
| **Applications**  | Define streamable apps/games          |
| **Configuration** | Encoder, resolution, bitrate settings |
| **Logs**          | Debug streaming issues                |

***

## Step 4: Configure Encoding Settings

Navigate to **Configuration** → **Video** in the web UI:

### Recommended Settings for Clore.ai

```
# Encoder
encoder: nvenc          # Use NVIDIA hardware encoding

# Resolution
resolution_width: 1920
resolution_height: 1080

# Frame rate
fps: 60

# Bitrate
bitrate: 50000          # 50 Mbps for 1080p60 — excellent quality

# H.265 (better compression, use if client supports it)
codec: hevc
```

{% hint style="info" %}
**NVENC vs VAAPI**: On Clore.ai NVIDIA servers, always use `nvenc` encoder. It offloads encoding to the GPU hardware, freeing CPU for the game itself.
{% endhint %}

### Bitrate Guide

| Quality   | Resolution | Bitrate   |
| --------- | ---------- | --------- |
| Good      | 1080p60    | 20 Mbps   |
| Great     | 1080p60    | 35 Mbps   |
| Excellent | 1080p60    | 50 Mbps   |
| Great     | 1440p60    | 50 Mbps   |
| Excellent | 4K60       | 100+ Mbps |

***

## Step 5: Add Applications to Stream

In the Sunshine web UI → **Applications** → **Add New**:

### Example: Desktop Streaming

```
Name: Desktop
Command: (leave empty for full desktop)
Working Directory: /home/user
```

### Example: Steam Game

```
Name: Steam Big Picture
Command: steam -bigpicture
Working Directory: /home/user
Detach Command: (empty)
```

### Example: Custom Game

```
Name: My Game
Command: /opt/games/mygame/start.sh
Working Directory: /opt/games/mygame
Image: /opt/games/mygame/cover.png
```

***

## Step 6: Set Up Virtual Display (Headless Server)

Clore.ai servers are headless (no physical monitor). You need a virtual display:

```bash
# Install virtual display driver
apt-get update && apt-get install -y xvfb x11vnc xfce4

# Create virtual display
Xvfb :1 -screen 0 1920x1080x24 &
export DISPLAY=:1

# Start desktop environment
startxfce4 &
```

### Or Use a Virtual Framebuffer Script

```bash
#!/bin/bash
# start-display.sh

export DISPLAY=:1

# Start virtual display
Xvfb :1 -screen 0 1920x1080x24 -ac +extension GLX +render -noreset &
sleep 2

# Start window manager
openbox &
sleep 1

# Start Sunshine
docker compose up -d sunshine
```

Make it executable and run:

```bash
chmod +x start-display.sh
./start-display.sh
```

{% hint style="info" %}
**NVIDIA GPU with no display**: Add the following to your Sunshine config to use the GPU without a physical display:

```bash
export __GL_SYNC_TO_VBLANK=0
export __GL_GSYNC_ALLOWED=0
```

{% endhint %}

***

## Step 7: Connect with Moonlight Client

### Install Moonlight

| Platform     | Download                                                 |
| ------------ | -------------------------------------------------------- |
| Windows      | [moonlight-stream.org](https://moonlight-stream.org)     |
| macOS        | Mac App Store or moonlight-stream.org                    |
| Linux        | `flatpak install flathub com.moonlight_stream.Moonlight` |
| Android      | Google Play Store                                        |
| iOS          | App Store                                                |
| Raspberry Pi | `apt install moonlight-embedded`                         |

### Pair Moonlight with Sunshine

1. Open Moonlight on your local device
2. Click **Add PC** and enter your Clore.ai server IP
3. Moonlight will display a **PIN code**
4. Go to Sunshine Web UI → **Pin** → enter the PIN
5. Connection established! ✅

### Moonlight Settings for Best Experience

```
Resolution: 1920x1080
FPS: 60
Bitrate: 50 Mbps
Video codec: HEVC (H.265)
Hardware decoding: Enabled
Audio: Stereo
```

***

## Step 8: Port Forwarding Reference

| Port        | Protocol | Purpose                   |
| ----------- | -------- | ------------------------- |
| 22          | TCP      | SSH management            |
| 47984       | TCP      | HTTPS (GameStream compat) |
| 47989       | TCP      | HTTP (GameStream compat)  |
| 47990       | TCP      | HTTPS Web UI              |
| 48010       | TCP      | RTSP (streaming control)  |
| 47998-48000 | UDP      | Video/Audio streaming     |
| 48010       | UDP      | Video streaming           |

{% hint style="warning" %}
**Clore.ai port mapping**: When ordering your server, ensure ports 47990 and 48010 are in your port map. UDP ports for streaming (47998-48000) should also be available if possible.
{% endhint %}

***

## Troubleshooting

### Sunshine Won't Start

```bash
# Check container logs
docker logs sunshine --tail 50

# Common fix: permissions
chmod 777 /tmp/.X11-unix
xhost +local:docker
```

### Black Screen When Streaming

```bash
# Verify virtual display is running
export DISPLAY=:1
xdpyinfo | grep dimensions

# Restart display
pkill Xvfb
Xvfb :1 -screen 0 1920x1080x24 &
```

### High Latency

* Switch from **Wi-Fi to Ethernet** on client side
* Reduce bitrate in Moonlight settings
* Use **H.265** instead of H.264 (better compression at same quality)
* Enable **Frame Pacing** in Sunshine config

### NVENC Error: "No encoder found"

```bash
# Verify NVIDIA GPU is accessible
nvidia-smi

# Check container has GPU access
docker exec sunshine nvidia-smi

# If not, restart with --gpus all flag
docker stop sunshine && docker rm sunshine
# Re-run with --gpus all
```

### Authentication/Pairing Issues

```bash
# Reset Sunshine credentials
docker exec sunshine sunshine --creds admin newpassword

# Clear paired clients
rm -f ./sunshine-config/sunshine_state.json
docker restart sunshine
```

***

## Advanced Configuration

### Multi-Monitor Support

```yaml
# In Sunshine config (sunshine.conf)
[video]
adapter_name = /dev/dri/card0
output_name = HDMI-A-1
```

### Audio Over Network

Install PulseAudio virtual sink:

```bash
apt-get install -y pulseaudio
pulseaudio --daemon
pactl load-module module-null-sink sink_name=virtual_sink
export PULSE_SERVER=unix:/run/user/1000/pulse/native
```

### Game Controller Support

Sunshine supports virtual gamepad emulation. Enable in config:

```yaml
[input]
gamepad = enabled
ds4_back_as_touchpad_click = disabled
```

### Wake-on-LAN (for persistent servers)

```bash
# Keep server alive even when not streaming
docker update --restart=always sunshine
```

***

## Cost Optimization

### Calculate Your Streaming Cost

```
GPU rental: ~$0.30-0.80/hour (RTX 3080)
Storage: ~$0.01/hour (50GB SSD)
Total: ~$0.31-0.81/hour

vs GeForce NOW: $9.99-$19.99/month (limited hours)
vs Xbox Cloud Gaming: $14.99/month (limited catalog)
```

### Tips to Save Money

1. **Spot instances**: Use cheapest available GPU during off-peak hours
2. **Pause when not gaming**: Stop the container but keep the volume
3. **Pre-install games**: Use a persistent volume so you don't re-download each time
4. **Auto-shutdown**: Add a script to stop the server after inactivity

```bash
# Auto-shutdown after 30 min of no Moonlight connection
#!/bin/bash
while true; do
  connections=$(ss -tn | grep 47990 | wc -l)
  if [ "$connections" -eq 0 ]; then
    idle_count=$((idle_count + 1))
  else
    idle_count=0
  fi
  if [ "$idle_count" -ge 30 ]; then
    echo "No connections for 30 min, shutting down"
    docker stop sunshine
    break
  fi
  sleep 60
done
```

***

## Security Best Practices

{% hint style="danger" %}
**Never expose Sunshine without authentication!** Always set a strong password and consider using a VPN or SSH tunnel for additional security.
{% endhint %}

### SSH Tunnel Method (Most Secure)

```bash
# On your local machine, create SSH tunnel
ssh -L 47990:localhost:47990 \
    -L 48010:localhost:48010 \
    root@<clore-server-ip>

# Then connect Moonlight to localhost instead of the server IP
```

### Change Default Credentials

```bash
docker exec sunshine sunshine --creds admin 'Y0urStr0ngP@ssw0rd!'
```

### Restrict Access by IP

In Sunshine config:

```
allowed_ips = 192.168.1.0/24,203.0.113.5
```

***

## Performance Benchmarks

| GPU      | Resolution | FPS | Latency | Encoder   |
| -------- | ---------- | --- | ------- | --------- |
| RTX 3060 | 1080p      | 60  | \~15ms  | NVENC     |
| RTX 3080 | 1440p      | 60  | \~12ms  | NVENC     |
| RTX 4080 | 4K         | 60  | \~10ms  | NVENC AV1 |
| RTX 4090 | 4K         | 120 | \~8ms   | NVENC AV1 |

*Latency measured on 100 Mbps local network connection*

***

## Useful Links

* [Sunshine GitHub](https://github.com/LizardByte/Sunshine) — 20K+ stars
* [Moonlight Official Site](https://moonlight-stream.org)
* [Sunshine Documentation](https://docs.lizardbyte.dev/projects/sunshine)
* [LizardByte Discord](https://discord.gg/lizardbyte)
* [Clore.ai Marketplace](https://clore.ai)

***

## Summary

| Step | Action                                      |
| ---- | ------------------------------------------- |
| 1    | Rent GPU server with ports 22, 47990, 48010 |
| 2    | Deploy `lizardbyte/sunshine` via Docker     |
| 3    | Configure via web UI at `https://IP:47990`  |
| 4    | Set NVENC encoder, 50 Mbps bitrate          |
| 5    | Create virtual display (Xvfb)               |
| 6    | Install Moonlight client locally            |
| 7    | Pair using PIN code                         |
| 8    | Stream and game! 🎮                         |

With Sunshine + Moonlight on Clore.ai, you get a cloud gaming experience that rivals any commercial service — with full control over your hardware and games. No subscriptions, no restrictions, no limits.

***

## Clore.ai GPU Recommendations

| Use Case                  | Recommended GPU | Est. Cost on Clore.ai |
| ------------------------- | --------------- | --------------------- |
| 1080p/60fps Streaming     | RTX 3090 (24GB) | \~$0.12/gpu/hr        |
| 4K/High-refresh Streaming | RTX 4090 (24GB) | \~$0.70/gpu/hr        |
| AAA Gaming + Streaming    | RTX 4090 (24GB) | \~$0.70/gpu/hr        |

> 💡 All examples in this guide can be deployed on [Clore.ai](https://clore.ai/marketplace) GPU servers. Browse available GPUs and rent by the hour — no commitments, full root access.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/gaming-and-streaming/sunshine-moonlight.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.