# Juego remoto Sunshine + Moonlight

Transmite y juega juegos de PC de forma remota con latencia casi nula usando Sunshine (host) y Moonlight (cliente) en los servidores con GPU de Clore.ai.

{% hint style="info" %}
**Sunshine** es un servidor de transmisión de juegos de código abierto y autohospedado con más de 20.000 estrellas en GitHub. **Moonlight** es el cliente gratuito y de código abierto que se conecta a él. Juntos rivalizan con GeForce NOW, pero a una fracción del coste.
{% endhint %}

***

## ¿Qué son Sunshine y Moonlight?

**Sunshine** es un fork de la pila original Moonlight/GameStream, ahora totalmente independiente y mantenido activamente por LizardByte. Captura la salida de tu GPU, la codifica en tiempo real usando H.264/H.265/AV1 y la transmite por la red con latencia ultrabaja.

**Moonlight** es la aplicación cliente disponible para Windows, macOS, Linux, Android, iOS, Raspberry Pi e incluso algunas smart TVs.

### ¿Por qué usarlo en Clore.ai?

* **Alquila una GPU de alto rendimiento** (RTX 4090, A100, etc.) a precio spot
* **Transmite juegos AAA** desde la nube a cualquier dispositivo, incluso un portátil económico
* **No se necesita suscripción a GeForce NOW** — tú controlas el hardware
* **Modificación de juegos, juego asistido por IA**, o pruebas de desarrollo de juegos en hardware potente

***

## Prerrequisitos

| Requisito          | Detalles                                        |
| ------------------ | ----------------------------------------------- |
| Cuenta de Clore.ai | Con saldo de CLORE suficiente                   |
| servidor GPU       | GPU NVIDIA (preferible para codificación NVENC) |
| Cliente Moonlight  | Instalado en tu dispositivo local               |
| Acceso SSH         | Para la configuración inicial                   |

***

## Paso 1: Alquila un servidor con GPU en Clore.ai

1. Ve a [clore.ai](https://clore.ai) → **Marketplace**
2. Filtrar por **Tipo de GPU**: Se recomienda RTX 3080 o mejor para streaming a 1080p/60fps
3. Busca servidores con puertos **22**, **47990**, y **48010** disponibles
4. Selecciona un servidor y procede a ordenar

{% hint style="warning" %}
**Requisitos de puertos**: Sunshine necesita los puertos 47990 (interfaz web HTTPS) y 48010 (streaming). Asegúrate de que estén listados en los puertos disponibles del servidor antes de ordenar.
{% endhint %}

### GPU recomendada para streaming

| Resolución | FPS objetivo | GPU mínima      |
| ---------- | ------------ | --------------- |
| 1080p      | 60 fps       | RTX 3060        |
| 1440p      | 60 fps       | RTX 3080        |
| 4K         | 60 fps       | RTX 3090 / 4080 |
| 1080p      | 120 fps      | RTX 4070+       |

***

## Paso 2: Desplegar Sunshine vía Docker

### Docker Compose (recomendado)

Crea un archivo `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]
```

### Inicia el contenedor

```bash
# Descargar e iniciar
docker compose up -d

# Comprobar logs
docker compose logs -f sunshine

# Verificar que esté en ejecución
docker ps | grep sunshine
```

{% hint style="success" %}
**Primer arranque**: Sunshine tarda \~30 segundos en inicializarse. Observa los logs hasta ver "Sunshine started successfully" antes de continuar.
{% endhint %}

### Comando Docker único (Inicio rápido)

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

***

## Paso 3: Configurar la interfaz web de Sunshine

1. Abra su navegador y navegue a:

   ```
   https://<tu-ip-servidor-clore>:47990
   ```
2. Acepta la advertencia del certificado autofirmado
3. Inicia sesión con las credenciales que configuraste (`admin` / `your_secure_password`)

{% hint style="warning" %}
**Solo HTTPS**: La interfaz web de Sunshine se ejecuta en HTTPS. Tu navegador mostrará una advertencia de certificado — esto es esperado. Haz clic en "Avanzado" → "Continuar" para seguir.
{% endhint %}

### Secciones de la interfaz web

| Sección           | Propósito                                           |
| ----------------- | --------------------------------------------------- |
| **Pin**           | Emparejar con el cliente Moonlight                  |
| **Aplicaciones**  | Define aplicaciones/juegos que se puedan transmitir |
| **Configuración** | Codificador, resolución, ajustes de bitrate         |
| **Registros**     | Depurar problemas de streaming                      |

***

## Paso 4: Configurar ajustes de codificación

Navegue a **Configuración** → **Vídeo** en la interfaz web:

### Ajustes recomendados para Clore.ai

```
# Codificador
encoder: nvenc          # Usar codificación por hardware NVIDIA

# Resolución
resolution_width: 1920
resolution_height: 1080

# Tasa de frames
fps: 60

# Bitrate
bitrate: 50000          # 50 Mbps para 1080p60 — excelente calidad

# H.265 (mejor compresión, úsalo si el cliente lo soporta)
codec: hevc
```

{% hint style="info" %}
**NVENC vs VAAPI**: En los servidores NVIDIA de Clore.ai, siempre usa `nvenc` encoder. Delegará la codificación al hardware GPU, liberando la CPU para el propio juego.
{% endhint %}

### Guía de bitrate

| Calidad   | Resolución | Bitrate   |
| --------- | ---------- | --------- |
| Bueno     | 1080p60    | 20 Mbps   |
| Excelente | 1080p60    | 35 Mbps   |
| Excelente | 1080p60    | 50 Mbps   |
| Excelente | 1440p60    | 50 Mbps   |
| Excelente | 4K60       | 100+ Mbps |

***

## Paso 5: Añadir aplicaciones para transmitir

En la interfaz web de Sunshine → **Aplicaciones** → **Añadir nuevo**:

### Ejemplo: Transmisión del escritorio

```
Nombre: Desktop
Comando: (dejar vacío para escritorio completo)
Directorio de trabajo: /home/user
```

### Ejemplo: Juego de Steam

```
Nombre: Steam Big Picture
Comando: steam -bigpicture
Directorio de trabajo: /home/user
Comando de desanexar: (vacío)
```

### Ejemplo: Juego personalizado

```
Nombre: My Game
Comando: /opt/games/mygame/start.sh
Directorio de trabajo: /opt/games/mygame
Imagen: /opt/games/mygame/cover.png
```

***

## Paso 6: Configurar pantalla virtual (servidor sin cabeza)

Los servidores de Clore.ai son headless (sin monitor físico). Necesitas una pantalla virtual:

```bash
# Instalar controlador de pantalla virtual
apt-get update && apt-get install -y xvfb x11vnc xfce4

# Crear pantalla virtual
Xvfb :1 -screen 0 1920x1080x24 &
export DISPLAY=:1

# Iniciar entorno de escritorio
startxfce4 &
```

### O usa un script de framebuffer virtual

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

export DISPLAY=:1

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

# Iniciar gestor de ventanas
openbox &
sleep 1

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

Hazlo ejecutable y ejecútalo:

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

{% hint style="info" %}
**GPU NVIDIA sin pantalla**: Añade lo siguiente a tu configuración de Sunshine para usar la GPU sin un display físico:

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

{% endhint %}

***

## Paso 7: Conectar con el cliente Moonlight

### Instala Moonlight

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

### Emparejar Moonlight con Sunshine

1. Abre Moonlight en tu dispositivo local
2. Haz clic **Añadir PC** e ingresa la IP de tu servidor Clore.ai
3. Moonlight mostrará un **código PIN**
4. Ve a la interfaz web de Sunshine → **Pin** → ingresa el PIN
5. ¡Conexión establecida! ✅

### Ajustes de Moonlight para la mejor experiencia

```
Resolución: 1920x1080
FPS: 60
Bitrate: 50 Mbps
Códec de vídeo: HEVC (H.265)
Decodificación por hardware: Habilitada
Audio: Estéreo
```

***

## Paso 8: Referencia de reenvío de puertos

| Puerto      | Protocolo | Propósito                         |
| ----------- | --------- | --------------------------------- |
| 22          | TCP       | Gestión SSH                       |
| 47984       | TCP       | HTTPS (compatibilidad GameStream) |
| 47989       | TCP       | HTTP (compatibilidad GameStream)  |
| 47990       | TCP       | Interfaz web HTTPS                |
| 48010       | TCP       | RTSP (control de streaming)       |
| 47998-48000 | UDP       | Transmisión de vídeo/audio        |
| 48010       | UDP       | Transmisión de vídeo              |

{% hint style="warning" %}
**Asignación de puertos en Clore.ai**: Al ordenar tu servidor, asegúrate de que los puertos 47990 y 48010 estén en tu mapa de puertos. Si es posible, los puertos UDP para streaming (47998-48000) también deberían estar disponibles.
{% endhint %}

***

## Solución de problemas

### Sunshine no arranca

```bash
# Verificar logs del contenedor
docker logs sunshine --tail 50

# Solución común: permisos
chmod 777 /tmp/.X11-unix
xhost +local:docker
```

### Pantalla negra al transmitir

```bash
# Verificar que la pantalla virtual esté en ejecución
export DISPLAY=:1
xdpyinfo | grep dimensions

# Reiniciar pantalla
pkill Xvfb
Xvfb :1 -screen 0 1920x1080x24 &
```

### Alta latencia

* Cambia de **Wi-Fi a Ethernet** en el lado del cliente
* Reduce el bitrate en los ajustes de Moonlight
* Usa **H.265** en lugar de H.264 (mejor compresión con la misma calidad)
* Activa **Sincronización de frames** en la configuración de Sunshine

### Error NVENC: "No encoder found"

```bash
# Verificar que la GPU NVIDIA sea accesible
nvidia-smi

# Comprobar que el contenedor tiene acceso a la GPU
docker exec sunshine nvidia-smi

# Si no, reinicia con la bandera --gpus all
docker stop sunshine && docker rm sunshine
# Volver a ejecutar con --gpus all
```

### Problemas de autenticación/emparejamiento

```bash
# Restablecer credenciales de Sunshine
docker exec sunshine sunshine --creds admin newpassword

# Borrar clientes emparejados
rm -f ./sunshine-config/sunshine_state.json
docker restart sunshine
```

***

## Configuración avanzada

### Soporte multi-monitor

```yaml
# En la configuración de Sunshine (sunshine.conf)
[video]
adapter_name = /dev/dri/card0
output_name = HDMI-A-1
```

### Audio por red

Instala un sink virtual de 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
```

### Soporte de controladores de juego

Sunshine admite emulación de gamepad virtual. Habilítalo en la configuración:

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

### Wake-on-LAN (para servidores persistentes)

```bash
# Mantener el servidor activo incluso cuando no se está transmitiendo
docker update --restart=always sunshine
```

***

## Optimización de costos

### Calcula tu costo de streaming

```
Alquiler de GPU: ~$0.30-0.80/hora (RTX 3080)
Almacenamiento: ~$0.01/hora (SSD 50GB)
Total: ~$0.31-0.81/hora

vs GeForce NOW: $9.99-$19.99/mes (horas limitadas)
vs Xbox Cloud Gaming: $14.99/mes (catálogo limitado)
```

### Consejos para ahorrar dinero

1. **Instancias spot**: Usa la GPU más barata disponible durante horas valle
2. **Pausar cuando no juegas**: Detén el contenedor pero conserva el volumen
3. **Preinstalar juegos**: Usa un volumen persistente para no volver a descargar cada vez
4. **Apagado automático**: Añade un script para detener el servidor tras inactividad

```bash
# Apagado automático tras 30 min sin conexión Moonlight
#!/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
```

***

## Buenas prácticas de seguridad

{% hint style="danger" %}
**¡Nunca expongas Sunshine sin autenticación!** Siempre establece una contraseña fuerte y considera usar una VPN o túnel SSH para mayor seguridad.
{% endhint %}

### Método de túnel SSH (más seguro)

```bash
# En tu máquina local, crea un túnel SSH
ssh -L 47990:localhost:47990 \
    -L 48010:localhost:48010 \
    root@<clore-server-ip>

# Luego conecta Moonlight a localhost en lugar de la IP del servidor
```

### Cambiar credenciales por defecto

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

### Restringir acceso por IP

En la configuración de Sunshine:

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

***

## Benchmarks de rendimiento

| GPU      | Resolución | FPS | Latencia | Codificador |
| -------- | ---------- | --- | -------- | ----------- |
| 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   |

*Latencia medida en una conexión de red local de 100 Mbps*

***

## Enlaces útiles

* [Sunshine en GitHub](https://github.com/LizardByte/Sunshine) — 20K+ estrellas
* [Sitio oficial de Moonlight](https://moonlight-stream.org)
* [Documentación de Sunshine](https://docs.lizardbyte.dev/projects/sunshine)
* [Discord de LizardByte](https://discord.gg/lizardbyte)
* [Mercado de Clore.ai](https://clore.ai)

***

## Resumen

| Paso | Acción                                            |
| ---- | ------------------------------------------------- |
| 1    | Alquila servidor GPU con puertos 22, 47990, 48010 |
| 2    | Desplegar `lizardbyte/sunshine` vía Docker        |
| 3    | Configurar vía interfaz web en `https://IP:47990` |
| 4    | Configura el codificador NVENC, bitrate 50 Mbps   |
| 5    | Crear pantalla virtual (Xvfb)                     |
| 6    | Instala el cliente Moonlight localmente           |
| 7    | Empareja usando el código PIN                     |
| 8    | ¡Transmite y juega! 🎮                            |

Con Sunshine + Moonlight en Clore.ai, obtienes una experiencia de juego en la nube que rivaliza con cualquier servicio comercial — con control total sobre tu hardware y tus juegos. Sin suscripciones, sin restricciones, sin límites.

***

## Recomendaciones de GPU en Clore.ai

| Caso de uso                  | GPU recomendada | Coste estimado en Clore.ai |
| ---------------------------- | --------------- | -------------------------- |
| Streaming 1080p/60fps        | RTX 3090 (24GB) | \~$0.12/gpu/hr             |
| Streaming 4K/Alta frecuencia | RTX 4090 (24GB) | \~$0.70/gpu/hr             |
| Juegos AAA + Streaming       | RTX 4090 (24GB) | \~$0.70/gpu/hr             |

> 💡 Todos los ejemplos en esta guía pueden desplegarse en [Clore.ai](https://clore.ai/marketplace) servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.


---

# 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/guides_v2-es/juegos-y-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.