Avoiding Bpy.Ops Functions For Better Performance With Blender’S Python Api

The Problem with bpy.ops

bpy.ops functions allow scripts to execute Blender operators, which are tools that perform actions on data like meshes, objects, and materials. However, using bpy.ops has some key downsides:

• bpy.ops functions route operators through Blender’s interface and dependency graph, adding overhead compared to directly accessing data
• This makes scripts that heavily rely on bpy.ops significantly slower than those that use Blender’s data API

In tests, a script that creates 1,000 cubes with bpy.ops.mesh.primitive_cube_add() can take over 30 seconds to complete. A script that creates 1,000 cubes by directly adding new mesh data runs nearly 300 times faster.

Leveraging Blender’s Data API

To avoid the interface overhead of bpy.ops, scripts can directly access and modify the same scene data that operators change. This allows bypassing the interface and editing data much more efficiently.

For example, this script creates a new mesh cube and object using the data API:

import bpy
from mathutils import Vector

verts = [Vector(v) for v in [(-1, -1, -1), (-1, -1, 1), (-1, 1, -1), (-1, 1, 1), (1, -1, -1), (1, -1, 1), (1, 1, -1), (1, 1, 1)]] 
edges = []
faces = [[0, 1, 3, 2], [6, 7, 5, 4], [0, 4, 6, 2], [1, 5, 7, 3], [4, 5, 1, 0], [2, 3, 7, 6]]

mesh = bpy.data.meshes.new("Cube")
mesh.from_pydata(verts, edges, faces)

object = bpy.data.objects.new("Cube", mesh)
bpy.context.collection.objects.link(object)

By constructing mesh data and linking an object rather than using bpy.ops.mesh.primitive_cube_add(), this script runs over 10 times faster than the operator approach.

Common Operators to Avoid

Some categories of operators like mesh and object operators have direct data API alternatives that can speed up scripts.

bpy.ops.mesh Functions and Alternatives

bpy.ops.mesh Function	Faster Alternative
bpy.ops.mesh.primitive_cube_add()	Directly create mesh cube data
bpy.ops.mesh.subdivide()	bpy.ops.subdivide()
bpy.ops.mesh.loopcut_slide()	Change mesh topology with bmesh

bpy.ops.object Functions and Alternatives

bpy.ops.object Function	Faster Alternative
bpy.ops.object.duplicate()	bpy.data.objects.new_from_object()
bpy.ops.object.delete()	bpy.data.objects.remove()
bpy.ops.object.modifier_add()	Directly access object modifiers

Best Practices

To optimize Blender Python scripts for speed, follow these guidelines:

• Use the data API over operators when possible – Access mesh, object, and other data directly instead of using operators
• Only use operators when necessary – If an operator has no data API equivalent, minimize its use
• Combine operators to limit interface overhead – When operators are needed, group them so interface is accessed less frequently

For example, this script uses the best practices for quickly batch renaming objects:

import bpy

objects = bpy.data.objects 

bpy.ops.object.select_all(action='DESELECT')

for obj in objects:
  obj.select_set(True) 
  
  # Combine operators so interface only accessed once
  bpy.ops.object.rename(name="NewName")    
  
  obj.select_set(False)

By selecting all objects first rather than calling the rename operator separately on each object, the overhead of accessing the interface is reduced.

Frequently Asked Questions

Why are bpy.ops functions slower than directly accessing data?

bpy.ops goes through Blender’s interface code and dependency graph before running tools. This adds levels of abstraction that create overhead compared to directly editing scene data.

When should I still use operators in my scripts?

Operators are still preferred in some cases like undo support, custom interface tools, and functionality that has no data API access like grease pencil tools.

How much speedup can I expect from avoiding operators?

In many benchmarks, scripts optimized with the data API run over 25-100x faster than heavy operator use. Gains depend on the types of operations performed.

What are some examples optimizing slow bpy.ops functions?

Common optimizations include replacing bpy.ops.mesh creation functions with direct mesh data access and using bpy.data object methods instead of bpy.ops.object operator equivalents.

Is bpy.ops.mesh the only category I should optimize?

No, most categories of Blender operators like object, physics, modifier operators have potential for optimization using Blender’s data API.