Introduction
- Python-based auto-rigging tool built in Maya
- Developed through multiple iterations, evolving from hard-coded to modular systems
- Utilizes a guide skeleton and naming conventions to generate rigs procedurally
- Prefix system enables reuse across left and right sides
- Includes IK/FK limbs, ribbon and FK spine
Script link to Github here: https://github.com/AliensExist/JonasMayaAutoRigger
Core Logic
I moved from hard-coded scripts to a more modular, prefix-based system driven by naming conventions. By using a guide skeleton as the input, the tool procedurally generates the rig. This modularity allows the same limb functions to be reused across any number of arms or legs simply by swapping prefixes. (Example of prefix system use)
The Spine Systems
I implemented a dual-spine approach:
FK Spine: A direct rotation chain that also acts as a driver for the ribbon, giving animators both broad mechanical control and subtle deformation.
Ribbon Spine: Uses a NURBS surface with follicles to drive joints
Stability: To keep the movement predictable, I used aim constraints and offset groups. This setup ensures the mid-control behaves naturally when the spine twists, preventing the mesh from “glitching” or collapsing.
Integration: The entire ribbon is designed to be procedural, so the number of joints or follicles can be easily adjusted in the code to fit different character heights.
(Example where the ribbon function was used)
Limb Logic (IK/FK & Foot)
Each limb generates three chains (IK, FK, and Result) with a blending switch.
Arms: Includes finger articulation driven by the same “lollipop” utility, with added attributes for fist and splay poses.
Legs: Features a reverse-foot setup with custom attributes for heel roll, toe break, and banking. (example of the banking function used)
Assembly System
The assembly function connects all generated systems into a final rig structure. Result joints are constrained back to the original skeleton to drive deformation. Legs, arms, and spine systems are integrated through parent constraints. The ribbon and FK spine systems are also interconnected for combined behavior. The script ensures correct hierarchy order by rebuilding joint lists and reversing them when needed. This step transforms separate modules into a cohesive rig. It reflects a pipeline mindset where systems are built independently and assembled at the end.
Reflection & Improvements
This tool successfully moved from a hard-coded script to a modular rigging framework. By using prefix-based logic and naming conventions, the system is now more scalable and handles diverse character archetypes with minimal manual setup.
Key areas for continued development:
Pipeline Integration: Refining dependency management for even faster “one-click” rig rebuilding.
PySide UI: Add the existing rigging functions under a tab in current rigging UI
Math based soulution: Adding IK that uses the true angle for the pole vector