Skip to content
Eric Thivierge
← Portfolio

Kraken Rigging Framework

Role
Software development, UI/UX design
Team
Hybride VFX & Fabric Engine
Timeline
2014–2017
Platform
Maya, Softimage and 3ds Max
The Kraken graph editor showing a rig built as connected component nodes

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.

Softimage viewport showing a rig's guide hierarchy on a humanoid character
Maya viewport showing the Python plugin that builds a rig component

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.

ToolOpen sourceYear availableApplication
mGearYes2015Maya
Advanced SkeletonNoUndocumentedMaya
ART (Epic Games)No2014Maya
MixamoNo2011Web
KrakenYes2014Maya, Softimage, 3ds Max
The Kraken Editor showing the component hierarchy list and the spine and arm component graph with their ports
The Kraken Editor: component hierarchy and per-component node graph

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.