Blender Rendering

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

All examples can be run on GPU servers rented through CLORE.AI Marketplace.

Renting on CLORE.AI

1. Visit 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:

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

# 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)

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

Render Commands

Single Frame

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

Animation (Frame Range)

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

Specific Frames

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

Render Options

Resolution

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

Use Python Script

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

render_setup.py:

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:

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:

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

Server 2:

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

Server 3:

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

Then combine renders locally.

Eevee Rendering (Faster)

For real-time quality:

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

OptiX Support (RTX GPUs)

For RTX ray tracing:

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

Automated Render Script

render.sh:

#!/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:

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

Monitoring Render Progress

Watch Output Folder

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

# 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:

# 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

# 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

# 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"

# 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)

Out of memory

• 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