The Rosetta Stone - The Same Task In Maya, Blender & Unreal

The Three Worldviews (Read This First)

	Maya cmds	Blender bpy	Unreal Python
Everything is...	a string (node names)	an object (`bpy.data`)	an asset (packages on disk)
You mostly...	call flat commands on names	walk object properties	ask subsystems & libraries
Selection is...	central - most cmds act on it	context-dependent (the classic gotcha)	barely a thing - you work on asset paths
Classic gotcha	duplicate names break everything - use long paths	ops need the right context/mode	loading assets is slow - filter via the registry first

Hold onto this: Maya asks "what is it called?", Blender asks "where does it live in the data?", Unreal asks "which subsystem owns this?". Once that clicks, the rest is documentation lookup.

Task 1 - Report Meshes Over A Triangle Budget

Maya

import maya.cmds as cmds

BUDGET = 10000
for mesh in cmds.ls(type="mesh", noIntermediate=True, long=True):
 tris = cmds.polyEvaluate(mesh, triangle=True)
 if tris > BUDGET:
 print(f"{mesh} {tris} tris")

Blender

import bpy

BUDGET = 10000
for ob in bpy.data.objects:
 if ob.type != "MESH": continue
 tris = sum(len(p.vertices) - 2 for p in ob.data.polygons)
 if tris > BUDGET:
 print(f"{ob.name} {tris} tris")

Unreal

import unreal

BUDGET = 10000
reg = unreal.AssetRegistryHelpers.get_asset_registry()
for data in reg.get_assets_by_class(
 unreal.TopLevelAssetPath("/Script/Engine", "StaticMesh"), True):
 mesh = unreal.EditorAssetLibrary.load_asset(str(data.package_name))
 tris = mesh.get_num_triangles(0) # LOD 0
 if tris > BUDGET:
 print(f"{mesh.get_name()} {tris} tris")

What transfers: the shape - enumerate, measure, compare, report. What doesn't: Maya counts via a query command on a name; Blender computes from raw geometry data (you calculate the result from the geometry); Unreal makes you load each asset, which is why real audit scripts filter with the registry before loading anything.

Task 2 - Export Selection To FBX

Maya

import maya.cmds as cmds

cmds.loadPlugin("fbxmaya", quiet=True)
cmds.file(r"D:/exports/prop.fbx", force=True,
 exportSelected=True, type="FBX export",
 options="v=0")

Blender

import bpy

bpy.ops.export_scene.fbx(
 filepath=r"D:/exports/prop.fbx",
 use_selection=True,
 apply_scale_options="FBX_SCALE_ALL", # UE-friendly scale
 bake_space_transform=True) # fixes the axis dance

Unreal

import unreal

# Unreal is usually the DESTINATION - its export is for round-trips
task = unreal.AssetExportTask()
task.object = unreal.EditorAssetLibrary.load_asset("/Game/Props/SM_Crate")
task.filename = r"D:/exports/SM_Crate.fbx"
task.automated = True
unreal.Exporter.run_asset_export_task(task)

What transfers: exports are configuration problems, not code problems - the flags are the work. What doesn't: the asymmetry. Maya and Blender are usually sources, Unreal a destination; a "pipeline" is mostly agreeing on the flags once and burying them in a shared preset so the team uses the same tested settings. (That's the Blender starter kit in one sentence.)

Task 3 - Enforce A Naming Convention

Maya

import maya.cmds as cmds, re

RULE = re.compile(r"^SM_[A-Z][A-Za-z0-9_]*$")
for xform in cmds.ls(type="transform", long=True):
 short = xform.rsplit("|", 1)[-1]
 if cmds.listRelatives(xform, shapes=True, type="mesh") and not RULE.match(short):
 print("BAD NAME:", short)

Blender

import bpy, re

RULE = re.compile(r"^SM_[A-Z][A-Za-z0-9_]*$")
for ob in bpy.data.objects:
 if ob.type == "MESH" and not RULE.match(ob.name):
 print("BAD NAME:", ob.name)

Unreal

import unreal, re

RULE = re.compile(r"^SM_[A-Z][A-Za-z0-9_]*$")
reg = unreal.AssetRegistryHelpers.get_asset_registry()
for data in reg.get_assets_by_class(
 unreal.TopLevelAssetPath("/Script/Engine", "StaticMesh"), True):
 name = str(data.asset_name)
 if not RULE.match(name):
 print("BAD NAME:", str(data.package_name))

What transfers: the regex - literally the same line in all three, which is the whole argument for learning regex once. Note Unreal never loads an asset here: names live in the registry, which avoids loading each asset just to check its name. Generate the regex (and this validator) with the Naming Forge.

Task 4 - Find Meshes With No UVs

Maya

import maya.cmds as cmds

for mesh in cmds.ls(type="mesh", noIntermediate=True, long=True):
 uv_count = cmds.polyEvaluate(mesh, uvcoord=True)
 if not uv_count:
 print("NO UVs:", mesh)

Blender

import bpy

for ob in bpy.data.objects:
 if ob.type == "MESH" and not ob.data.uv_layers:
 print("NO UVs:", ob.name)

Unreal

import unreal

reg = unreal.AssetRegistryHelpers.get_asset_registry()
for data in reg.get_assets_by_class(
 unreal.TopLevelAssetPath("/Script/Engine", "StaticMesh"), True):
 mesh = unreal.EditorAssetLibrary.load_asset(str(data.package_name))
 if mesh.get_num_uv_channels(0) == 0:
 print("NO UVs:", mesh.get_name())

Task 5 - Write & Read Custom Metadata

Maya

import maya.cmds as cmds

obj = cmds.ls(selection=True)[0]
if not cmds.attributeQuery("lodGroup", node=obj, exists=True):
 cmds.addAttr(obj, longName="lodGroup", dataType="string")
cmds.setAttr(obj + ".lodGroup", "prop_small", type="string")

print(cmds.getAttr(obj + ".lodGroup"))

Blender

import bpy

ob = bpy.context.active_object
ob["lodGroup"] = "prop_small" # custom properties are just dict access

print(ob["lodGroup"])
# tick "Custom Properties" in the FBX exporter to carry these to engine

Unreal

import unreal

asset = unreal.EditorAssetLibrary.load_asset("/Game/Props/SM_Crate")
unreal.EditorAssetLibrary.set_metadata_tag(asset, "lodGroup", "prop_small")

print(unreal.EditorAssetLibrary.get_metadata_tag(asset, "lodGroup"))
# metadata tags are also searchable from the asset registry

What transfers: metadata is the connective tissue of pipelines - author it at the source, read it at the destination, and suddenly your importer knows things no filename could carry. The three-API chain above (Blender property -> FBX -> Unreal tag) is a complete mini-pipeline.

Task 6 - Give Your Tool A Button

Maya

import maya.cmds as cmds

if cmds.menu("taMenu", exists=True):
 cmds.deleteUI("taMenu")
menu = cmds.menu("taMenu", label="TA Tools",
 parent="MayaWindow", tearOff=True)
cmds.menuItem(label="Audit Scene",
 command=lambda *_: print("auditing..."))

Blender

import bpy

class TA_OT_audit(bpy.types.Operator):
 bl_idname = "ta.audit_scene"
 bl_label = "Audit Scene"
 def execute(self, context):
 print("auditing...")
 return {"FINISHED"}

def menu_draw(self, context):
 self.layout.operator("ta.audit_scene")

bpy.utils.register_class(TA_OT_audit)
bpy.types.VIEW3D_MT_object.append(menu_draw)

Unreal

import unreal

menus = unreal.ToolMenus.get()
menu = menus.find_menu("LevelEditor.MainMenu")
ta = menu.add_sub_menu("TA", "Tools", "TAMenu", "TA Tools")

entry = unreal.ToolMenuEntry(
 name="AuditScene", type=unreal.MultiBlockType.MENU_ENTRY)
entry.set_label("Audit Scene")
entry.set_string_command(
 unreal.ToolMenuStringCommandType.PYTHON, "",
 "print('auditing...')")
ta.add_menu_entry("Scripts", entry)
menus.refresh_all_widgets()

What transfers: making the tool accessible in the workflow where it will be used. Blender's ceremony (operator classes, registration) looks heavy next to Maya's two-liner, but it buys you undo integration, search, and keymaps for free - each DCC's "extra work" usually pays for something.

A practical example

Try sketching the same task in each application before copying an example. The useful pattern is often the same: collect the inputs, validate them, perform the operation, and report the result. The API calls will change, but that structure gives you a starting point when learning another DCC.

<- Reference

Python Snippet Library

Build ->

First Pipeline Script