Skip to main content Home Creators kevin-liu-01 agent-machines blender-web-pipeline
blender-web-pipeline Blender to web export workflows for 3D models and animations. Use this skill when exporting Blender models to glTF for web, optimizing 3D assets for Three.js or Babylon.js, batch processing models with Python scripts, automating Blender workflows, or creating web-ready 3D pipelines. Triggers on tasks involving Blender glTF export, bpy scripting, 3D asset optimization, model compression, texture baking, or Blender automation. Exports models for threejs-webgl, react-three-fiber, and babylonjs-engine skills.
Jump to install Skills Marketplace Discover and explore AI skills built by the community.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Show prompt details A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/Kevin-Liu-01/Agent-Machines --skill blender-web-pipelineThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Download Zip Downloading... More from this repository How Agent Machines work -- providers (Dedalus, E2B, Sprites), agent runtimes (Hermes, OpenClaw, Claude Code, Codex), MCP catalog, bootstrap, and closed-loop verification. Use when asked about the runtime, scaling, sleep/wake, destroy, or inspecting this environment.
Build landing page sections, hero blocks, and marketing surfaces in the Reticle/Sigil engineering-instrument-grid aesthetic. Use when creating new landing sections, hero components, marketing pages, or when the user says "reticle", "hero", "landing page", "new section", "instrument panel", "grid cell", or wants to match the existing Agent Machines visual language.
Declarative web framework for building browser-based 3D, VR, and AR experiences using HTML and entity-component architecture. Use this skill when creating WebXR applications, VR experiences, AR experiences, 360-degree media viewers, or immersive web content with minimal JavaScript. Triggers on tasks involving A-Frame, WebXR, VR development, AR development, entity-component-system, declarative 3D, or HTML-based 3D scenes. Built on Three.js with accessible HTML-first approach.
Related occupations SOC
Based on SOC occupation classification
name blender-web-pipeline description Blender to web export workflows for 3D models and animations. Use this skill when exporting Blender models to glTF for web, optimizing 3D assets for Three.js or Babylon.js, batch processing models with Python scripts, automating Blender workflows, or creating web-ready 3D pipelines. Triggers on tasks involving Blender glTF export, bpy scripting, 3D asset optimization, model compression, texture baking, or Blender automation. Exports models for threejs-webgl, react-three-fiber, and babylonjs-engine skills.
Blender Web Pipeline
Overview
Blender Web Pipeline skill provides workflows for exporting 3D models and animations from Blender to web-optimized formats (primarily glTF 2.0). It covers Python scripting for batch processing, optimization techniques for web performance, and integration with web 3D libraries like Three.js and Babylon.js.
When to use this skill:
Exporting Blender models for web applications
Batch processing multiple 3D assets
Optimizing file sizes for web delivery
Automating repetitive Blender tasks
Creating production pipelines for 3D web content
Converting legacy formats to glTF
Key capabilities:
glTF 2.0 export with optimization
Python (bpy) automation scripts
Texture baking and compression
LOD (Level of Detail) generation
Batch processing workflows
Material and lighting optimization for web
Core Concepts
glTF 2.0 Format
Why glTF for Web:
Industry-standard 3D format for web
Efficient binary encoding (.glb)
PBR materials support
Animation and skinning
Extensible with custom data
Wide library support (Three.js, Babylon.js, etc.)
glTF vs GLB:
.gltf = JSON + external .bin + external textures
.glb = Single binary file (recommended for web)
Blender Python API (bpy) Access Blender data and operations via Python:
import bpy
scene = bpy.context.scene
objects = bpy.data.objects
obj = bpy.data.objects['Cube' ]
obj.location = (0 , 0 , 1 )
obj.scale = (2 , 2 , 2 )
bpy.ops.export_scene.gltf(
filepath='/path/to/model.glb' ,
export_format='GLB'
)
Web Optimization Goals
File size: <5 MB per model (ideal <1 MB)
Polygon count: <50k triangles for real-time
Texture resolution: 2048x2048 max (1024x1024 preferred)
Draw calls: Minimize via texture atlases
Load time: <2 seconds on average connection
Common Patterns
1. Basic glTF Export (Manual)
import bpy
bpy.ops.object .select_all(action='DESELECT' )
bpy.data.objects['MyModel' ].select_set(True )
bpy.ops.export_scene.gltf(
filepath='/path/to/output.glb' ,
export_format='GLB' ,
use_selection=True ,
export_apply=True ,
export_texcoords=True ,
export_normals=True ,
export_materials='EXPORT' ,
export_colors=True ,
export_cameras=False ,
export_lights=False ,
export_animations=True ,
export_draco_mesh_compression_enable=True ,
export_draco_mesh_compression_level=6 ,
export_draco_position_quantization=14 ,
export_draco_normal_quantization=10 ,
export_draco_texcoord_quantization=12
)
2. Python Script for Batch Export
"""
Batch export all .blend files in a directory to glTF
Usage: blender --background --python batch_export.py -- /path/to/blend/files
"""
import bpy
import os
import sys
argv = sys.argv
argv = argv[argv.index("--" ) + 1 :] if "--" in argv else []
input_dir = argv[0 ] if argv else "/path/to/models"
output_dir = argv[1 ] if len (argv) > 1 else input_dir + "_gltf"
os.makedirs(output_dir, exist_ok=True )
blend_files = [f for f in os.listdir(input_dir) if f.endswith('.blend' )]
print (f"Found {len (blend_files)} .blend files" )
for blend_file in blend_files:
input_path = os.path.join(input_dir, blend_file)
output_name = blend_file.replace('.blend' , '.glb' )
output_path = os.path.join(output_dir, output_name)
print (f"Processing: {blend_file} " )
bpy.ops.wm.open_mainfile(filepath=input_path)
bpy.ops.export_scene.gltf(
filepath=output_path,
export_format='GLB' ,
export_apply=True ,
export_draco_mesh_compression_enable=True ,
export_draco_mesh_compression_level=6
)
print (f" Exported: {output_name} " )
print ("Batch export complete!" )
blender --background --python batch_export.py -- /models/source /models/output
3. Optimize Model for Web (Decimation) import bpy
def optimize_mesh (obj, target_ratio=0.5 ):
"""Reduce polygon count using decimation modifier."""
if obj.type != 'MESH' :
return
decimate = obj.modifiers.new(name='Decimate' , type ='DECIMATE' )
decimate.ratio = target_ratio
decimate.use_collapse_triangulate = True
bpy.context.view_layer.objects.active = obj
bpy.ops.object .modifier_apply(modifier='Decimate' )
print (f"Optimized {obj.name} : {len (obj.data.polygons)} polygons" )
for obj in bpy.context.selected_objects:
optimize_mesh(obj, target_ratio=0.3 )
4. Texture Baking for Web import bpy
def bake_textures (obj, resolution=1024 ):
"""Bake all materials to single texture."""
bpy.context.scene.render.engine = 'CYCLES'
bpy.context.scene.cycles.bake_type = 'COMBINED'
bake_image = bpy.data.images.new(
name=f"{obj.name} _bake" ,
width=resolution,
height=resolution
)
mat = bpy.data.materials.new(name=f"{obj.name} _baked" )
mat.use_nodes = True
nodes = mat.node_tree.nodes
tex_node = nodes.new(type ='ShaderNodeTexImage' )
tex_node.image = bake_image
tex_node.select = True
nodes.active = tex_node
if obj.data.materials:
obj.data.materials[0 ] = mat
else :
obj.data.materials.append(mat)
bpy.context.view_layer.objects.active = obj
obj.select_set(True )
bpy.ops.object .bake(type ='COMBINED' )
bake_image.filepath_raw = f"/tmp/{obj.name} _bake.png"
bake_image.file_format = 'PNG'
bake_image.save()
print (f"Baked {obj.name} to {bake_image.filepath_raw} " )
for obj in bpy.context.selected_objects:
if obj.type == 'MESH' :
bake_textures(obj, resolution=2048 )
5. Generate LOD (Level of Detail) import bpy
def generate_lods (obj, lod_levels=[0.75 , 0.5 , 0.25 ] ):
"""Generate LOD copies with decreasing polygon counts."""
lod_objects = []
for i, ratio in enumerate (lod_levels):
lod_obj = obj.copy()
lod_obj.data = obj.data.copy()
lod_obj.name = f"{obj.name} _LOD{i} "
bpy.context.collection.objects.link(lod_obj)
decimate = lod_obj.modifiers.new(name='Decimate' , type ='DECIMATE' )
decimate.ratio = ratio
bpy.context.view_layer.objects.active = lod_obj
bpy.ops.object .modifier_apply(modifier='Decimate' )
lod_objects.append(lod_obj)
print (f"Created {lod_obj.name} : {len (lod_obj.data.polygons)} polygons" )
return lod_objects
if bpy.context.active_object:
generate_lods(bpy.context.active_object)
6. Export with Texture Compression import bpy
import os
def export_optimized_gltf (filepath, texture_max_size=1024 ):
"""Export glTF with downscaled textures."""
for img in bpy.data.images:
if img.size[0 ] > texture_max_size or img.size[1 ] > texture_max_size:
img.scale(texture_max_size, texture_max_size)
print (f"Downscaled {img.name} to {texture_max_size} x{texture_max_size} " )
bpy.ops.export_scene.gltf(
filepath=filepath,
export_format='GLB' ,
export_apply=True ,
export_image_format='JPEG' ,
export_jpeg_quality=85 ,
export_draco_mesh_compression_enable=True ,
export_draco_mesh_compression_level=8 ,
export_draco_position_quantization=12 ,
export_draco_normal_quantization=8 ,
export_draco_texcoord_quantization=10
)
export_optimized_gltf('/path/to/optimized.glb' , texture_max_size=512 )
7. Command-Line Automation #!/bin/bash
SCRIPT_DIR="$(dirname "$0 " ) "
for blend_file in *.blend; do
echo "Exporting $blend_file ..."
blender --background "$blend_file " --python - <<EOF
import bpy
import os
# Get output filename
filename = os.path.splitext(bpy.data.filepath)[0]
output = filename + '.glb'
# Export
bpy.ops.export_scene.gltf(
filepath=output,
export_format='GLB',
export_apply=True,
export_draco_mesh_compression_enable=True,
export_draco_mesh_compression_level=6
)
print(f'Exported to {output}')
EOF
done
echo "All files exported!"
Integration Patterns
With Three.js import * as THREE from 'three' ;
import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js' ;
import { DRACOLoader } from 'three/addons/loaders/DRACOLoader.js' ;
const loader = new GLTFLoader ();
const dracoLoader = new DRACOLoader ();
dracoLoader.setDecoderPath ('/draco/' );
loader.setDRACOLoader (dracoLoader);
loader.load ('/models/exported.glb' , (gltf ) => {
scene.add (gltf.scene );
if (gltf.animations .length > 0 ) {
const mixer = new THREE .AnimationMixer (gltf.scene );
const action = mixer.clipAction (gltf.animations [0 ]);
action.play ();
}
});
With React Three Fiber import { useGLTF } from '@react-three/drei' ;
function Model (const { scene } = useGLTF ('/models/exported.glb' );
return <primitive object ={scene} /> preload ('/models/exported.glb' );
With Babylon.js import * as BABYLON from '@babylonjs/core' ;
import '@babylonjs/loaders/glTF' ;
BABYLON .SceneLoader .ImportMesh (
'' ,
'/models/' ,
'exported.glb' ,
scene,
(meshes ) => {
console .log ('Loaded meshes:' , meshes);
}
);
Optimization Techniques
1. Geometry Optimization
obj.modifiers.new(name='Decimate' , type ='DECIMATE' )
obj.modifiers['Decimate' ].ratio = 0.3
bpy.ops.object .mode_set(mode='EDIT' )
bpy.ops.mesh.select_all(action='SELECT' )
bpy.ops.mesh.remove_doubles(threshold=0.0001 )
bpy.ops.object .mode_set(mode='OBJECT' )
bpy.ops.object .mode_set(mode='EDIT' )
bpy.ops.mesh.select_all(action='SELECT' )
bpy.ops.mesh.quads_convert_to_tris()
bpy.ops.object .mode_set(mode='OBJECT' )
2. Texture Optimization
for img in bpy.data.images:
img.file_format = 'JPEG'
img.filepath_raw = f"/output/{img.name} .jpg"
img.save()
bpy.ops.object .mode_set(mode='EDIT' )
bpy.ops.mesh.select_all(action='SELECT' )
bpy.ops.uv.smart_project(angle_limit=66 , island_margin=0.02 )
bpy.ops.object .mode_set(mode='OBJECT' )
3. Material Simplification
for mat in bpy.data.materials:
if not mat.use_nodes:
mat.use_nodes = True
nodes = mat.node_tree.nodes
principled = nodes.get('Principled BSDF' )
if not principled:
principled = nodes.new(type ='ShaderNodeBsdfPrincipled' )
output = nodes.get('Material Output' )
mat.node_tree.links.new(principled.outputs[0 ], output.inputs[0 ])
Common Pitfalls
1. Large File Sizes Problem: Exported .glb files are 20+ MB
Enable Draco compression (60-90% reduction)
Reduce texture resolution (2048 → 1024 or 512)
Use JPEG instead of PNG for textures
Decimate geometry (target <50k triangles)
Remove unused materials/textures
2. Missing Textures in Export Problem: Textures don't appear in web viewer
Ensure all images are saved (not packed)
Use relative paths for textures
Export with "Export Images" enabled
Check image format compatibility (PNG/JPEG)
3. Animations Not Playing Problem: Animations don't export or play incorrectly
Ensure animations are on timeline (not NLA strips)
Export with "Export Animations" enabled
Check animation actions are assigned to objects
Use "Bake Actions" for complex rigs
4. Materials Look Different Problem: Materials render differently in web vs Blender
Use Principled BSDF (maps to glTF PBR)
Avoid custom shader nodes (won't export)
Use supported texture types (Base Color, Metallic, Roughness, Normal, Emission)
Test in glTF viewer before deploying
5. Slow Export Times Problem: Export takes 10+ minutes
Apply modifiers before export (don't export non-destructively)
Reduce geometry complexity
Remove unused data (orphan cleanup)
Use command-line export (faster than GUI)
6. Performance Issues in Browser Problem: Model lags in browser
Generate LODs (Level of Detail)
Use instancing for repeated objects
Limit draw calls (merge objects, texture atlases)
Reduce polygon count (<50k triangles)
Optimize shaders (avoid transparency/refraction)
Best Practices
Pre-Export Checklist ☐ Apply all modifiers
☐ Merge vertices (remove doubles)
☐ Triangulate faces (if required)
☐ Optimize polygon count (<50k triangles)
☐ UV unwrap all meshes
☐ Bake materials (if complex)
☐ Resize textures (max 2048x2048)
☐ Use Principled BSDF materials
☐ Remove unused data (orphan cleanup)
☐ Name objects descriptively
☐ Set origin points correctly
☐ Apply transformations (Ctrl+A)
Export Settings
bpy.ops.export_scene.gltf(
filepath='/output.glb' ,
export_format='GLB' ,
export_apply=True ,
export_image_format='JPEG' ,
export_jpeg_quality=85 ,
export_draco_mesh_compression_enable=True ,
export_draco_mesh_compression_level=6 ,
export_animations=True ,
export_lights=False ,
export_cameras=False
)
Resources
scripts/
batch_export.py - Batch export .blend files to glTFoptimize_model.py - Optimize geometry and textures for webgenerate_lods.py - Generate LOD copies automatically
references/
gltf_export_guide.md - Complete glTF export referencebpy_api_reference.md - Blender Python API quick referenceoptimization_strategies.md - Detailed optimization techniques
assets/
export_template.blend - Pre-configured export templateshader_library/ - Web-optimized PBR shaders
Related Skills
threejs-webgl - Load and render exported glTF models in Three.jsreact-three-fiber - Use glTF models in React applicationsbabylonjs-engine - Alternative 3D engine for webplaycanvas-engine - Game engine that supports glTF import 