> 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/otras-cargas-de-trabajo/blender-rendering.md).

# Renderizado de Blender

Renderizado 3D de Blender acelerado por GPU en Clore.ai

Renderiza escenas y animaciones 3D usando Blender en las GPUs de CLORE.AI.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [Marketplace de CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [Marketplace de CLORE.AI](https://clore.ai/marketplace)
2. Filtra por tipo de GPU, VRAM y precio
3. Elige **Bajo demanda** (tarifa fija) o **Spot** (precio ofertado)
4. Configura tu pedido:
   * Selecciona la imagen de Docker
   * Configura los puertos (TCP para SSH, HTTP para interfaces web)
   * Añade variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona el método de pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera al despliegue

### Accede a tu servidor

* Encuentra los detalles de conexión en **Mis pedidos**
* Interfaces web: Usa la URL del puerto HTTP
* SSH: `ssh -p <port> root@<proxy-address>`

## ¿Por qué alquilar GPUs para Blender?

* Renderiza escenas complejas entre 10 y 50 veces más rápido que con CPU
* Varias GPUs para un renderizado aún más rápido
* No necesitas invertir en hardware costoso
* Paga solo por el tiempo de renderizado

## Requisitos

| Complejidad de la escena | GPU recomendada | VRAM     |
| ------------------------ | --------------- | -------- |
| Sencilla                 | RTX 3070        | 8GB      |
| Medio                    | RTX 3090        | 24GB     |
| Complejo                 | RTX 4090        | 24GB     |
| Producción               | A100            | 40-80 GB |

## Despliegue rápido

**Imagen de Docker:**

```
linuxserver/blender
```

O renderizado sin interfaz:

```
nytimes/blender:3.6-gpu-ubuntu22.04
```

**Puertos:**

```
22/tcp
3000/http
```

## Configuración de renderizado sin interfaz

**Imagen:**

```
nvidia/cuda:12.8.1-devel-ubuntu22.04
```

**Comando:**

```bash
apt-get update && \
apt-get install -y wget libxi6 libxxf86vm1 libxfixes3 libxrender1 libgl1 && \
wget https://download.blender.org/release/Blender4.0/blender-4.0.2-linux-x64.tar.xz && \
tar -xf blender-4.0.2-linux-x64.tar.xz && \
mv blender-4.0.2-linux-x64 /opt/blender
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis pedidos**:

1. Ve a **Mis pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (p. ej., `abc123.clorecloud.net`)

Usa `https://YOUR_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos a continuación.

## Sube tu proyecto

### Mediante SCP

```bash

# Subir archivo .blend
scp -P <port> myproject.blend root@<proxy>:/workspace/

# Subir carpeta del proyecto
scp -P <port> -r ./project/ root@<proxy>:/workspace/
```

### Mediante rsync (proyectos grandes)

```bash
rsync -avz --progress -e "ssh -p <port>" ./project/ root@<proxy>:/workspace/project/
```

## Comandos de renderizado

### Fotograma único

```bash
/opt/blender/blender -b /workspace/myproject.blend -o /workspace/output/frame_### -f 1 -- --cycles-device CUDA
```

### Animación (rango de fotogramas)

```bash
/opt/blender/blender -b /workspace/myproject.blend -o /workspace/output/frame_### -s 1 -e 250 -a -- --cycles-device CUDA
```

### Fotogramas específicos

```bash
/opt/blender/blender -b /workspace/myproject.blend -o /workspace/output/frame_### -f 1,50,100,150,200 -- --cycles-device CUDA
```

## Opciones de renderizado

### Resolución

```bash

# Sobrescribir resolución
blender -b file.blend -o //output/frame_### -x 1920 -y 1080 -a -- --cycles-device CUDA
```

### Usar script de Python

```bash
blender -b file.blend --python render_setup.py -a
```

**render\_setup.py:**

```python
import bpy

# Establecer el motor de renderizado
bpy.context.scene.render.engine = 'CYCLES'

# Establecer dispositivo
bpy.context.preferences.addons['cycles'].preferences.compute_device_type = 'CUDA'

# Habilitar todas las GPUs
for device in bpy.context.preferences.addons['cycles'].preferences.devices:
    device.use = True

# Establecer muestras
bpy.context.scene.cycles.samples = 128

# Establecer resolución
bpy.context.scene.render.resolution_x = 1920
bpy.context.scene.render.resolution_y = 1080

# Configuración de salida
bpy.context.scene.render.image_settings.file_format = 'PNG'
```

## Renderizado con varias GPUs

Para servidores con varias GPUs:

```python
import bpy

# Habilitar CUDA
prefs = bpy.context.preferences.addons['cycles'].preferences
prefs.compute_device_type = 'CUDA'

# Actualizar dispositivos
prefs.get_devices()

# Habilitar todas las GPUs
for device in prefs.devices:
    if device.type == 'CUDA':
        device.use = True
        print(f"Habilitado: {device.name}")
```

## Estilo de granja de renderizado (varios servidores)

Alquila varios servidores y divide los fotogramas:

**Servidor 1:**

```bash
blender -b project.blend -o //output/frame_### -s 1 -e 100 -a
```

**Servidor 2:**

```bash
blender -b project.blend -o //output/frame_### -s 101 -e 200 -a
```

**Servidor 3:**

```bash
blender -b project.blend -o //output/frame_### -s 201 -e 300 -a
```

Luego combina los renders localmente.

## Renderizado con Eevee (más rápido)

Para calidad en tiempo real:

```bash
blender -b file.blend -E BLENDER_EEVEE -o //output/frame_### -a
```

## Compatibilidad con OptiX (GPUs RTX)

Para trazado de rayos RTX:

```python
import bpy
prefs = bpy.context.preferences.addons['cycles'].preferences
prefs.compute_device_type = 'OPTIX'  # En lugar de CUDA
```

## Script automatizado de renderizado

**render.sh:**

```bash
#!/bin/bash
BLEND_FILE=$1
START_FRAME=$2
END_FRAME=$3
OUTPUT_DIR=/workspace/output

mkdir -p $OUTPUT_DIR

/opt/blender/blender -b $BLEND_FILE \
    -o ${OUTPUT_DIR}/frame_### \
    -s $START_FRAME \
    -e $END_FRAME \
    -a \
    -- --cycles-device CUDA

echo "¡Renderizado completado!"
ls -la $OUTPUT_DIR
```

Uso:

```bash
chmod +x render.sh
./render.sh /workspace/myproject.blend 1 250
```

## Monitoreo del progreso del renderizado

### Vigilar la carpeta de salida

```bash
watch -n 5 'ls -la /workspace/output/ | tail -20'
```

### Salida de Blender

Blender imprime el progreso del fotograma en stdout:

```
Fot.:1 Mem:1234.56M (Pico 1500.00M) | Tiempo:00:01.23 | Restante:04:32.10 | Mem:567.89M, Pico:890.12M | Escena, Capa de vista | Muestra 64/128
```

## Descargar fotogramas renderizados

```bash

# Descargar todos los fotogramas
scp -P <port> -r root@<proxy>:/workspace/output/ ./renders/

# Descargar fotogramas específicos
scp -P <port> root@<proxy>:/workspace/output/frame_001.png ./

# Sincronizar con rsync
rsync -avz --progress -e "ssh -p <port>" root@<proxy>:/workspace/output/ ./renders/
```

## Codificación de video

Después de renderizar los fotogramas, codifícalos en video:

```bash

# Instalar ffmpeg
apt-get install -y ffmpeg

# Codificar a MP4
ffmpeg -framerate 24 -i /workspace/output/frame_%03d.png -c:v libx264 -pix_fmt yuv420p output.mp4

# Codificar a ProRes (alta calidad)
ffmpeg -framerate 24 -i /workspace/output/frame_%03d.png -c:v prores_ks -profile:v 3 output.mov
```

## Consejos de rendimiento

### Optimizar para velocidad

```python

# Reducir muestras para vista previa
bpy.context.scene.cycles.samples = 64

# Usar muestreo adaptativo
bpy.context.scene.cycles.use_adaptive_sampling = True
bpy.context.scene.cycles.adaptive_threshold = 0.01

# Limitar rebotes
bpy.context.scene.cycles.max_bounces = 8
```

### Optimización de memoria

```python

# Usar renderizado en mosaico para alta resolución
bpy.context.scene.render.use_persistent_data = True

# Establecer tamaño de mosaico
bpy.context.scene.cycles.tile_size = 256  # Para GPU
```

## Estimaciones del tiempo de renderizado

| Escena     | GPU      | Resolución | Muestras | Tiempo/Fotograma |
| ---------- | -------- | ---------- | -------- | ---------------- |
| Sencilla   | RTX 3090 | 1080p      | 128      | \~30 s           |
| Medio      | RTX 3090 | 1080p      | 256      | \~2min           |
| Complejo   | RTX 4090 | 4K         | 512      | \~10min          |
| Producción | A100     | 4K         | 1024     | \~20min          |

## Cálculo de costos

**Ejemplo: animación de 250 fotogramas**

```
GPU: RTX 4090
Tiempo por fotograma: 2 minutos
Tiempo total de renderizado: 500 minutos = 8,3 horas
Tarifa por hora: $0.04
Costo total: ~$0.33
```

## Solución de problemas

### "CUDA device not found"

```python

# Comprobar dispositivos disponibles
import bpy
prefs = bpy.context.preferences.addons['cycles'].preferences
prefs.compute_device_type = 'CUDA'
prefs.get_devices()
for d in prefs.devices:
    print(d.name, d.type)
```

{% hint style="danger" %}
**Sin memoria**
{% endhint %}

* Reducir la resolución de las texturas
* Usar un tamaño de mosaico más pequeño
* Habilitar "datos persistentes"
* Usar shaders más simples

### Renderizado lento

* Comprueba que se esté usando la GPU (nvidia-smi)
* Optimizar la geometría de la escena
* Usar eliminación de ruido con menos muestras

## Siguientes pasos

* Ejecutar Jupyter para posprocesamiento
* [Generación de video con IA](/guides/guides_v2-es/generacion-de-video/ai-video-generation.md)


---

# 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/otras-cargas-de-trabajo/blender-rendering.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.