Skip to main content
skill CX Codex

blender-rendering · el4cteo — Claude Code skill: rendering and install

blender-rendering — a skill for Claude Code configures Blender 5.3 rendering for stills, animation, and turntables. It covers single-frame, animation, and turntable jobs.

MIT 582 installs ★ 2,624 updated 2026-11-13

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add EL4CTEO/blender-skills --skill blender-rendering -a claude-code
Open on GitHub

What blender-rendering does

This skill configures Blender 5.3 renders with Cycles, EEVEE, or Workbench. It applies the preview, final, and product presets, selects an available GPU automatically, and sets adaptive sampling with denoising. Persistent data is used for animation and turntable work. Single frames, frame ranges, and multi-camera batches run through scripts/render_batch.py.

It covers AgX, Khronos PBR Neutral, Standard, and ACES color management, plus PNG, JPEG, EXR, and MP4 output. Passes and the Blender 5.0+ compositor API are included. For video, frame sequences can be encoded with FFmpeg or the VSE. Background EEVEE still needs a GPU; CI jobs without one can use Cycles on CPU or Workbench.

What it helps with

  • render a single frame or a frame range
  • choose a quality preset for Cycles or EEVEE
  • produce a turntable from several cameras
  • write a multilayer EXR with passes
  • run animation renders from the CLI

Example prompts for the agent

  • Render the hero scene in Cycles with the final preset using scripts/render_batch.py -- --engine CYCLES --preset final --res 1920 1080 --out //render/hero_#### --frames 1.
  • Create a preview turntable for frames 1–120 as MP4 with scripts/render_batch.py -- --preset preview --frames 1-120 --format MP4 --out //render/turntable.
  • Render CamA, CamB, and CamC to multilayer EXR files in //render/shots/.

How to install blender-rendering

1Skills CLI (Vercel)

npx skills add EL4CTEO/blender-skills --skill blender-rendering -a claude-code

2Manually: put the files in place

~/.claude/skills/blender-rendering/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/blender-rendering/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about blender-rendering

How do I install blender-rendering in Claude Code?

Run npx skills add EL4CTEO/blender-skills --skill blender-rendering -a claude-code, then check ~/.claude/skills/blender-rendering/SKILL.md. This installs the skill for Claude Code.

What does the blender-rendering skill do?

It sets up Blender rendering with Cycles, EEVEE, and Workbench, including quality presets, GPU selection, sampling, denoising, color management, and output formats. It also handles CLI and batch jobs for stills, animations, and multiple cameras.

What does blender-rendering require?

Blender 5.3 is required. FFmpeg or the VSE is used to encode video after rendering frames, and background EEVEE requires a GPU.

Source text

SKILL.md · MIT
---
name: blender-rendering
description: Render with Blender 5.3 Cycles/EEVEE/Workbench - quality presets, GPU setup, adaptive sampling, denoising, light paths, color management (AgX, Khronos PBR Neutral, ACES), PNG/EXR/MP4 output, passes, the 5.0 compositor API, CLI and multi-camera batch rendering. Use for any still, animation or turntable render.
license: MIT
metadata:
  author: blender-agent-skills
  version: "1.2.0"
---

# Rendering

The execution model is in `blender-core`. Scene lighting and cameras are in `blender-lighting-lookdev`.

## One call
```
scripts/render_batch.py -- --engine CYCLES --preset final --res 1920 1080 --out //render/hero_#### --frames 1
scripts/render_batch.py -- --preset preview --frames 1-120 --format MP4 --out //render/turntable
scripts/render_batch.py -- --cameras CamA CamB CamC --format EXR_MULTI --out //render/shots/
```
Presets: `preview` (Cycles 64 spp, threshold 0.05, 50% res; EEVEE 16), `final` (512 spp, 0.01; EEVEE 128 + raytracing), `product` (1024 spp, transparent background). GPU is picked automatically (OptiX > CUDA > HIP > Metal > oneAPI), and the denoiser matches (OptiX or OpenImageDenoise).

## Engine choice
| Engine | Use | Notes |
|---|---|---|
| Cycles | final quality, product, archviz, glass/SSS/caustics, baking | path tracer; set the GPU; adaptive sampling + denoise |
| EEVEE (5.x, ex-"Next") | fast look-dev, stylized, motion graphics, previews | ray-traced reflections/GI (`use_raytracing`), virtual shadow maps; needs a GPU even headless |
| Workbench | playblasts, clay/matcap reviews, QA sheets | instant, no lighting accuracy |
Engine ids: `CYCLES`, `BLENDER_EEVEE`, `BLENDER_WORKBENCH`.

## Cycles quality levers (ordered by impact)
1. **Adaptive sampling** (`adaptive_threshold` 0.01 final / 0.05 preview) + **denoise** (OIDN with albedo+normal passes, `denoising_input_passes="RGB_ALBEDO_NORMAL"`). Raising samples alone is the least efficient fix.
2. **Light paths**: interiors need diffuse bounces ≥ 4. Product shots: total 12, glossy 4, transmission 8–12 for glass. Clamp indirect 5–10 kills fireflies at a small energy cost.
3. **Light tree** (`use_light_tree`, on) for many lights. **Path guiding** (CPU only) for difficult indirect light.
4. Fewer, larger lights beat many small ones. Emissive meshes are noisier than area lights.
5. Persistent data (`render.use_persistent_data`) speeds up animations and turntables. Use `simplify` (max subdivision, texture limit) for previews.
6. 5.2: **texture cache** (`render.use_texture_cache`, `use_auto_generate_texture_cache`) cuts memory in texture-heavy scenes by generating `.tx` mip tiles.

## Color management (decide once per project)
- **AgX** (default): photographic, handles bright highlights. Looks: `AgX - Punchy`, `- Base Contrast`...
- **Khronos PBR Neutral**: shows albedo faithfully. Use it for product/e-commerce and asset reviews, and to match three.js `NeutralToneMapping`.
- **Standard**: graphics/UI/texture output that must match pixel values.
- **ACES 1.3 / 2.0**: VFX pipelines (plates, other DCCs).
- Use exposure (`view_settings.exposure`), not light power, for global brightness tweaks. Display device sRGB, or Display P3 / Rec.2100 for HDR delivery.

## Output formats
- Stills: PNG 8/16-bit (RGBA when the film is transparent) or JPEG for web previews.
- Comp/VFX: **EXR multilayer** (`EXR_MULTI`, DWAA 16-bit) with passes (Denoising Data, Cryptomatte, AO, Mist, Z). 5.0 renamed passes: `Diffuse Color`, `Depth`, etc.
- Video: render **frames first** (PNG/EXR), then encode (FFmpeg or the VSE), because a crash mid-MP4 loses everything. Direct MP4 is fine for previews. Set `image_settings.media_type` **before** `file_format` (5.0+).
- Transparent: `film_transparent=True` + PNG/EXR. A glass-only alpha needs `film_transparent_glass`.

## Compositor (5.0+ API)
```python
ng = bpy.data.node_groups.new("Comp", "CompositorNodeTree"); scene.compositing_node_group = ng
ng.interface.new_socket("Image", in_out="OUTPUT", socket_type="NodeSocketColor")
rl, glare, out = ng.nodes.new("CompositorNodeRLayers"), ng.nodes.new("CompositorNodeGlare"), ng.nodes.new("NodeGroupOutput")
ng.links.new(rl.outputs["Image"], glare.inputs["Image"]); ng.links.new(glare.outputs["Image"], out.inputs[0])
```
There's no Composite node anymore: the group output is the final image. Many node options are now **input sockets** (Glare `Type`, `Threshold`, `Strength`), so `--describe` them with `blender-geometry-nodes/scripts/gn_builder.py`. File Output node: `directory`, `file_name`, `file_output_items`.
5.3: the compositor is an **effects stack** (`scene.compositor_effects`, each with its own `node_group`, `enable_for_render`/`enable_for_preview`). `scene.compositing_node_group` still gets/sets the active effect's group. The Essentials **Bloom** node group restores the old EEVEE bloom.

## CLI rendering (render farms, CI)
- `blender -b scene.blend -E CYCLES -o //out/frame_#### -F PNG -s 1 -e 120 -a` renders an animation. `-f 10` renders a single frame. Python args go after `--`.
- `-- --cycles-device OPTIX` (or CUDA/HIP/METAL/ONEAPI) selects the device without Python.
- Split frames across machines with `-s/-e`, or with Placeholders + No Overwrite (`render.use_placeholder`, `use_overwrite=False`) on shared storage.

## Gotchas
- `scene.render.engine` enum under-reports (add-on engines). Assign in try/except (the script does).
- EEVEE in background still needs a GPU context. In CI without a GPU, use Cycles CPU or Workbench.
- `bpy.ops.render.render(write_still=True)` writes `render.filepath`. Without `write_still`, the result only lives in `Render Result`.
- Noise in glass/caustics: enable caustics only if needed (`caustics_refractive`), raise transmission bounces, or fake it with Thin Wall (5.2) for windows.
- Fireflies: clamp indirect, a filter glossy / blur glossy (`blur_glossy` 0.5–1), and bigger light sources.

© blender-agent-skills · MIT · EL4CTEO/blender-skills

Similar skills

All skills for Game dev and 3D: Unity, Unreal, Godot, Blender →

blender-rendering by other authors comes first.

blender-rendering RobLe3 blender-rendering configures Cycles and EEVEE engines in Blender, managing samples, denoising, and AgX color transforms. Useful when asking an agent to produce renders or animations. CX Codex +1 2,400installs scenario-blender-lighting-rendering scenario-labs scenario-blender-lighting-rendering — a skill that walks an AI agent through lighting, rendering and compositing in Blender, from three-point setups to AgX color management. CX Codex +1 1,100installs scenario-blender-hair scenario-labs scenario-blender-hair guides hair and fur grooming in Blender 5.2 using hair curves and Essentials nodes. Helps set up character hairstyles, animal fur, procedural grooms, and game hair cards. CX Codex +1 907installs blender-forest mromidev blender-forest is a Claude Code skill that builds realistic 3D nature environments in Blender by following YouTube guides step by step. Sets up assets, custom scattering, and camera passes. CX Codex +1 ★ 182repo stars Frugal Blender MCP mohakmalviya Frugal Blender MCP connects coding agents to Blender via four tools, keeping baseline context consumption at 338 tokens through lazy schemas and request batching. CX Codex +1 ★ 18repo stars blender-pro-workflow RobLe3 The blender-pro-workflow skill sets the order for building a Blender scene, from block-out and camera to render and export. Useful when one request spans modeling, lighting and materials. CX Codex +1 2,300installs archviz https://github.com/arjun988 archviz — a skill for Claude Code and Codex guides architectural visualization in Blender over MCP. Enforces real-world dimensions, camera framing, realistic materials, and final rendering. CX Codex +1 619installs

From the same set28

The whole set →
blender-hardsurface-modeling blender-hardsurface-modeling — a skill for Claude Code guides hard-surface and prop modeling workflows in Blender 5.3. Sets up blockout rules, modifier pipelines, and topology checks. CX Codex +1 621installs blender-lighting-lookdev The blender-lighting-lookdev Claude Code skill sets up lighting, cameras and material look-dev in Blender 5.3. It activates for render scenes, asset presentations and consistent material checks. CX Codex +1 606installs blender-retopology-uv The blender-retopology-uv Claude Code skill covers retopology and UV work in Blender 5.3. Use it to turn a sculpt or scan into a game mesh, or prepare UVs for texturing and baking. CX Codex +1 603installs blender-texture-baking blender-texture-baking — a skill for Claude Code that runs Cycles baking pipelines in Blender 5.3. Triggers when transferring high-poly sculpt details to game assets or converting procedural node networks to images. CX Codex +1 587installs blender-geometry-nodes The blender-geometry-nodes Claude Code skill helps build Geometry Nodes setups in Blender. It comes into play for procedural assets, surface scattering, and modifier inputs. CX Codex +1 563installs blender-scene-setup The blender-scene-setup Claude Code skill sets up and audits Blender scenes. It runs while starting a project, organizing a .blend file, or preparing a handoff or export. CX Codex +1 558installs blender-sculpting blender-sculpting — a skill for Claude Code runs procedural sculpting workflows in Blender 5.3 for organic models and characters. Used when building base meshes, adding surface details, and preparing bake sources. CX Codex +1 558installs blender-facial-shapekeys blender-facial-shapekeys is a Claude Code skill that configures facial rigs and shape keys in Blender 5.3 for ARKit 52 and engine export. Runs when preparing 3D character faces for animation or export. CX Codex +1 548installs

Project sponsors

Companies that keep this analytics open