# Blender Rendering

Render 3D scenes and animations using Blender on CLORE.AI GPUs.

{% hint style="success" %}
All examples can be run on GPU servers rented through [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Renting on CLORE.AI

1. Visit [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filter by GPU type, VRAM, and price
3. Choose **On-Demand** (fixed rate) or **Spot** (bid price)
4. Configure your order:
   * Select Docker image
   * Set ports (TCP for SSH, HTTP for web UIs)
   * Add environment variables if needed
   * Enter startup command
5. Select payment: **CLORE**, **BTC**, or **USDT/USDC**
6. Create order and wait for deployment

### Access Your Server

* Find connection details in **My Orders**
* Web interfaces: Use the HTTP port URL
* SSH: `ssh -p <port> root@<proxy-address>`

## Why Rent GPUs for Blender?

* Render complex scenes 10-50x faster than CPU
* Multiple GPUs for even faster rendering
* No need to invest in expensive hardware
* Pay only for render time

## Requirements

| Scene Complexity | Recommended GPU | VRAM    |
| ---------------- | --------------- | ------- |
| Simple           | RTX 3070        | 8GB     |
| Medium           | RTX 3090        | 24GB    |
| Complex          | RTX 4090        | 24GB    |
| Production       | A100            | 40-80GB |

## Quick Deploy

**Docker Image:**

```
linuxserver/blender
```

Or headless rendering:

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

**Ports:**

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

## Headless Rendering Setup

**Image:**

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

**Command:**

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

## Accessing Your Service

After deployment, find your `http_pub` URL in **My Orders**:

1. Go to **My Orders** page
2. Click on your order
3. Find the `http_pub` URL (e.g., `abc123.clorecloud.net`)

Use `https://YOUR_HTTP_PUB_URL` instead of `localhost` in examples below.

## Upload Your Project

### Via SCP

```bash

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

# Upload project folder
scp -P <port> -r ./project/ root@<proxy>:/workspace/
```

### Via rsync (large projects)

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

## Render Commands

### Single Frame

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

### Animation (Frame Range)

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

### Specific Frames

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

## Render Options

### Resolution

```bash

# Override resolution
blender -b file.blend -o //output/frame_### -x 1920 -y 1080 -a -- --cycles-device CUDA
```

### Use Python Script

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

**render\_setup.py:**

```python
import bpy

# Set render engine
bpy.context.scene.render.engine = 'CYCLES'

# Set device
bpy.context.preferences.addons['cycles'].preferences.compute_device_type = 'CUDA'

# Enable all GPUs
for device in bpy.context.preferences.addons['cycles'].preferences.devices:
    device.use = True

# Set samples
bpy.context.scene.cycles.samples = 128

# Set resolution
bpy.context.scene.render.resolution_x = 1920
bpy.context.scene.render.resolution_y = 1080

# Output settings
bpy.context.scene.render.image_settings.file_format = 'PNG'
```

## Multi-GPU Rendering

For servers with multiple GPUs:

```python
import bpy

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

# Refresh devices
prefs.get_devices()

# Enable all GPUs
for device in prefs.devices:
    if device.type == 'CUDA':
        device.use = True
        print(f"Enabled: {device.name}")
```

## Render Farm Style (Multiple Servers)

Rent multiple servers and split frames:

**Server 1:**

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

**Server 2:**

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

**Server 3:**

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

Then combine renders locally.

## Eevee Rendering (Faster)

For real-time quality:

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

## OptiX Support (RTX GPUs)

For RTX ray tracing:

```python
import bpy
prefs = bpy.context.preferences.addons['cycles'].preferences
prefs.compute_device_type = 'OPTIX'  # Instead of CUDA
```

## Automated Render Script

**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 "Rendering complete!"
ls -la $OUTPUT_DIR
```

Usage:

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

## Monitoring Render Progress

### Watch Output Folder

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

### Blender Output

Blender prints frame progress to stdout:

```
Fra:1 Mem:1234.56M (Peak 1500.00M) | Time:00:01.23 | Remaining:04:32.10 | Mem:567.89M, Peak:890.12M | Scene, View Layer | Sample 64/128
```

## Download Rendered Frames

```bash

# Download all frames
scp -P <port> -r root@<proxy>:/workspace/output/ ./renders/

# Download specific frames
scp -P <port> root@<proxy>:/workspace/output/frame_001.png ./

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

## Video Encoding

After rendering frames, encode to video:

```bash

# Install ffmpeg
apt-get install -y ffmpeg

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

# Encode to ProRes (high quality)
ffmpeg -framerate 24 -i /workspace/output/frame_%03d.png -c:v prores_ks -profile:v 3 output.mov
```

## Performance Tips

### Optimize for Speed

```python

# Reduce samples for preview
bpy.context.scene.cycles.samples = 64

# Use adaptive sampling
bpy.context.scene.cycles.use_adaptive_sampling = True
bpy.context.scene.cycles.adaptive_threshold = 0.01

# Limit bounces
bpy.context.scene.cycles.max_bounces = 8
```

### Memory Optimization

```python

# Use tiled rendering for high-res
bpy.context.scene.render.use_persistent_data = True

# Set tile size
bpy.context.scene.cycles.tile_size = 256  # For GPU
```

## Render Time Estimates

| Scene      | GPU      | Resolution | Samples | Time/Frame |
| ---------- | -------- | ---------- | ------- | ---------- |
| Simple     | RTX 3090 | 1080p      | 128     | \~30s      |
| Medium     | RTX 3090 | 1080p      | 256     | \~2min     |
| Complex    | RTX 4090 | 4K         | 512     | \~10min    |
| Production | A100     | 4K         | 1024    | \~20min    |

## Cost Calculation

**Example: 250 frame animation**

```
GPU: RTX 4090
Time per frame: 2 minutes
Total render time: 500 minutes = 8.3 hours
Hourly rate: $0.04
Total cost: ~$0.33
```

## Troubleshooting

### "CUDA device not found"

```python

# Check available devices
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" %}
**Out of memory**
{% endhint %}

* Reduce texture resolution
* Use smaller tile size
* Enable "persistent data"
* Use simpler shaders

### Slow rendering

* Check GPU is being used (nvidia-smi)
* Optimize scene geometry
* Use denoising with fewer samples

## Next Steps

* Run Jupyter for Post-Processing
* [AI Video Generation](https://docs.clore.ai/guides/video-generation/ai-video-generation)