interpBlendShape is a custom MPxDeformerNode and target-authoring workflow for Autodesk Maya. It extends conventional blend-shape deformation with NURBS-surface interpolation, target and in-between management, paintable weights, direct component editing, and surface-aware Sticky and Smooth sculpt brushes.

Version 1.1.0 includes interactive sculpt preview, undoable strokes, dense-mesh prewarming, and deferred target transfers for direct vertex edits and sculpt brushes. The Edit column shows pending changes and transfer state, and commits happen automatically at editing boundaries. The deformer supports TBB-parallel CPU evaluation and an optional OpenCL Maya GPU Override path.

The Windows build documented here targets Autodesk Maya 2024, Windows x64, and an AVX2-capable CPU. GPU evaluation also needs a compatible OpenCL device and runtime; CPU evaluation is available. Other Maya releases and operating systems require a separately built and tested plug-in.

A module package uses the following layout. Keep the module file and its matching plug-in, scripts, and resources together.

InterpBlendShape/
├── interpBlendShape.mod
└── interpBlendShape/
    ├── plug-ins/interpBlendShape.mll
    ├── icons/
    ├── AETemplates/
    └── scripts/
        ├── interpBlendShape_ui.py
        ├── interpBlendShape_activation.py
        └── resources/LICENSE.txt

1. Close Maya before replacing an installed build.
2. Extract the module package into a permanent folder. Add that folder to MAYA_MODULE_PATH, or place the module file and its sibling folder in your Maya user modules directory.
3. Start Maya 2024 and load interpBlendShape in Plug-in Manager, then open the editor with the code below.
4. Complete offline activation before creating or evaluating target geometry.

import maya.cmds as cmds

cmds.loadPlugin("interpBlendShape", quiet=True)
print(cmds.pluginInfo("interpBlendShape", query=True, path=True))
from interpBlendShape_ui import showUI
showUI()

Create a deformer: select one or more matching target meshes first, select the base mesh last, then choose Create → Create InterpBlendShape. Selecting only the base creates a node without an initial target.

Add a target: select a target mesh, select the InterpBlendShape node or a target row in the editor, then choose Create → Add Selection as Target. With no valid target selected, the command creates an empty target.

Add an in-between: select the in-between mesh and its parent target row, choose Create → Add Selection as In-Between Target, and enter a weight strictly between 0.0 and 1.0.

The editor manages targets, in-betweens, weights, cache state, live mode, surface assignment, and edit tools. Target operations include duplicate, merge, split, rebuild, mirror, and flip. Drag and drop can reorder targets, and column layout is saved per user.

Sticky and Smooth use a private preview mesh. The Edit column keeps its short mode label and adds an amber dot when changes are pending. See Editing & Automatic Commit for transfer timing and status indicators.

The affected target’s weight controls are unavailable while edits are pending or transferring. They also remain unavailable while Sticky, Smooth, or a Maya mesh sculpt brush is active. Leave the brush to adjust weights and inspect the committed result.

Direct vertex edits, Maya mesh brushes, and Sticky/Smooth strokes update the visible mesh as you work. Changes are accumulated without copying the full target mesh after every drag or stroke.

Pending edits transfer automatically when you:

• Leave the current tool or switch to another tool.
• Change the target or in-between being edited.
• Turn Edit off.
• Save the scene.

No manual Apply step is required. Saving transfers pending edits before writing the scene. You can continue editing afterward; new changes wait for the next automatic commit.

The amber Edit dot tracks uncommitted edits. The separate Cache column describes target-cache readiness.

Create an interpBlendShape node on a mesh or NURBS curve. The node inherits from MPxDeformerNode and follows the standard Maya deformer connection convention (inputGeom / outputGeom).

# Create node on selected mesh
mc.deformer("pSphere1", type="interpBlendShape")

The node ships with optional OpenCL GPU acceleration support, registered via MPxGPUStandardDeformer. The GPU path handles all deformation modes — non-UV blend, UV blend, and Bezier blend — fully on the GPU, allowing the deformer to benefit from Maya's parallel evaluation graph when GPU override is active.

GPU evaluation uses the same cached data built during the CPU bind pass, so there is no extra bind cost when switching between evaluation modes. The node automatically falls back to CPU evaluation if GPU resources are unavailable or if the Evaluation Manager has GPU override disabled for the node.

The Sticky/Smooth sculpt workflow also uses GPU-assisted surface processing when available, with a CPU fallback. This interactive sculpt path is separate from Maya’s deformer GPU Override decision.

Built for dense meshes, many active targets, and GPU-accelerated inbetween playback.

* In the inbetween test, Maya fell back to CPU with GPU Override enabled; interpBlendShape ran on GPU. These figures describe the reported benchmark workloads and builds. Results depend on Maya version, hardware, target setup, and evaluation mode. Brush interaction and final edit transfers have separate costs.

Dense mesh performance as target count grows

1,000,000 vertices. The measured GPU playback advantage grows as more targets are active.

About these measurements

Controlled tests used Maya 2024, an Intel Core i7-10700, and an RTX 2060 SUPER, with Cached Playback off. Results are medians of five trials on 10K and 100K meshes; the overall comparison uses 100K vertices and eight active groups with dense targets. Playback FPS measures actual viewport playback; CPU read and redraw times measure different parts of evaluation. The 1M-vertex chart uses separately reported tests with GPU Override enabled for EMP. Maya used CPU fallback in the controlled inbetween GPU comparisons, as marked above. Performance varies with scene setup.

Each entry in inputTargetGroup[] defines one blend target and its behaviour. These are children of inputTarget[geomIndex].inputTargetGroup[targetIndex].

The inputSurface[] compound array holds one or more guide NURBS surfaces used for UV-blend operations.

Sticky and Smooth provide undoable strokes with interactive Viewport 2.0 preview. The default session brush radius is 15.0. Hold B and left-drag to adjust radius, or M and left-drag to adjust strength.

Activating a sculpt mode prewarms the spatial and surface data needed by both Sticky and Smooth. Dense meshes can briefly show a preparation progress state before the brush is ready. Prewarming on activation avoids placing that cold-start cost on the first stroke.

While Sticky is active, hold Shift to temporarily use Smooth; releasing Shift returns to Sticky. If Smooth is already the active mode, Shift does not change the mode.

The editor’s Cache column reflects the node’s current per-target state. Creation and target-add callbacks are synchronized with an immediate state check so fast cache completion is not missed.

UV blend mode projects each vertex onto a guide NURBS surface at bind time, stores UV coordinates and a tangent-space delta, then re-evaluates the surface at the blended UV each frame. This allows deformation targets to slide with the surface normal and tangent frame rather than blending naively in object space.

# Enable UV blend on target group 0
mc.setAttr("interpBlendShape1.inputTarget[0].inputTargetGroup[0].targetBlendUV", 1)
mc.setAttr("interpBlendShape1.inputTarget[0].inputTargetGroup[0].targetSurfaceId", 0)

# Connect guide surface
mc.connectAttr(
    "nurbsSurface1.worldSpace[0]",
    "interpBlendShape1.inputSurface[0].inputTargetSurface"
)

When targetBlendBezier is enabled, inbetween targets act as Bezier control points. With one inbetween the path is quadratic; with two it is cubic; additional inbetweens use de Casteljau evaluation.

The targetCurvature attribute scales how far the middle control points pull away from the chord. A value of 0 collapses all arcs to straight lines; 1 (default) uses the authored control-point positions; higher values amplify the arc.

Live blend (targetBlendLive) bypasses the target data cache and recomputes closest-point evaluation per frame directly from the connected target geometry. This is useful for corrective shapes driven by animated meshes, but carries a per-frame closest-point cost. For static targets, always leave live blend off.

Multiple entries in inputTargetItem[] create an inbetween sequence. Item logical index encodes weight: index 5000 = weight 0, index 6000 = weight 1.0, index 5500 = weight 0.5. The deformer linearly interpolates between adjacent items based on the current weight[] value.

# Index = 5000 + (weight * 1000)
# weight 0.0 → index 5000
# weight 0.5 → index 5500
# weight 1.0 → index 6000
inbetween_index = 5000 + int(weight * 1000)

The deformer exposes base weights (a per-vertex envelope applied to all targets), target weights (per-target influence), and target-offset weights (a mask for surface attach / peel-off). They can be edited with Maya’s paintable-deformer workflow or the InterpBlendShape editor.

Target weights support two additional per-target controls:

The interpBlendShape command adds connected targets, creates empty targets, and removes target data from an existing deformer. It operates in edit mode only and is fully undoable. Targets can be full-weight shapes or in-between shapes at fractional weights.

The interpBlendShapeEdit command mirrors, flips, splits, duplicates, merges, or rebuilds target data. Geometry edits trigger the appropriate partial rebind on the affected group. The command supports mesh and NURBS curve targets where applicable and is fully undoable.

Internally it uses a BVH (Bounding Volume Hierarchy) for fast closest-vertex lookup during mirroring, and supports four surface association modes for controlling how mirrored deltas are sampled from the source side.

The copyInterpBlendWeights command copies, mirrors, or flips per-vertex weight maps between deformer nodes. It works with both standard Maya blendShape nodes and interpBlendShape nodes as source or destination. The command is fully undoable and uses TBB parallelism and a BVH for fast mirrored-vertex lookup on large meshes.

Measured on a 250K vertex mesh. The cluster column is included as a reference comparison for weight painting workflows — not a direct equivalent. NA indicates the operation is not supported by that deformer.

Enable profilingEnabled to print averaged per-section timing to the Script Editor. Results are averaged over profilingSampleRate frames to smooth per-frame variance before printing. The accumulator resets automatically after each report.

# Enable profiling, print every 60 frames
mc.setAttr("interpBlendShape1.profilingEnabled", 1)
mc.setAttr("interpBlendShape1.profilingSampleRate", 60)

[InterpBlendShape Timing] interpBlendShape1[0] avg(30)
  total=2.14ms (467 fps)
  surfCache=0.00 | targetCache=0.00 | partialCache=0.00
  envW=0.01 | baseW=0.00 | targetLoop=2.12
  uvLoop=1.87 | uvEval=1.54 | nonUvLoop=0.25

Wrong build loaded: run the code below. If the path or version is wrong, close the editor and restart Maya before loading the intended build.

import maya.cmds as cmds
print(cmds.pluginInfo("interpBlendShape", query=True, path=True))
print(cmds.pluginInfo("interpBlendShape", query=True, version=True))

Edit state out of sync: choose Help → Troubleshooting → Refresh Edit Mode. Use Print Diagnostics to create a support report in the Script Editor.

Amber dot after editing: changes are still pending. Leave the tool, turn Edit off, change targets, or save to transfer them automatically.

Three dots and a brief pause: Maya is copying pending edits and rebuilding the output. Dense meshes and UV/surface binding can make the final commit take a few seconds.

Transfer failed or saving was cancelled: edits remain pending. Restore a deleted target or fix the reported issue, then retry. Keep the scene open until the transfer succeeds.

Target topology does not match: use the base mesh’s vertex count, vertex order, and polygon connectivity. UV Blend does not remap incompatible mesh topology for sculpt editing.

Weight controls are disabled: finish the transfer and leave the active sculpt brush before changing the edited target’s weight.

Cache shows Failed: confirm matching topology, review the Script Editor message, then click the cache state to retry.

GPU unavailable: enable Parallel evaluation and GPU Override, and confirm Maya recognizes a compatible OpenCL device. CPU fallback remains available.

Activation required: choose Help → Activate License..., export a request for this computer, and import its signed license. A license from another computer will not activate this machine.

License agreement appears repeatedly: confirm Maya can write the current user’s preferences. Acceptance is stored locally with the InterpBlendShape UI settings.

The plug-in requires a signed, machine-bound, perpetual offline license for authoring, CPU/GPU evaluation, playback, and rendering. Each workstation and render machine needs its own activation. Maya can load the plug-in and open the activation dialog before activation; geometry evaluation requires a valid license.

There is no hardcoded expiry date or internet check. Windows reinstallation and RAM, GPU, or disk replacement normally preserve the hardware binding. A motherboard replacement or firmware identity change requires a new activation request.

1. Open Help → Activate License... in the editor.
2. Click Export Request… and send the JSON request to your license provider.
3. Click Import License… to import the signed .ibslic file returned for this computer.
4. Confirm the dialog reports Activated, then retry node creation or evaluation.

from interpBlendShape_activation import showUI
showUI()

import maya.cmds as cmds
print(cmds.interpBlendShapeLicense(status=True))
print(cmds.interpBlendShapeLicense(licensePath=True))

The default Windows license location is %LOCALAPPDATA%/InterpBlendShape/license.ibslic. A studio can set INTERPBLENDSHAPE_LICENSE_PATH to an explicit license-file path; the file still needs a valid signature and must match the current computer.

The first editor launch displays the InterpBlendShape End User License Agreement. Acceptance is stored for the current OS user and is requested again only when the agreement version changes. The agreement can be reviewed later from Help → License Agreement.

Individual and Studio license terms below apply in addition to machine activation. Individual users also need a signed activation file.

• Independent individuals and freelancers may use InterpBlendShape without charge on personally controlled equipment, including for paid freelance work.
• Use by or within a studio, company, organization, production team, educational institution, or government body requires a separate Studio License.
• An organization cannot satisfy its Studio License requirement by having workers obtain multiple Individual Licenses.
• Baked or exported deliverables that no longer depend on the plug-in do not require the recipient to hold a license.
• A recipient that loads, evaluates, edits, or renders a scene or rig requiring InterpBlendShape must hold the appropriate license.