Skip to main content
skill CX Codex

blender-game-optimization — Claude Code skill: game asset 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.

MIT 657 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-game-optimization -a claude-code
Open on GitHub

What blender-game-optimization does

The skill checks triangle, material, bone, and texture budgets across mobile, console, PC, web, and VR platforms. An AI agent runs measurement scripts, strips hidden geometry, builds LOD chains, and merges materials to reduce draw calls before export.

Running the workflows requires Blender and the core module blender-core. Instructions cover UV seam costs, vertex split overheads, and simplified physics collision generation.

What it helps with

  • calculate polygon and material budgets for a target gaming platform
  • generate LOD chains with automated reduction ratios
  • merge materials and texture atlases to lower draw calls
  • clean up hidden interior geometry and unused edge loops
  • set up simplified collision meshes for physics

Example prompts for the agent

  • Optimize the asset hero.blend for mobile platform limits
  • Run the mesh stats script to check triangle and draw call counts
  • Generate LOD chains for the selected character mesh

How to install blender-game-optimization

1Skills CLI (Vercel)

npx skills add EL4CTEO/blender-skills --skill blender-game-optimization -a claude-code

2Manually: put the files in place

~/.claude/skills/blender-game-optimization/SKILL.md

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

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

Questions about blender-game-optimization

How to install blender-game-optimization in Claude Code?

Run npx skills add EL4CTEO/blender-skills --skill blender-game-optimization -a claude-code, then reference ~/.claude/skills/blender-game-optimization/SKILL.md.

What does blender-game-optimization do?

It automates the optimization of Blender 3D assets by checking platform budgets, cleaning meshes, generating LODs, and reducing draw calls.

What is required to run blender-game-optimization?

It requires Blender installed locally and the foundational blender-core module configured in the workspace.

Source text

SKILL.md · MIT
---
name: blender-game-optimization
description: Optimize Blender assets for real-time engines - triangle/material/texture/bone budgets per platform (mobile, Roblox, web, VR, console, PC), LOD chains, decimation modes, mesh cleanup, draw-call reduction (material merging, atlases, trim sheets), instancing, vertex-split costs, collision proxies, texture memory. Use when an asset is too heavy, before export, or when targeting a platform budget.
license: MIT
metadata:
  author: blender-agent-skills
  version: "1.2.0"
---

# Game Optimization

The execution model is in `blender-core`. Always re-run `blender-asset-qa` after optimizing.

## Procedure
1. **Measure**: `scripts/mesh_stats.py -- --objects ... --budget mobile|roblox|web|vr|console|pc`. It returns tris, estimated draw calls, materials, texture VRAM, bones, and the over-budget items.
2. **Clean**: `make_lods.py --cleanup` (merge by distance 0.1 mm, dissolve degenerate, delete loose). Remove hidden faces: back-to-back faces and faces under other parts (`qa_check` → `back_to_back`, plus manual xray).
3. **Reduce in this order** (cheapest visual loss first): hidden/interior geometry → unnecessary edge loops on flat areas (Limited Dissolve 1–5°) → over-segmented cylinders → Decimate → bake detail to normals (`blender-texture-baking`).
4. **Materials**: merge to 1–2 per asset (atlas / trim sheet / shared tiling material). Each material slot per mesh is roughly one draw call.
5. **LODs**: `scripts/make_lods.py -- --objects SM_X --rename` creates `_LOD1.._LOD3` at 50/25/12.5%. Check every LOD silhouette with `look`/`review_shots`.
6. **Re-measure**, then QA, then export (`blender-export-pipelines`).

## Budgets (guidance per asset, 2026)
| Platform | Hero char tris | Prop tris | Mats/asset | Max texture | Bones |
|---|---|---|---|---|---|
| Mobile | 5–15k | 0.3–3k | 1–2 | 1024 | ≤75 |
| Roblox | body ≤10,742 (head 4k, torso 1.75k, limb 1,248); accessory/clothing 4k | ≤20k per MeshPart | 1 (SurfaceAppearance) | 1024 (PBR), 4k max | R15 + optional |
| Web (three.js/Babylon) | 10–30k | 1–10k | 1–2 | 2048 | ≤100 |
| Standalone VR (Quest) | 10–40k | 1–10k | 1–3 | 2048 | ≤100 |
| Console / PC | 50–150k | 5–50k | 2–6 | 4096 | 150–300 |
| UE5 Nanite (static) | — | millions OK | few | 4096+ | n/a |
Whole-scene limits matter more than single assets: mobile ≈ 100–300k tris visible and < 100–200 draw calls; PC ≈ millions of tris and < 2–5k draw calls.

## Decimate modes
| Mode | Use | Notes |
|---|---|---|
| `COLLAPSE` (ratio) | organic, scans, LODs | `use_symmetry`, vertex group factor to protect faces/hands; triangulates |
| `UNSUBDIV` (iterations) | meshes made by subdividing quads | restores the quad grid cleanly |
| `DISSOLVE` (planar, angle) | hard-surface / CAD | delimit `{"SEAM","SHARP","MATERIAL","UV"}`; keeps the silhouette, makes n-gons → triangulate on export |
Protect UV seams and silhouette: decimate a copy, then compare. If UVs tear at LOD1, the ratio is too aggressive for that topology, so re-unwrap or use a manual LOD.

## The hidden cost: vertex splits
GPU vertex count = unique (position, normal, UV, color) combinations. Every UV seam and hard edge **duplicates** vertices, so engine vertex counts are often 1.5–3× Blender's. Minimize seams where they aren't needed, keep hard edges = seams (so the split happens once), and don't add vertex colors or extra UV sets you don't use.

## LOD rules
- Halve the tris per level. Switch at screen size ~0.5 / 0.25 / 0.125 (UE "Screen Size", Unity LOD Group %, Godot `lod_bias` auto).
- LODs keep the same materials (or fewer: merge them at LOD2+), same pivot, same bounds.
- Skeletal LODs: remove finger/face bones at LOD2+ (the engine bone-reduction tools handle this). Keep the skinning on the same skeleton.
- Far LOD / foliage: impostor/billboard. Unreal Nanite (static, opaque/masked) and Godot's auto mesh LOD can replace a hand-made chain.
- Roblox: no manual LODs. `RenderFidelity=Automatic` does it. Keep each MeshPart ≤ 20k tris and use a simple `CollisionFidelity` (Box/Hull) for non-walkable parts.

## Draw calls and batching
- **Merge** static meshes that share a material and are always seen together (join objects). **Don't merge** across large areas, because that defeats frustum/occlusion culling.
- **Instancing**: repeated objects as linked duplicates (Alt+D, shared mesh) or collection instances. They export as instances (glTF `EXT_mesh_gpu_instancing` with `export_gpu_instances`) or as one mesh + transforms in the engine.
- **Atlases/trim sheets**: put many props on one texture set. Trim sheets let walls, panels and pipes share one 2k material.
- **Texture memory** (upper bound, uncompressed RGBA8 + mips): 1k = 5.3 MB, 2k = 21 MB, 4k = 85 MB. Engines compress (BC7/ASTC ≈ 4–8×). Pack grayscale maps into ORM channels to cut it 3×.

## Collision
Keep collision separate and simple: boxes/convex hulls of ≤ 32–255 verts. UE `UCX_<Mesh>_##`, Godot `-colonly`/`-convcolonly` suffix, Unity MeshCollider on a simplified mesh, Roblox `CollisionFidelity`. Never use the render mesh as a physics mesh for anything that moves.

## Rig and animation cost
Limit to 4 influences per vertex (`vertex_group_limit_total(limit=4)` + normalize). Remove non-deforming bones from the export (`use_armature_deform_only`). Bake constraints and drivers to keys. Shape keys cost memory per vertex, so drop unused ones and keep only deltas (glTF sparse accessors handle this).

## Gotchas
- Decimate on meshes with unapplied modifiers: `make_lods.py` evaluates them first. Other paths need you to apply them.
- Join (`Ctrl+J`) merges materials and UV maps by **name**. Rename the UV maps identically first, or the UVs get lost.
- The `Weld` modifier is the non-destructive merge by distance. Use `mode="CONNECTED"` to avoid welding separate parts.
- Triangulate before measuring if the engine will. Quads already count as 2 tris in the stats.

© 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-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-export-pipelines 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. CX Codex +1 681installs 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 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

Project sponsors

Companies that keep this analytics open