Kraken Rigging Framework
- Role
- Software development, UI/UX design
- Team
- Hybride VFX & Fabric Engine
- Timeline
- 2014–2017
- Platform
- Maya, Softimage and 3ds Max

In one sentence
Kraken was a Python framework that generated character rigs from code instead of by hand. It started as a Softimage-only framework but expanded once Fabric Engine released its Splice plug-ins for Maya and Softimage, which allowed it to become cross-platform.
Stage 1
Hybride VFX
When I joined Hybride, rigs were built by hand and exported in Softimage's proprietary format, so every fix had to be applied manually, one asset at a time. Without a standardized, code-driven framework, the studio couldn't regenerate rigs at scale, which limited the number and complexity of projects it could take on.
Goals
- Establish a standardized rig-building framework where none existed before.
- Allow for rapid reproduction of rigs at scale instead of using version-locked, hand-crafted and hand-corrected components. Expand capacity to handle more complex projects.
- Make it cross-platform so the same rig worked identically in Maya and Softimage while the studio began transitioning between DCCs.
Constraints
- Python-only API, chosen to stay nimble and because Python was already available across every major DCC.
- Limited to humanoid components at first, since bipeds were the fastest way to prove the framework before taking on quadrupeds or other creature types.
- Developed solo at Hybride alongside full-time production rigging; additional developers only contributed once the collaborative Fabric Engine phase began.
Challenges
- Maya and Softimage handle transforms and evaluation differently, so matching results meant testing every component in both applications.
- Rigging artists were used to hand-built rigs, so a graph-based setup had to feel approachable to people who did not write code.
Initial Work
The earliest goal in development was to create a Python-based rigging framework for the studio purely for Softimage and not including any Fabric Engine technology. The system would build native controls, skeletons, and use the built-in solvers and constraint combinations.
Developed a standardized, production-ready rigging framework built on core Fabric Engine APIs, replacing per-DCC rig-building with one shared system. On top of the framework I built a custom node-based canvas editor, giving riggers, and for simple rigs animators, a visual graph to construct and debug rigs instead of hand-writing code.


Tool Availability Landscape
Public rigging tools at the time were mostly locked to a single application, and nothing offered true cross-DCC rig portability. Fabric Engine itself was the only public technology positioned as a true cross-DCC layer, which is part of why Kraken drew immediate interest when it was first proposed on the Softimage community mailing list in March 2014.
| Tool | Open source | Year available | Application |
|---|---|---|---|
| mGear | Yes | 2015 | Maya |
| Advanced Skeleton | No | Undocumented | Maya |
| ART (Epic Games) | No | 2014 | Maya |
| Mixamo | No | 2011 | Web |
| Kraken | Yes | 2014 | Maya, Softimage, 3ds Max |

Key decisions
Three choices that shaped how Kraken worked for riggers and animators.
Decision 1
Added a graph-based visual UI to connect and configure rig components without writing code.
Impact
Lowered the barrier to entry for technical directors, enabled rapid prototyping of rig architectures, and made the system accessible to less experienced riggers.
Decision 2
Designed for potential exposure to the animation department for simple rigs, not just rigging specialists.
Impact
Expanded the user base beyond TDs, created a tiered complexity model for different skill levels, and reduced dependency on scarce rigging expertise.
Decision 3
Used Fabric Engine's Canvas visual programming system as the core connection mechanism.
Impact
Made rig logic transparent and debuggable visually rather than hidden in code, and accelerated iteration on rig architecture without recompilation.
Stage 2
Fabric Engine
Joining Fabric in 2016 and taking Kraken into the core product and onto a third application.
Starting point
Fabric Engine's cross-DCC compute platform represented a genuine opportunity to solve the problem of building cross platform rigs. My background as a working Creature Technical Director made the pairing a natural one: applying production rigging experience directly to a platform built to solve exactly that kind of problem became the starting point for Kraken.
After I joined Fabric Engine directly, one of my tasks was extending that same framework to a third DCC, 3ds Max, specifically to open Fabric Engine's platform to the games industry.
Goals
- Ship it as part of Fabric Engine's core product so every customer had access out of the box.
- Bring rigging expertise to the team to assist optimizing the product for that use case.
- Extend Kraken to 3ds Max to open Fabric to game studios.
Constraints
- Developed alongside a Fabric engineer, so the work had to fit Fabric's core product and CI/CD pipeline.
- Qt via PyQt was the only UI framework common to every platform, so the tools had to be built on it.
- No time to add deformation setup or autoskinning, so binding geometry to the rig stayed out of scope.
Challenges
- Porting to 3ds Max meant learning an entirely new DCC and its under-documented Python API from scratch, then going onsite in London to onboard the new customer.
- Found bugs in core Fabric libraries and had to patch or work around them until they were fixed.
- Customizing PyQt widgets took a long time and hurt performance unless reimplemented at a lower level.
Approach
After joining Fabric Engine in 2016, I ported Kraken to a third DCC, 3ds Max, to open the platform to the games industry, learning an unfamiliar application and its under-documented API from scratch and going onsite in London to help onboard the resulting customer.
I helped drive Kraken's open-source release through Fabric Engine and its integration into Fabric's core product and CI/CD pipeline, making it available to every Fabric customer out of the box.
Rig definition (Python / JSON)
Generic description of components
(Head · Arms · Spine · Legs)
softimage/builder.py
maya/builder.py
max/builder.py
Translates to DCC-native primitives and constraints, and sets up the Fabric solver network and its connections
Softimage Rig
Maya Rig
3ds Max Rig
Fabric Solvers
Final Pose, identical across all DCCs.
Key decisions
Two choices that took Kraken beyond Hybride.
Decision 4
Prioritized the 3ds Max port at Fabric Engine's direction, to open the platform to the games industry.
Impact
The port succeeded: Fabric landed a new games-industry customer, and I was sent onsite to London to help onboard them, despite having no prior 3ds Max experience.
Decision 5
Helped drive Kraken's open-source release through Fabric Engine, after presenting it at one of their regular monthly syncs.
Impact
Extended reach beyond internal use to the broader VFX industry, attracted contributions from studios like Oculus Story Studio, and validated the cross-platform approach as an industry-standard solution.
Overall
Looking back
What the two stages taught me, and where Kraken ended up.
Lessons learned
Testing and QA are essential to developing solid software and catching bugs early. I also learned that industry-standard animation apps carried a lot of overhead and weren't well suited to our rigging needs.
Cross-platform portability solved the "same rig everywhere" problem, but it also carried old rigging conventions forward instead of questioning them. A later exploration, where another Fabric engineer built a Kraken evaluator natively in Fabric's own KL language, exposed exactly where those conventions cost performance.
Rigs always carried both an FK and an IK branch, with a blend check that had to run whether it was needed or not. Maya-side transform I/O was a hard bottleneck that couldn't be engineered around, and routing animator controls through Maya's or Softimage's native objects meant constant get and set overhead. A native-Fabric-controls approach was eventually prototyped to remove that last bottleneck, but only very late, years after it would have mattered most.
Key takeaway
Cross-platform portability solved the 'same rig everywhere' problem, but it also carried old rigging conventions forward instead of questioning them.
Outcome
Kraken shipped as a production-ready, cross-platform rigging framework, first unifying Maya and Softimage at Hybride, then extending to 3ds Max at Fabric Engine, where the port helped land a new games-industry customer.
Fabric Engine presented and released it as open source at their SIGGRAPH 2015 user group session, and it drew contributions from studios including Oculus Story Studio, then shipped as a bundled feature of Fabric’s own platform rather than a separate download. Working hands-on across software development and UI/UX design on Kraken was part of what led me back toward product design full time.
Want to know more?
Happy to walk through the work or talk about a role.