Skip to main content
skill CX Codex

blender-export-pipelines — Claude Code skill for Blender exports

The blender-export-pipelines Claude Code skill exports Blender assets with presets for game engines and other formats. It activates when an asset needs to leave Blender and the exported file needs checking.

MIT 681 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-export-pipelines -a claude-code
Open on GitHub

What blender-export-pipelines does

The skill exports models and scenes from Blender 5.3 using presets for Roblox, Unity, Unreal, Godot, the web, and USD. Presets set scale, axes, smoothing, bones, and animation clips; batch export and post-export checks are supported.

The export script is scripts/export_asset.py; it takes a preset, objects or a collection, and an output path. The workflow relies on blender-core, and blender-asset-qa runs before export; blender-game-optimization is also used for budget checks. Procedural materials need baking first because they do not export directly.

What it helps with

  • export a skeletal model as FBX for Unity or Unreal
  • save a collection as GLB for Godot or web use
  • export several objects as separate files in one batch
  • check scale and animation after export

Example prompts for the agent

  • Export SK_Hero as FBX for Unreal with the unreal_skeletal preset.
  • Save the Export collection as GLB for the web.
  • Batch-export SM_A, SM_B, and SM_C as separate Unity files.

How to install blender-export-pipelines

1Skills CLI (Vercel)

npx skills add EL4CTEO/blender-skills --skill blender-export-pipelines -a claude-code

2Manually: put the files in place

~/.claude/skills/blender-export-pipelines/SKILL.md

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

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

Questions about blender-export-pipelines

How do I install blender-export-pipelines in Claude Code?

Run npx skills add EL4CTEO/blender-skills --skill blender-export-pipelines -a claude-code. The skill file is at ~/.claude/skills/blender-export-pipelines/SKILL.md.

What does blender-export-pipelines do?

It exports Blender assets with presets for engines, web formats, and USD, then checks the resulting files. Exports run through scripts/export_asset.py.

What does blender-export-pipelines need to run?

It requires Blender 5.3 and the execution model from blender-core. Run blender-asset-qa before exporting; blender-game-optimization is also used for budget checks.

Source text

SKILL.md · MIT
---
name: blender-export-pipelines
description: Export from Blender 5.3 with verified presets - Roblox (FBX/glTF, cages, R15, SurfaceAppearance), Unity (FBX, Humanoid), Unreal (FBX skeletal, Nanite, UCX), Godot/web (GLB, meshopt/Draco, WebP), USD. Scale/axes, smoothing, tangents, leaf bones, clips, batch export, post-export verification. Use whenever an asset leaves Blender.
license: MIT
metadata:
  author: blender-agent-skills
  version: "1.2.0"
---

# Export Pipelines

The execution model is in `blender-core`. Run `blender-asset-qa` (and `blender-game-optimization` for budgets) **before** exporting.

## One call
```
scripts/export_asset.py -- --preset unreal_skeletal --objects SK_Hero --out //export/SK_Hero.fbx
scripts/export_asset.py -- --preset web --collection Export --out //export/scene.glb
scripts/export_asset.py -- --preset unity --objects SM_A SM_B SM_C --batch --out //export/x.fbx   # one file each, at origin
```
Presets: `roblox`, `roblox_gltf`, `unity`, `unity_skeletal`, `unreal`, `unreal_skeletal`, `godot`, `web`, `gltf`, `usd`. Pass any exporter kwarg with `--set key=value`. Every preset is tested with a round-trip that keeps scale and avoids a 100× armature scale.

## Engine reference (load only the one you need)
- [references/roblox.md](references/roblox.md): MeshParts, avatar bodies (R15), accessories, layered clothing cages, SurfaceAppearance, limits
- [references/unity.md](references/unity.md): FBX settings, Humanoid rigs, URP/HDRP maps, animation clips
- [references/unreal.md](references/unreal.md): static/skeletal FBX, root bone, collision UCX, LODs, Nanite, ORM/DirectX
- [references/godot-web.md](references/godot-web.md): glTF/GLB, import suffixes, three.js/Babylon, compression, KHR extensions

## Universal pre-export checklist
1. **Scale**: scene unit scale 1.0, objects at scale 1, rotation applied (except intentional object transforms). The presets handle unit conversion.
2. **Pivot/origin** where the engine expects it: props at the bottom-center, characters at the world origin between the feet, facing **-Y** (Blender front). Every preset converts that to the engine's forward.
3. **Modifiers**: the presets export the evaluated mesh. Mirror, bevel and weighted normals are kept; booleans become real geometry.
4. **Normals**: custom/weighted normals export. Smooth shading, plus hard edges marked sharp.
5. **Triangulation**: FBX presets triangulate (`use_triangles`) so the bake and engine tangents match. glTF always triangulates.
6. **Materials**: image-texture → Principled chains only, with names `M_*` and textures `T_*`. Procedural nodes don't export, so bake them first.
7. **Armature**: deform bones only, no leaf bones, rest pose = bind pose, 4 weights per vertex max, and the root at the origin.
8. **Animation**: one action per clip, named `Rig_Clip`. Bake constraints/IK to keys (`blender-animation`). FBX exports the active/NLA action per preset settings; glTF `ACTIONS` mode exports every action that has a slot for the armature.
9. **Naming**: unique, ASCII, no spaces. Engines key materials/meshes by name across reimports.

## Format choice
| Need | Format |
|---|---|
| Unity, Unreal (most stable for skeletal) | FBX |
| Godot, web, Roblox (supported), Unreal 5.x Interchange, Blender↔Blender | glTF 2.0 (`.glb`) |
| Film/VFX, Omniverse, Apple AR (`.usdz`), layout interchange | USD |
| Static geometry for printing/CAD | OBJ / STL (`wm.obj_export`, `wm.stl_export`) |
| Point caches / deforming sims | Alembic (`wm.alembic_export`) |

## Verify after export (required)
- The script returns `ok`, the file size, and for `.glb` a parsed summary (meshes, materials, images, animations, skins, tris, extensions). Compare it with what you expected.
- For FBX/USD: re-import into an empty scene (`import_scene.fbx` / `wm.usd_import`) and check `dimensions`, the armature scale (must be 1, not 100) and the action count.
- In the engine: scale against a reference (UE mannequin 180 cm, Unity capsule 2 m, Roblox character 5 studs), normals/smoothing, the normal map's green channel, and animation root motion.

## Collection exporters (re-export in one click, 4.2+)
See `blender-scene-setup`: `collection.exporters` stores the format + settings per collection, and `bpy.ops.wm.collection_export_all()` re-exports everything.

## Gotchas
- FBX `use_tspace` fails silently on n-gons. Triangulate first (the presets do).
- `bake_space_transform` (Apply Transform) is experimental. Use it for Unity static meshes only, never with armatures.
- glTF exports **actions** linked through slots/NLA. An action with no user on the armature is skipped (`export_animation_mode` options: `ACTIONS`, `ACTIVE_ACTIONS`, `NLA_TRACKS`, `SCENE`, `BROADCAST`).
- glTF needs image textures in PNG/JPEG/WebP. EXR/TIFF get converted (`export_image_format`).
- 5.3 glTF: `export_image_add_webp`/`export_image_webp_fallback` became `export_image_add_compressed_images` + `export_compressed_images_type` (`WEBP`/`KTX2`) + `export_compressed_images_fallback`. `at_collection_center` became `collection_center_mode`. Point clouds export (`export_pointclouds`).
- Linked library data exports fine, but make it local or override it if you need to modify it first.
- Shape keys: FBX exports them as blendshapes, glTF as morph targets (`export_morph`). Modifiers before the Armature modifier can block shape-key export in FBX (apply them first).

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

Similar skills

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

From the same set28

The whole set →
blender-core blender-core is a Claude Code and Cursor skill that coordinates Blender 5.2 and 5.3 workflows via bpy, MCP, and CLI, routing requests to specialized scripts for modeling, animation, and rendering. CX Codex +1 965installs blender-character-rigging blender-character-rigging — a skill for Claude Code automates character rigging in Blender 5.3 with Rigify. It triggers on armature generation, weight painting, and mesh binding tasks. CX Codex +1 779installs blender-asset-qa blender-asset-qa — a Claude Code skill for automated review of meshes and assets in Blender. Runs before export or delivery. CX Codex +1 765installs blender-animation blender-animation — a skill for Claude Code that automates Blender 5.3 animation via Python scripts. It handles keyframing, mocap retargeting, and rigging bake processes for game engines. CX Codex +1 757installs blender-game-optimization The blender-game-optimization skill runs in Claude Code, Codex, Cursor and other platforms to optimize Blender 3D assets for real-time engine limits. CX Codex +1 657installs blender-pbr-materials blender-pbr-materials — a skill for Claude Code configures PBR materials and texture sets in Blender 5.3 following engine-ready rules. CX Codex +1 644installs 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

More in the catalog

Project sponsors

Companies that keep this analytics open