I Built a Batch Asset Validator for Blender in Python — Here's What I Learned

Mon, 16 Mar 2026 13:58:07 +0000

I Built a Batch Asset Validator for Blender in Python — Here's What I Learned

Game developers and 3D artists deal with a problem that doesn't get talked about enough: you find out your assets are broken after you've already submitted them.

Wrong scale. Tri count way over budget. Missing textures. Unapplied transforms. Negative scale that makes your mesh flip inside-out in Unity. These issues are obvious in hindsight, but catching them manually across a folder of 50 FBX files before every export is the kind of tedious work that either doesn't happen, or happens inconsistently.

So I built AssetSentinel — a Blender addon that batch validates FBX and glTF assets against a target platform profile before they leave your machine. Here's the technical breakdown of how it works, what I ran into building it, and a full demo video at the end.

The Core Problem: Validation Belongs Before Export, Not After

Most 3D pipelines look like this:

Model → Export FBX/glTF → Import to Engine → Discover problem → Go back to Blender

The discovery step is the expensive one. If you're submitting to a marketplace like Fab or CGTrader, a rejection costs you review time. If you're a studio delivering to a client, it costs credibility. The fix is moving validation to before the export step:

Model → Validate → Fix → Export FBX/glTF → Import to Engine

That's what AssetSentinel does.

How It Works: Temp Scene Import Loop

The core mechanism is a modal operator that imports each file into a temporary Blender scene, runs a series of checks, then destroys the scene and moves to the next file. This keeps the user's working scene completely untouched.

def _evaluate_in_temp_scene(context, path: str, profile: dict) -> dict:
    win = context.window
    orig_scene = win.scene
    temp_scene = bpy.data.scenes.new(name="ASSETSENTINEL_TEMP")
    win.scene = temp_scene
    try:
        _import_file(path)
        # run all checks here
        tris, verts = _tri_vert_counts()
        ngons = _ngon_count()
        # ... more checks
    except Exception:
        # classify the import failure
        detail = _tb_last_meaningful_line(traceback.format_exc())
        ftype, suggestion = _classify_import_failure(detail)
    finally:
        win.scene = orig_scene
        bpy.data.scenes.remove(temp_scene)
        bpy.ops.outliner.orphans_purge(do_recursive=True)

The finally block is non-negotiable. You have to restore the original scene and purge orphan data whether the import succeeded or failed — otherwise you accumulate stale mesh data across every file in the batch.

Blender's UI locks up if you run long operations on the main thread. The solution is a modal operator driven by a timer event. Each tick of the timer processes one file, then yields back to Blender so the UI stays responsive and the user can cancel with ESC.

def modal(self, context, event):
    wm = context.window_manager
    if event.type == "ESC":
        wm.assetsentinel_cancel_requested = True
    if event.type != "TIMER":
        return {"PASS_THROUGH"}
    if self._idx >= len(self._files):
        wm.assetsentinel_status = "Done"
        return self._finish(context, cancelled=False)
    # process one file per tick
    path = self._files[self._idx]
    res = _evaluate_in_temp_scene(context, path, prof)
    self._results.append(res)
    self._idx += 1
    wm.assetsentinel_progress = int((self._idx / len(self._files)) * 100)
    return {"RUNNING_MODAL"}

The timer interval is 0.1 seconds. Fast enough to feel responsive, slow enough not to hammer the CPU.

Profile-Based Validation

Rather than hardcoding limits, AssetSentinel uses JSON profiles — one per target platform. Each profile defines the limits that matter for that destination:

{
  "UNITY_MOBILE": {
    "label": "Unity - Mobile",
    "max_tris": 20000,
    "max_texture_res": 2048,
    "max_material_slots": 4,
    "lod_required": true,
    "no_spaces": true,
    "min_bbox_m": 0.05,
    "max_bbox_m": 10.0,
    "tri_over_is_error": true,
    "lod_missing_is_error": false
  }
}

The _is_error flags per rule let you configure severity independently. A tri count violation might be a hard error on mobile, but only a warning on desktop. The profile system auto-merges on load — if a user has an older profiles.json, new keys from the defaults get added without losing their custom values.

The Checks

Here's what runs on every imported asset:

Geometry:

Triangle and vertex count via me.calc_loop_triangles() — falls back to bmesh triangulate if that fails
Ngon detection by checking p.loop_total > 4 on every polygon
Negative scale on any axis
Unapplied transforms (scale/rotation not at identity)

Textures:

Total image count from bpy.data.images
External file resolution — whether the filepath exists on disk
Max texture resolution from img.size[0] and img.size[1]
Missing external textures list

Naming:

Regex match against allowed_name_chars from the profile
Space detection in object and material names

Scale:

World-space bounding box via evaluated_get(depsgraph).bound_box
Compared against min_bbox_m and max_bbox_m in the profile

LOD:

Name-based detection — checks for _LOD0, _LOD1, _LOD2, _LOD3 substrings

Import Failure Classification

One of the more useful features: when an import fails, it doesn't just say "import error." It classifies the failure and suggests a fix:

def _classify_import_failure(detail_line: str) -> tuple[str, str]:
    s = (detail_line or "").lower()
    if "khr_texture_basisu" in s:
        return (
            "UNSUPPORTED_EXTENSION",
            "Re-export without BasisU/KHR_texture_basisu and try again."
        )
    if "bad gltf" in s and "json error" in s:
        return (
            "INVALID_GLTF",
            "The glTF/GLB appears corrupted. Re-export from your DCC."
        )
    return ("UNKNOWN", "Try re-exporting and verify the file opens in Blender.")

This is genuinely useful in practice. KHR_texture_basisu failures come up frequently with AI-generated GLB files and photogrammetry exports. The error message from Blender's importer isn't helpful on its own — this surfaces the actual fix.

The HTML Report

After the scan, results are exported as an HTML report with a CSV alongside it. The report uses a dark theme, shows per-asset pass/warning/fail status with a triangle count bar against the profile limit, and includes filter controls to show only failed or warning assets.

The report also surfaces "top violations" — which checks failed most frequently across the batch. On a folder of 26 game assets, the most common failures were tri count overages and suspicious bounding box scales. Both are things that would have caused problems in the engine.

Watch the Full Demo

[embed: https://www.youtube.com/watch?v=64qQiMLCSD0]

The video walks through a real batch scan of 26 assets against the Unreal Desktop profile — showing the scan running, reading the HTML report, and interpreting the results.

Get the Addon

AssetSentinel is available on Superhive (Blender Market): https://superhivemarket.com/products/assetsentinel

Supports Blender 3.6 and above. No external dependencies — pure Python, no PyPI packages.

What I'd Do Differently

A few things I'd approach differently if I started over:

Results storage. I'm serialising the results to JSON and storing them in a WindowManager property string. It works but it's awkward — a proper addon-level data store would be cleaner.

The modal pattern. The timer-based modal is the right approach for Blender, but the 0.1s interval is a guess. A smarter approach would adapt the interval based on file size or import time.

Profile UI. Right now profiles are JSON files edited externally. An in-panel profile editor would make this accessible to artists who don't want to touch JSON.

Happy to answer questions about any part of the implementation — drop them in the comments.

Coder Legion - Recent posts tagged automate

I Built a Batch Asset Validator for Blender in Python — Here's What I Learned