> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/juegos-y-streaming/sunshine-moonlight.md).

# Juego remoto con Sunshine + Moonlight

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

{% hint style="info" %}
**Sunshine** es un servidor de streaming de juegos autohospedado y de código abierto 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, por una fracción del costo.
{% endhint %}

***

## ¿Qué es Sunshine + Moonlight?

**Sunshine** es una bifurcación de la pila original Moonlight/GameStream, ahora completamente independiente y mantenida 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 TV.

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

* **Alquila una GPU de alta gama** (RTX 4090, A100, etc.) a precio spot
* **Transmitir juegos AAA** desde la nube a cualquier dispositivo, incluso una laptop barata
* **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

***

## Requisitos previos

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

***

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

1. Ve a [clore.ai](https://clore.ai) → **Marketplace**
2. Filtrar por **Tipo de GPU**: Se recomienda una RTX 3080 o superior para transmisión 1080p/60fps
3. Busca servidores con puertos **22**, **47990**y **48010** disponibles
4. Selecciona un servidor y continúa con el pedido

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

### GPU recomendada para transmisión

| 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: Implementa Sunshine mediante 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

# Ver registros
docker compose logs -f sunshine

# Verifica que se esté ejecutando
docker ps | grep sunshine
```

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

### Comando único de Docker (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: Configura la interfaz web de Sunshine

1. Abre tu navegador y navega a:

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

{% 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                                             |
| ----------------- | ----------------------------------------------------- |
| **Fijar**         | Emparejar con el cliente Moonlight                    |
| **Aplicaciones**  | Definir aplicaciones/juegos compatibles con streaming |
| **Configuración** | Ajustes de codificador, resolución y bitrate          |
| **Registros**     | Depurar problemas de streaming                        |

***

## Paso 4: Configura los ajustes de codificación

Navega a **Configuración** → **Video** en la interfaz web:

### Ajustes recomendados para Clore.ai

```
# Codificador
codificador: nvenc          # Usa codificación por hardware de NVIDIA

# Resolución
resolution_width: 1920
resolution_height: 1080

# Frecuencia de cuadros
fps: 60

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

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

{% hint style="info" %}
**NVENC frente a VAAPI**: En los servidores NVIDIA de Clore.ai, usa siempre `nvenc` codificador. Descarga la codificación al hardware de la GPU, liberando la CPU para el juego en sí.
{% 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ñade aplicaciones para transmitir

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

### Ejemplo: transmisión de escritorio

```
Nombre: Escritorio
Comando: (déjalo vacío para el 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 desconexión: (vacío)
```

### Ejemplo: juego personalizado

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

***

## Paso 6: Configura una pantalla virtual (servidor sin interfaz)

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

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

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

# Inicia el entorno de escritorio
startxfce4 &
```

### O usa un script de framebuffer virtual

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

export DISPLAY=:1

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

# Inicia el gestor de ventanas
openbox &
sleep 1

# Inicia 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 una pantalla física:

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

{% endhint %}

***

## Paso 7: Conéctate con el cliente Moonlight

### Instala Moonlight

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

### Empareja Moonlight con Sunshine

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

### Ajustes de Moonlight para la mejor experiencia

```
Resolución: 1920x1080
FPS: 60
Bitrate: 50 Mbps
Códec de video: 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       | Administración SSH                    |
| 47984       | TCP       | HTTPS (compatibilidad con GameStream) |
| 47989       | TCP       | HTTP (compatibilidad con GameStream)  |
| 47990       | TCP       | Interfaz web HTTPS                    |
| 48010       | TCP       | RTSP (control de streaming)           |
| 47998-48000 | UDP       | Transmisión de video/audio            |
| 48010       | UDP       | Transmisión de video                  |

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

***

## Solución de problemas

### Sunshine no se inicia

```bash
# Compruebe los registros 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
# Verifica que la pantalla virtual esté en ejecución
export DISPLAY=:1
xdpyinfo | grep dimensions

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

### Alta latencia

* Cambiar 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)
* Habilita **Sincronización de fotogramas** en la configuración de Sunshine

### Error de NVENC: "No se encontró ningún codificador"

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

# Comprueba que el contenedor tenga 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
# Restablece las credenciales de Sunshine
docker exec sunshine sunshine --creds admin newpassword

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

***

## Configuración avanzada

### Compatibilidad con varios monitores

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

### Audio por red

Instala el sumidero 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
```

### Compatibilidad con mandos de juego

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

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

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

```bash
# Mantén el servidor activo incluso cuando no esté transmitiendo
docker update --restart=always sunshine
```

***

## Optimización de costos

### Calcula tu costo de streaming

```
Alquiler de GPU: $0.05–0.19/h (RTX 3080)
Almacenamiento: ~$0.01/hora (SSD de 50 GB)
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 las horas de menor demanda
2. **Pausar cuando no estés jugando**: Detén el contenedor pero conserva el volumen
3. **Preinstalar juegos**: Usa un volumen persistente para no volver a descargarlos cada vez
4. **Apagado automático**: Añade un script para detener el servidor después de la inactividad

```bash
# Apagado automático después de 30 min sin conexión de 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 "Sin conexiones durante 30 min, apagando"
    docker stop sunshine
    break
  fi
  sleep 60
done
```

***

## Mejores prácticas de seguridad

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

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

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

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

### Cambiar las credenciales predeterminadas

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

### Restringir el acceso por IP

En la configuración de Sunshine:

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

***

## Puntos de referencia 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

* [GitHub de Sunshine](https://github.com/LizardByte/Sunshine) — más de 20 mil 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)
* [Marketplace de Clore.ai](https://clore.ai)

***

## Resumen

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

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 para Clore.ai

| Caso de uso                                      | GPU recomendada | Costo estimado en Clore.ai |
| ------------------------------------------------ | --------------- | -------------------------- |
| Streaming 1080p/60fps                            | RTX 3090 (24GB) | $0.07–0.21/gpu/hr          |
| Streaming 4K/de alta frecuencia de actualización | RTX 4090 (24GB) | $0.14–0.42/gpu/hr          |
| Juegos AAA + Streaming                           | RTX 4090 (24GB) | $0.14–0.42/gpu/hr          |

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/juegos-y-streaming/sunshine-moonlight.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.