Kinetix: Rebuilt Animation Platform for a Major Tech Company

Role: Lead 3D Engineer at Kinetix
Duration: 2024–2025
Stack: Python, NumPy, Voxel Processing, Mesh Topology Analysis, Blender (Addon + Backend), AWS Lambda, Node.js, Three.js, TypeScript, WebGL

The Challenge: Rebuilding a Legacy Animation Platform

I rebuilt the animation platform for a major tech company, the system that powers automatic character rigging and retargeting for millions of creators. Their platform was solid, but they wanted a complete rebuild to modernize the tech stack and expand capabilities.

The Kinetix codebase we inherited had major gaps compared to the client’s existing platform. Their system was already advanced, so we had to do serious work just to catch up, let alone surpass it.

The rebuild needed to support:

• Fully automatic rigging with manual fallback for edge cases
• Intelligent bone mapping (automap) with manual mapping fallback for edge cases
• ML-powered video-to-animation generation
• Premium retargeting services
• WebGL-based 3D preview and rendering engine

My Role: Engine, Autorig and Automap

As lead 3D engineer, I rebuilt the core intelligence of the platform:

1. Animation Engine - Forked and modernized the legacy engine for character/animation loading, rendering, and retargeting
2. Autorig System - Built a fully automatic anatomical landmark detection pipeline
3. Automap System - Developed topology-based bone mapping replacing nomenclature-based detection
4. Manual Mapping Interface - Built fallback tools for edge cases that needed manual fixes
5. Enterprise Integrations - Debugged and adapted systems for major clients

Technical Architecture

Three.js WebGL Engine

I rebuilt the browser-based 3D engine from scratch:

Core features:

• Universal character model loading with backend normalization preprocessing (accepts any 3D file format, normalizes to consistent internal representation)
• Character animation playback and preview
• Retargeting visualization (mapping animations between different character rigs)
• WebGL-optimized rendering for smooth cross-platform performance

Automap: Geometry-Based Bone Mapping

The Problem: When users upload characters with existing rigs, the system has to map those bones to a standardized hierarchy for retargeting. The old system matched bone names against keyword lists, which broke when:

• Rigs used non-English naming (Japanese, Korean, Chinese game characters)
• Custom hierarchies didn’t follow expected patterns
• Bones were unnamed or generically numbered
• Rigs contained many additional bones for props, accessories, or to avoid the “candy wrap effect” (skin deformation artifacts)

Users had to manually fix mappings in ~40% of uploads - a massive pain point.

The Solution: Replaced nomenclature matching with multi-criteria geometric detection analyzing:

• Position & Spatial Relationships - Where bones exist relative to character center of mass
• Hierarchy Analysis - Parent-child structure and branching patterns
• Geometry Dimensions - Bone length ratios and proportions
• Symmetry Detection - Left/right pairing through mirror-plane analysis
• Connectivity Patterns - How bones form chains (spine, limbs, fingers)
• Extra Bone Handling - Intelligent filtering to distinguish core skeletal bones from prop bones, twist bones, and other non-standard additions

Success rate jumped to near-100% for both standard and non-standard rigs. Users could now upload characters with arbitrary bone naming, extra bones, or completely custom hierarchies and get correct mappings automatically.

Autorig: Fully Automatic Rigging System

Deployment: Blender addon and serverless backend library (AWS Lambda)

The Problem: Build a fully automatic rigging system that could handle the massive diversity of humanoid characters users upload, without any manual marker placement.

The Solution: Developed a fully automatic anatomical landmark detection pipeline using voxel-based geometric analysis:

Key Innovation: Handling Props and Accessories

One major challenge: distinguishing actual limbs from props, hair, or accessories. Traditional approaches would try to place bones in swords, capes, or decorative elements, which corrupted the rig.

Solution: Implemented morphological kernel-based centroid path computation. This approach:

• Analyzed cross-sections perpendicular to the limb axis
• Calculated center of mass for each cross-section
• Naturally ignored thin accessories and focused on substantial body structures
• Maintained consistent paths even with complex surface detail

This let us place bones reliably for characters with equipment, clothing, or decorative elements - no manual cleanup needed.

Key Innovation: Topology-Based Finger Detection

Automatic finger detection is exceptionally challenging because fingers can have varying counts (3-6), diverse anatomies (organic vs. mechanical), and ambiguous ordering (which is the thumb?). The voxel-based approach used for body parts fails here—even with high precision, voxelization causes fingers to merge before the actual interdigital spaces, making individual finger separation impossible.

Solution: Developed face island analysis that identifies connected polygon groups directly from mesh topology and scans them sequentially from left to right, tracking where separate islands merge toward the palm. The system validates findings using interdigital space detection and automatically determines finger identity through permutation testing. This worked across human hands, stylized characters, mechanical rigs, and weird anatomies.

Enterprise Integrations

Unity Muse integration showcased at Unity’s Unite 2024 conference

Beyond the base system, I debugged and adapted our tech for major client integrations. The biggest was Unity Muse integration, which let Unity users generate animations from video directly in the Unity Editor.

Integration challenges:

• Getting character preprocessing to work with Unity’s asset pipeline
• Adapting autorig and automap outputs to Unity’s animation system requirements
• Debugging edge cases specific to Unity-exported character models
• Performance optimization for real-time preview within the Unity Editor environment

Impact & Results

User Experience Transformation

• Rigging time: Manual marker placement eliminated → fully automatic in seconds
• Mapping accuracy: ~60% auto-success (legacy) → ~95% auto-success (new system)
• Character diversity: Humanoid-focused → 40+ body configurations supported
• Manual intervention: Required in ~40% of cases → Required in <5% of cases

Platform features

The rebuilt platform delivered:

• Automatic rigging for standard and non-standard character types
• Topology-based mapping working across diverse naming conventions, languages, and custom hierarchies
• Intelligent extra bone handling for props, technical bones, and candy-wrap prevention
• Premium retargeting with reliable skeletal structure consistency
• Enterprise integrations with major platforms like Unity

Technical Achievements

• Dual-deployment architecture: Same autorig codebase works as Blender addon and AWS Lambda function
• Robust fallback handling: Manual mapping tools for edge cases the automatic system couldn’t handle
• Compatible with major tools: Worked with all major 3D software and game engines
• Major client integrations: Debugged and shipped Unity Muse and other enterprise partnerships

Building animation pipelines? I offer freelance consulting for complex 3D automation systems. Get in touch or connect on LinkedIn .