# Sunshine + Moonlight रिमोट गेमिंग

Sunshine (होस्ट) और Moonlight (क्लाइंट) का उपयोग करके Clore.ai के GPU-संचालित सर्वरों पर निकट-शून्य विलंबता के साथ पीसी गेम्स को दूरस्थ रूप से स्ट्रीम और प्ले करें।

{% hint style="info" %}
**Sunshine** एक ओपन-सोर्स, स्वयं-होस्टेड गेम स्ट्रीमिंग सर्वर है जिसके GitHub पर 20,000+ स्टार हैं। **Moonlight** वह मुफ्त, ओपन-सोर्स क्लाइंट है जो इससे जुड़ता है। साथ मिलकर ये GeForce NOW के समकक्ष हैं — बहुत कम लागत पर।
{% endhint %}

***

## Sunshine + Moonlight क्या है?

**Sunshine** मूल Moonlight/GameStream स्टैक का एक फोर्क है, अब पूरी तरह स्वतंत्र और LizardByte द्वारा सक्रिय रूप से मेंटेन किया गया है। यह आपके GPU आउटपुट को कैप्चर करता है, वास्तविक समय में H.264/H.265/AV1 का उपयोग करके एन्कोड करता है, और अल्ट्रा-लो लेटेंसी के साथ नेटवर्क पर स्ट्रीम करता है।

**Moonlight** यह क्लाइंट ऐप है जो Windows, macOS, Linux, Android, iOS, Raspberry Pi और कुछ स्मार्ट टीवी पर उपलब्ध है।

### क्यों Clore.ai पर इसका उपयोग करें?

* **उच्च-स्तरीय GPU किराए पर लें** (RTX 4090, A100, आदि) स्पॉट प्राइसिंग पर
* **AAA गेम्स स्ट्रीम करें** क्लाउड से किसी भी डिवाइस पर — यहाँ तक कि एक सस्ती लैपटॉप पर भी
* **GeForce NOW सदस्यता की जरूरत नहीं** — आप हार्डवेयर को कंट्रोल करते हैं
* **गेम मॉडिंग, AI-सहायित गेमप्ले**, या शक्तिशाली हार्डवेयर पर गेम विकास का परीक्षण

***

## पूर्व-आवश्यकताएँ

| आवश्यकता          | विवरण                                                     |
| ----------------- | --------------------------------------------------------- |
| Clore.ai खाता     | पर्याप्त CLORE बैलेंस होने पर                             |
| GPU सर्वर         | NVIDIA GPU (NVENC एन्कोडिंग के लिए) प्राथमिकता दी जाती है |
| Moonlight क्लाइंट | आपके स्थानीय डिवाइस पर इंस्टॉल किया गया                   |
| SSH पहुंच         | प्रारम्भिक सेटअप के लिए                                   |

***

## चरण 1: Clore.ai पर एक GPU सर्वर किराए पर लें

1. जाएँ [clore.ai](https://clore.ai) → **मार्केटप्लेस**
2. फ़िल्टर करें **GPU प्रकार**: 1080p/60fps स्ट्रीमिंग के लिए RTX 3080 या बेहतर की सिफारिश की जाती है
3. ऐसे सर्वरों की तलाश करें जिनके पास पोर्ट **22**, **47990**और **48010** उपलब्ध हों
4. एक सर्वर चुनें और ऑर्डर करने के लिए आगे बढ़ें

{% hint style="warning" %}
**पोर्ट आवश्यकताएँ**: Sunshine को पोर्ट 47990 (HTTPS वेब UI) और 48010 (स्ट्रीमिंग) की आवश्यकता होती है। आदेश देने से पहले सुनिश्चित करें कि ये सर्वर के उपलब्ध पोर्ट सूची में हैं।
{% endhint %}

### स्ट्रीमिंग के लिए अनुशंसित GPU

| रिज़ॉल्यूशन | लक्षित FPS | न्यूनतम GPU     |
| ----------- | ---------- | --------------- |
| 1080p       | 60 fps     | सबसे उपयुक्त    |
| 1440p       | 60 fps     | RTX 3080        |
| 4K          | 60 fps     | RTX 3090 / 4080 |
| 1080p       | 120 fps    | RTX 4070+       |

***

## चरण 2: Docker के माध्यम से Sunshine डिप्लॉय करें

### Docker Compose (अनुशंसित)

एक फ़ाइल बनाएँ `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]
```

### कंटेनर शुरू करें

```bash
# पुल और स्टार्ट करें
docker compose up -d

# लॉग्स जांचें
docker compose logs -f sunshine

# सत्यापित करें कि यह चल रहा है
docker ps | grep sunshine
```

{% hint style="success" %}
**पहला बूट**: Sunshine को इनिशियलाइज़ होने में \~30 सेकंड लगते हैं। आगे बढ़ने से पहले लॉग में "Sunshine started successfully" देखें।
{% endhint %}

### सिंगल Docker कमांड (क्विक स्टार्ट)

```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
```

***

## चरण 3: Sunshine वेब UI कॉन्फ़िगर करें

1. अपने ब्राउज़र को खोलें और नेविगेट करें:

   ```
   https://<your-clore-server-ip>:47990
   ```
2. स्व-हस्ताक्षरित प्रमाणपत्र चेतावनी स्वीकार करें
3. आपके द्वारा सेट किए गए क्रेिडेंशियल्स के साथ लॉगिन करें (`admin` / `your_secure_password`)

{% hint style="warning" %}
**केवल HTTPS**: Sunshine का वेब UI HTTPS पर चलता है। आपका ब्राउज़र प्रमाणपत्र चेतावनी दिखाएगा — यह सामान्य है। जारी रखने के लिए "Advanced" → "Proceed" पर क्लिक करें।
{% endhint %}

### वेब UI सेक्शन

| सेक्शन           | उद्देश्य                                       |
| ---------------- | ---------------------------------------------- |
| **PIN**          | Moonlight क्लाइंट के साथ पेयर करें             |
| **एप्लिकेशन**    | स्ट्रीम करने योग्य ऐप्स/गेम्स को परिभाषित करें |
| **कॉन्फ़िगरेशन** | एन्कोडर, रेजोल्यूशन, बिटरेट सेटिंग्स           |
| **लॉग्स**        | स्ट्रीमिंग समस्याओं का डीबग करें               |

***

## चरण 4: एन्कोडिंग सेटिंग्स कॉन्फ़िगर करें

अपने ब्राउज़र में नेविगेट करें **कॉन्फ़िगरेशन** → **वीडियो** वेब UI में:

### Clore.ai के लिए अनुशंसित सेटिंग्स

```
# एन्कोडर
encoder: nvenc          # NVIDIA हार्डवेयर एन्कोडिंग का उपयोग करें

# रेजोल्यूशन
resolution_width: 1920
resolution_height: 1080

# फ्रेम रेट
fps: 60

# बिटरेट
bitrate: 50000          # 1080p60 के लिए 50 Mbps — उत्कृष्ट गुणवत्ता

# H.265 (बेहतर कंप्रेशन, यदि क्लाइंट समर्थन करता है तो उपयोग करें)
codec: hevc
```

{% hint style="info" %}
**NVENC बनाम VAAPI**: Clore.ai के NVIDIA सर्वरों पर, हमेशा उपयोग करें `nvenc` एन्कोडर। यह एन्कोडिंग को GPU हार्डवेयर पर ऑफलोड करता है, जिससे गेम के लिए CPU मुक्त रहता है।
{% endhint %}

### बिटरेट गाइड

| गुणवत्ता  | रिज़ॉल्यूशन | बिटरेट    |
| --------- | ----------- | --------- |
| अच्छा     | 1080p60     | 20 Mbps   |
| शानदार    | 1080p60     | 35 Mbps   |
| अत्युत्तम | 1080p60     | 50 Mbps   |
| शानदार    | 1440p60     | 50 Mbps   |
| अत्युत्तम | 4K60        | 100+ Mbps |

***

## चरण 5: स्ट्रीम में एप्लिकेशन जोड़ें

Sunshine वेब UI → में **एप्लिकेशन** → **Add New**:

### उदाहरण: डेस्कटॉप स्ट्रीमिंग

```
नाम: Desktop
कमांड: (पूर्ण डेस्कटॉप के लिए खाली छोड़ें)
वर्किंग डायरेक्टरी: /home/user
```

### उदाहरण: Steam गेम

```
नाम: Steam Big Picture
कमांड: steam -bigpicture
वर्किंग डायरेक्टरी: /home/user
Detach कमांड: (खाली)
```

### उदाहरण: कस्टम गेम

```
नाम: My Game
कमांड: /opt/games/mygame/start.sh
वर्किंग डायरेक्टरी: /opt/games/mygame
इमेज: /opt/games/mygame/cover.png
```

***

## चरण 6: वर्चुअल डिस्प्ले सेट करें (हेडलैस सर्वर)

Clore.ai सर्वर हेडलेस होते हैं (कोई भौतिक मॉनिटर नहीं)। आपको एक वर्चुअल डिस्प्ले की आवश्यकता है:

```bash
# वर्चुअल डिस्प्ले ड्राइवर इंस्टॉल करें
apt-get update && apt-get install -y xvfb x11vnc xfce4

# वर्चुअल डिस्प्ले बनाएं
Xvfb :1 -screen 0 1920x1080x24 &
export DISPLAY=:1

# डेस्कटॉप वातावरण शुरू करें
startxfce4 &
```

### या वर्चुअल फ्रेमबफर स्क्रिप्ट का उपयोग करें

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

export DISPLAY=:1

# वर्चुअल डिस्प्ले शुरू करें
Xvfb :1 -screen 0 1920x1080x24 -ac +extension GLX +render -noreset &
sleep 2

# विंडो मैनेजर शुरू करें
openbox &
sleep 1

# Sunshine शुरू करें
docker compose up -d sunshine
```

इसे निष्पादन योग्य बनाएं और चलाएँ:

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

{% hint style="info" %}
**NVIDIA GPU बिना डिस्प्ले के**: GPU को भौतिक डिस्प्ले के बिना उपयोग करने के लिए अपनी Sunshine कॉन्फ़िग में निम्न जोड़ें:

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

{% endhint %}

***

## चरण 7: Moonlight क्लाइंट से कनेक्ट करें

### Moonlight इंस्टॉल करें

| प्लेटफ़ॉर्म  | डाउनलोड                                                  |
| ------------ | -------------------------------------------------------- |
| Windows      | [moonlight-stream.org](https://moonlight-stream.org)     |
| macOS        | Mac App Store या moonlight-stream.org                    |
| Linux        | `flatpak install flathub com.moonlight_stream.Moonlight` |
| Android      | Google Play Store                                        |
| iOS          | App Store                                                |
| Raspberry Pi | `apt install moonlight-embedded`                         |

### Moonlight को Sunshine के साथ पेयर करें

1. अपने स्थानीय डिवाइस पर Moonlight खोलें
2. पर क्लिक करें **Add PC** और अपना Clore.ai सर्वर IP दर्ज करें
3. Moonlight एक प्रदर्शित करेगा **PIN कोड**
4. Sunshine वेब UI → पर जाएँ **PIN** → PIN दर्ज करें
5. कनेक्शन स्थापित! ✅

### बेहतरीन अनुभव के लिए Moonlight सेटिंग्स

```
रिज़ोल्यूशन: 1920x1080
FPS: 60
बिटरेट: 50 Mbps
वीडियो कोडेक: HEVC (H.265)
हार्डवेयर डिकोडिंग: सक्षम
ऑडियो: स्टेरियो
```

***

## चरण 8: पोर्ट फॉरवर्डिंग संदर्भ

| पोर्ट       | प्रोटोकॉल | उद्देश्य                    |
| ----------- | --------- | --------------------------- |
| 22          | TCP       | SSH प्रबंधन                 |
| 47984       | TCP       | HTTPS (GameStream अनुकूलता) |
| 47989       | TCP       | HTTP (GameStream अनुकूलता)  |
| 47990       | TCP       | HTTPS वेब UI                |
| 48010       | TCP       | RTSP (स्ट्रीमिंग कंट्रोल)   |
| 47998-48000 | UDP       | वीडियो/ऑडियो स्ट्रीमिंग     |
| 48010       | UDP       | वीडियो स्ट्रीमिंग           |

{% hint style="warning" %}
**Clore.ai पोर्ट मैपिंग**: अपने सर्वर का ऑर्डर करते समय सुनिश्चित करें कि पोर्ट 47990 और 48010 आपके पोर्ट मैप में हों। स्ट्रीमिंग के लिए UDP पोर्ट (47998-48000) भी संभव हो तो उपलब्ध होने चाहिए।
{% endhint %}

***

## समस्या निवारण

### Sunshine शुरू नहीं होगा

```bash
# कंटेनर लॉग्स जाँचें
docker logs sunshine --tail 50

# सामान्य फिक्स: परमिशन
chmod 777 /tmp/.X11-unix
xhost +local:docker
```

### स्ट्रीमिंग करते समय काली स्क्रीन

```bash
# सत्यापित करें कि वर्चुअल डिस्प्ले चल रहा है
export DISPLAY=:1
xdpyinfo | grep dimensions

# डिस्प्ले रीस्टार्ट करें
pkill Xvfb
Xvfb :1 -screen 0 1920x1080x24 &
```

### उच्च विलंबता

* से स्विच करें **क्लाइंट साइड पर Wi-Fi से Ethernet पर** क्लाइंट साइड पर
* Moonlight सेटिंग्स में बिटरेट घटाएँ
* उपयोग करें **H.265** की बजाय H.264 (एक ही गुणवत्ता पर बेहतर कंप्रेशन)
* सक्षम करें **फ्रेम पेसिंग** Sunshine कॉन्फ़िग में

### NVENC त्रुटि: "कोई एन्कोडर नहीं मिला"

```bash
# सत्यापित करें कि NVIDIA GPU पहुंच योग्य है
nvidia-smi

# जाँचें कि कंटेनर को GPU एक्सेस है
docker exec sunshine nvidia-smi

# यदि नहीं, तो --gpus all फ़्लैग के साथ पुनः शुरू करें
docker stop sunshine && docker rm sunshine
# --gpus all के साथ फिर से चलाएँ
```

### प्रमाणीकरण/पेयरिंग समस्याएँ

```bash
# Sunshine क्रेिडेंशियल्स रीसेट करें
docker exec sunshine sunshine --creds admin newpassword

# पेयर्ड क्लाइंट्स साफ़ करें
rm -f ./sunshine-config/sunshine_state.json
docker restart sunshine
```

***

## उन्नत कॉन्फ़िगरेशन

### मल्टी-मॉनिटर समर्थन

```yaml
# Sunshine कॉन्फ़िग (sunshine.conf) में
[video]
adapter_name = /dev/dri/card0
output_name = HDMI-A-1
```

### नेटवर्क पर ऑडियो

PulseAudio वर्चुअल सिंग्क इंस्टॉल करें:

```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
```

### गेम कंट्रोलर समर्थन

Sunshine वर्चुअल गेमपैड इम्युलेशन का समर्थन करता है। कॉन्फ़िग में सक्षम करें:

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

### Wake-on-LAN (स्थायी सर्वरों के लिए)

```bash
# स्ट्रीमिंग नहीं होने पर भी सर्वर को जीवित रखें
docker update --restart=always sunshine
```

***

## लागत अनुकूलन

### अपनी स्ट्रीमिंग लागत की गणना करें

```
GPU किराया: ~$0.30-0.80/घंटा (RTX 3080)
स्टोरेज: ~$0.01/घंटा (50GB SSD)
कुल: ~$0.31-0.81/घंटा

vs GeForce NOW: $9.99-$19.99/माह (सीमित घंटे)
vs Xbox Cloud Gaming: $14.99/माह (सीमित सूची)
```

### पैसे बचाने के सुझाव

1. **स्पॉट इंस्टेंस**: ऑफ-पीक घंटों में सबसे सस्ता उपलब्ध GPU उपयोग करें
2. **जब गेम न खेल रहे हों तो पॉज़ करें**: कंटेनर रोकें लेकिन वॉल्यूम को रखें
3. **गेम्स प्री-इंस्टॉल करें**: एक स्थायी वॉल्यूम का उपयोग करें ताकि हर बार फिर से डाउनलोड न करना पड़े
4. **ऑटो-शटडाउन**: निष्क्रियता के बाद सर्वर को बंद करने के लिए स्क्रिप्ट जोड़ें

```bash
# Moonlight कनेक्शन न होने पर 30 मिनट के बाद ऑटो-शटडाउन
#!/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 "30 मिनट के लिए कोई कनेक्शन नहीं, शटडाउन कर रहा है"
    docker stop sunshine
    break
  fi
  sleep 60
done
```

***

## सुरक्षा सर्वोत्तम प्रथाएँ

{% hint style="danger" %}
**Sunshine को बिना प्रमाणीकरण के कभी एक्सपोज़ न करें!** हमेशा एक मजबूत पासवर्ड सेट करें और अतिरिक्त सुरक्षा के लिए VPN या SSH टनल का उपयोग करने पर विचार करें।
{% endhint %}

### SSH टनल विधि (सबसे सुरक्षित)

```bash
# अपने स्थानीय मशीन पर SSH टनल बनाएं
ssh -L 47990:localhost:47990 \
    -L 48010:localhost:48010 \
    root@<clore-server-ip>

# फिर Moonlight को सर्वर IP की बजाय localhost से कनेक्ट करें
```

### डिफ़ॉल्ट क्रेिडेंशियल्स बदलें

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

### IP द्वारा पहुँच प्रतिबंधित करें

Sunshine कॉन्फ़िग में:

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

***

## प्रदर्शन बेंचमार्क्स

| GPU          | रिज़ॉल्यूशन | FPS | लेटेंसी | एन्कोडर   |
| ------------ | ----------- | --- | ------- | --------- |
| सबसे उपयुक्त | 1080p       | 60  | \~15ms  | NVENC     |
| RTX 3080     | 1440p       | 60  | \~12ms  | NVENC     |
| RTX 4080     | 4K          | 60  | \~10ms  | NVENC AV1 |
| RTX 4090     | 4K          | 120 | \~8ms   | NVENC AV1 |

*लेटेंसी 100 Mbps लोकल नेटवर्क कनेक्शन पर मापी गई है*

***

## उपयोगी लिंक

* [Sunshine GitHub](https://github.com/LizardByte/Sunshine) — 20K+ स्टार
* [Moonlight आधिकारिक साइट](https://moonlight-stream.org)
* [Sunshine दस्तावेज़](https://docs.lizardbyte.dev/projects/sunshine)
* [LizardByte Discord](https://discord.gg/lizardbyte)
* [Clore.ai मार्केटप्लेस](https://clore.ai)

***

## सारांश

| कदम | क्रिया                                                 |
| --- | ------------------------------------------------------ |
| 1   | पोर्ट 22, 47990, 48010 के साथ GPU सर्वर किराए पर लें   |
| 2   | डिप्लॉय करें `lizardbyte/sunshine` Docker के माध्यम से |
| 3   | वेब UI पर कॉन्फ़िगर करें यहाँ: `https://IP:47990`      |
| 4   | NVENC एन्कोडर सेट करें, 50 Mbps बिटरेट                 |
| 5   | वर्चुअल डिस्प्ले बनाएं (Xvfb)                          |
| 6   | स्थानीय रूप से Moonlight क्लाइंट इंस्टॉल करें          |
| 7   | PIN कोड का उपयोग करके पेयर करें                        |
| 8   | स्ट्रीम और गेमिंग शुरू करें! 🎮                        |

Clore.ai पर Sunshine + Moonlight के साथ, आपको कोई भी वाणिज्यिक सेवा जैसी क्लाउड गेमिंग अनुभव मिलता है — अपने हार्डवेयर और गेम्स पर पूर्ण नियंत्रण के साथ। कोई सदस्यता नहीं, कोई प्रतिबंध नहीं, कोई सीमा नहीं।

***

## Clore.ai GPU सिफारिशें

| उपयोग केस                 | सिफारिश की गई GPU | Clore.ai पर अनुमानित लागत |
| ------------------------- | ----------------- | ------------------------- |
| 1080p/60fps स्ट्रीमिंग    | RTX 3090 (24GB)   | \~$0.12/gpu/hr            |
| 4K/हाई-रिफ्रेश स्ट्रीमिंग | RTX 4090 (24GB)   | \~$0.70/gpu/hr            |
| AAA गेमिंग + स्ट्रीमिंग   | RTX 4090 (24GB)   | \~$0.70/gpu/hr            |

> 💡 इस गाइड के सभी उदाहरण तैनात किए जा सकते हैं [Clore.ai](https://clore.ai/marketplace) GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।