The
libs/galatea/area: a humanoid-robotics software stack for fashion-retail and entertainment robots — kinematics, whole-body control, locomotion, embedded firmware, perception, ISO 13482 safety, choreography, fleet ops, garment handling, and AI — built as ~37 Nx projects that mix TypeScript domain logic withno_stdRust crates for the real-time/embedded paths.
What this area is#
Galatea (named for Pygmalion's statue brought to life) is a library-only domain
that implements a full robotics stack for humanoid "robot mannequin" platforms.
It spans from low-level motor firmware up through kinematics, balance,
perception, behavioural AI, and multi-robot show choreography. Every project
carries the scope:galatea, type:lib, layer:domain Nx tags and a
galatea:<name> tag, and every TypeScript library exports a
GALATEA_LIBRARY_ID constant plus a getGalateaLibraryId() accessor for
runtime module identification.
The area is polyglot by design, exactly as the monorepo's stack policy
prescribes (TypeScript by default, Rust where performance/real-time requires
it). The performance-critical and embedded layers — kinematics,
whole-body-control, locomotion, pose-engine, hardware-abstraction,
firmware, and communication — ship companion Rust crates (#![no_std] for
the on-robot paths). Two patterns appear. In hardware-abstraction and
firmware the Rust crate is the implementation and the TypeScript surface
is a thin, typed *-rust-manifest.ts descriptor that records the crate path,
target profile, and capability list (e.g. CANFD_INTERFACE_RUST_MANIFEST). In
kinematics, whole-body-control, locomotion, pose-engine, and
communication there is a full TypeScript implementation alongside a
companion Rust crate, linked by the same manifest convention — so a node like
inverse-kinematics has both a TS solver (inverse-kinematics.ts) and a Rust
hierarchical-QP solver (rust-inverse-kinematics/src/inverse_kinematics_qp.rs,
JOINT_COUNT = 52).
I verified the Rust is real, not scaffold: the small (3–5 line) lib.rs files
are crate roots that delegate via pub mod to sibling modules, and summing each
crate's .rs files gives 95–2474 lines of genuine domain code per crate (FOC
park/clarke motor control, EtherCAT/CAN-FD/DDS/PTP/WiFi-mesh comms, stereo SLAM,
QP IK, etc.). An adversarial stub scan across the area came back clean — the
only Math.random() in non-test code is annotated retry-backoff jitter in
core/src/errors/error-recovery.ts, and the only placeholder() is a
const fn array-seed in the Rust auto-tuning module.
How the area is shaped#
The dependency graph (per docs/domains/galatea/README.md) layers bottom-up:
@galatea/core (shared types/constants/utils/errors) underpins the hardware,
motion, and safety layers; perception and safety sit beside hardware; kinematics
/ whole-body-control / locomotion form the motion tier; @galatea/ai is the
intelligence tier; and the application tier (fleet, choreography,
garment-management, simulation, analytics) plus the developer sdk sit on
top. Three projects — @galatea/database, @galatea/event-handlers, and
@galatea/inclusivity — are namespace parents: their own src/index.ts
carries only the library-ID marker, while the substantive code lives in
independently-importable child projects (e.g. @galatea/database/pose-store).
@galatea/sdk is a hybrid parent+client: its src/index.ts re-exports the
in-project TS client (client-ts) and the client-python manifest, so it is
not a pure marker-only aggregation root.
How it fits the wider system#
These are libraries, not running services — there is no Galatea app process
here; consumers compose the libraries. Higher tiers import lower ones directly
(the IK solver imports GALATEA_JOINT_KINEMATIC_CHAIN and
GALATEA_JOINT_LIMITS from @galatea/core; the SDK client wraps
fleet/show/analytics operations). The embedded Rust crates target on-robot
controllers (edge-linux / rt-preempt profiles) and are referenced from
TypeScript only as manifests, so the build graph stays buildable in a Node
toolchain while the real-time code is compiled for the robot. External
integrators consume the @galatea/sdk family — a TypeScript client and a typed
Python package (galatea_client). Walk the "used by" edges on any node below to
see exact consumers.
Entity catalog (37)#
The 37 tracked Nx projects in galatea, each a code-linked entity node — package, type, source path, declared targets, and its internal dependency graph (depends-on / used-by, resolved from the package manifests, §6/§8), read from the project graph. Grouped by architectural layer; walk the dependency links to travel the system. 37 of these carry an authored deep-dive (what / why / how it fits); the rest are generated scaffolds awaiting one.
domain (36)#
Galatea ai module
The intelligence tier (libs/galatea/ai/src, ~15.9k TS lines, 22 spec files)
with sixteen modules barrelled from index.ts: vla-runtime,
behavioral-engine, natural-motion-gen, customer-engagement,
llm-interaction, emotion-expression, fashion-trend-ai,
attention-prediction, reinforcement-learning, quiet-locomotion,
end-to-end-control (with reflex-vla-runtime), large-behavior-model
(flow-matching/diffusion-transformer training config plus an
lbm-evaluation-suite), motor-cortex-policy, teleoperation,
data-collection (plus training-data-management), and
training-infrastructure. These are deterministic,
configuration-and-orchestration implementations of the model pipelines (types,
schedules, evaluation), not bundled model weights.
Galatea analytics module
Engagement and business analytics (libs/galatea/analytics/src, ~8.7k lines):
engagement-tracker, ab-testing, heatmap-engine (store-traffic heatmaps),
pos-integration, inventory-bridge, revenue-attribution (~1.1k lines
modelling robot-vs-static-mannequin display-variant attribution with
exposure/sale events and cost models), and reporting-dashboard. Real
attribution and experimentation logic, not stubs.
Galatea choreography module
Multi-robot show authoring and performance (libs/galatea/choreography/src,
~9.8k lines): show-designer, show-dsl (a ~1.2k-line domain-specific language
with show/robot declarations, track/formation/cue/parallel statements and cue
departments), formation-engine, music-sync, lighting-bridge (DMX/ArtNet),
stage-mapper, timing-engine, rehearsal-engine, and show-scheduler. It is
the application-tier system that turns choreography into coordinated robot
motion and stage effects.
Galatea communication module
Robot communication protocols (libs/galatea/communication/src). Unlike
firmware and hardware-abstraction, this library has both a real TS surface
and companion Rust crates per protocol: ethercat-master, canfd-interface,
dds-bridge (ROS 2 interop), wifi-mesh (multi-robot mesh, ~1.2k-line crate),
cloud-connector, and ptp-sync (IEEE 1588). The *-rust-manifest.ts files
(e.g. CANFD_INTERFACE_RUST_MANIFEST) bind each TS module to its crate and
record edge-Linux/RT-PREEMPT targets and capability sets. All six crates are
substantial (443–1245 lines).
Galatea core module
The foundational library every other Galatea node depends on
(libs/galatea/core/src). It owns the shared domain vocabulary: types/
(pose/motion, robot-state), utils/ (quaternion.ts, se3.ts,
trajectory-interpolation.ts, procedural-motion.ts), constants/
(physical-constants, morphing-constants, safety-thresholds),
config/runtime-config.ts, and errors/ (a structured error-taxonomy plus
error-recovery with exponential-backoff-with-jitter). It exports the canonical
kinematic chain (GALATEA_JOINT_KINEMATIC_CHAIN), joint limits,
toRotationMatrix, and Quaternion/Vector3 types consumed across the motion
stack. Real, ~5k lines of TypeScript.
Galatea database module
A namespace-parent library (libs/galatea/database/src): its own index.ts
carries only GALATEA_LIBRARY_ID and getGalateaLibraryId(). The substantive
persistence code lives in five independently-importable child store projects
(below). It is an intentional thin aggregation root, not an empty scaffold.
Galatea append-only safety and operational event store with tamper-evident hash chaining
Operational/safety event persistence
(libs/galatea/database/event-store/src/event-store.ts, ~658 lines). Defines
event-domain and severity taxonomies (EventDomain, EventSeverity),
operational-event record schemas, append inputs, and SQL schema generation
(EventStoreSchemaSql, EventStoreSchemaOptions). Real, domain-specific.
Galatea garment catalog store with RFID mappings, DPP cache, wear history, and fit data
Garment data persistence
(libs/galatea/database/garment-store/src/garment-store.ts, ~1.0k lines). The
store for outfit/garment records backing garment-management, with schemas and
query operations. Real implementation.
Galatea pose store with PostgreSQL schema, pgvector similarity search, and full-text retrieval
Pose persistence (libs/galatea/database/pose-store/src/pose-store.ts, ~757
lines). A real store defining pose record schemas, validation, and query/append
operations for the pose-engine data — re-exported from the one-line index.ts.
Galatea show store with choreography definitions, execution history, and version lineage
Show/choreography persistence
(libs/galatea/database/show-store/src/show-store.ts, ~865 lines). Stores show
definitions, schedules, and performance records backing the choreography and
fleet scheduling tiers. Real implementation.
Galatea telemetry store with TimescaleDB schema and retention policies
Telemetry persistence
(libs/galatea/database/telemetry-store/src/telemetry-store.ts, ~1.3k lines —
the largest store). Handles time-series robot telemetry record schemas and
aggregation/query operations. Real implementation.
Galatea event-handlers module
A namespace-parent library (libs/galatea/event-handlers/src): index.ts
holds only the library-ID marker. The real event-processing logic lives in five
child handler projects (below), one per event family.
Galatea customer interaction event handlers with anonymized approach, engage, and depart workflows
Customer-interaction event processing
(libs/galatea/event-handlers/customer-events/src/customer-events.ts, ~470
lines). Processes engagement/interaction events feeding the analytics and
customer-engagement layers. Real implementation.
Galatea garment event handlers for RFID dressing lifecycle, fit validation, fabric-safe constraints, and DPP interactions
Garment-interaction event processing
(libs/galatea/event-handlers/garment-events/src/garment-events.ts, ~627
lines). Handles outfit-change, fit, and garment-tracking events. Real
implementation.
Galatea robot lifecycle event handlers for boot, fault, recovery, and shutdown orchestration
Robot lifecycle/status event processing
(libs/galatea/event-handlers/robot-events/src/robot-events.ts, ~1.6k lines —
the largest handler). Models robot lifecycle states, subsystem states,
registration, boot self-test sequences (BootSelfTestCheck, SelfTestReport),
and status transitions. Real, domain-specific.
Galatea safety event handlers for e-stop, force-limiting, collision response, and stability management
Safety-system event processing
(libs/galatea/event-handlers/safety-events/src/safety-events.ts, ~849 lines).
Handles emergency-stop, hazard, and safety-state-transition events from the
@galatea/safety layer. Real implementation.
Galatea show lifecycle event handlers for show start, cue dispatch, graceful degradation, and show reporting
Show-performance event processing
(libs/galatea/event-handlers/show-events/src/show-events.ts, ~1.1k lines).
Processes cue/timing/performance events emitted during choreographed shows. Real
implementation.
Galatea firmware module
Low-level embedded firmware (libs/galatea/firmware/src), also Rust-primary
with TS reduced to driver manifests (~396 TS lines). The crates are real and
sizeable #![no_std] embedded code: motor-drivers/rust-foc (~2.5k lines of
field-oriented control — Clarke/Park transforms, current protection, multi-mode
control, motor identification), safety-controller (~2.1k lines),
power-management, comms-bus, rtos-runtime, bootloader, board-support,
and a sensor-interfaces family of device drivers (rust-bno085 IMU,
rust-mini45 F/T, rust-vl53l5cx ToF, rust-tactile-skin,
rust-foot-pressure), each 440–675 lines.
Galatea fleet module
Multi-robot fleet operations (libs/galatea/fleet/src, ~8.3k lines):
orchestrator (task allocation), health-monitoring, scheduling-engine,
ota-updates, raas-billing (Robotics-as-a-Service metering),
remote-diagnostics, capacity-planning, incident-management,
federated-learning, and digital-nervous-system (fleet-wide telemetry
aggregation and anomaly detection). All real TypeScript application logic.
Galatea garment-management module
Clothing and costume handling (libs/galatea/garment-management/src, ~3.8k
lines): outfit-tracking (RFID/vision inventory), digital-product-passport
(provenance), cloth-manipulation (grasp/pull/drape primitives with
garmentlab/isaac-sim policy-training backends and dual-arm support),
quick-change, fit-validation, wardrobe-scheduler, fabric-safety, and
size-adaptation. This is the fashion-specific layer that distinguishes Galatea
from a generic robot stack.
Galatea hardware-abstraction module
The hardware abstraction layer (libs/galatea/hardware-abstraction/src).
Rust-primary: every module's TypeScript index.ts re-exports only a typed
*-rust-manifest.ts descriptor (the TS surface is ~220 lines total), while the
real implementation is #![no_std] Rust — joint-interface,
actuator-profiles (with auto-tuning), sensor-fusion, body-morphing,
face-system, hand-system, thermal-management, rfid-reader, and
tactile-skin, each crate 548–1672 lines of genuine code. The manifests record
crate path, target profile, and capabilities for the build graph; the algorithms
live in the crates.
Galatea inclusivity module
A namespace-parent library (libs/galatea/inclusivity/src) holding only the
library-ID marker; the real inclusivity logic lives in four child projects
(below). Thin aggregation root.
Galatea accessibility modes for seated display, adaptive presentation, movement announcements, visual contrast, and braille signage
Accessibility adaptations
(libs/galatea/inclusivity/accessibility/src/accessibility.ts, ~1.4k lines —
the largest inclusivity module). Implements accessibility configuration and
adaptation logic for diverse user needs. Real implementation.
Galatea inclusivity body profile presets and custom profile management
Body-profile configuration
(libs/galatea/inclusivity/body-profiles/src/body-profiles.ts, ~667 lines).
Defines body-shape and gender-presentation taxonomies, US/EU sizing scales
(WOMENS_US_SIZES, MENS_ALPHA_SIZES), and a BodyProfileRegistry
(createBodyProfileRegistry()) for diverse body-type configuration. Real
domain-specific code.
Galatea region-specific cultural configuration for gestures, facial expression intensity, and fashion pose traditions
Cultural customization
(libs/galatea/inclusivity/cultural-config/src/cultural-config.ts, ~1.4k
lines). Configures market/region-specific customizations (etiquette, gestures,
presentation norms) for international deployment. Real implementation.
Galatea multilingual operations for voice interaction, signage localization, garment localization, and region-aware units
Multilingual support
(libs/galatea/inclusivity/multilingual/src/multilingual.ts, ~925 lines).
Handles language configuration and localization for international robot
deployment. Real implementation.
Galatea kinematics module
Computational kinematics (libs/galatea/kinematics/src) with both TypeScript
and Rust solvers across six modules: forward-kinematics
(computeFullBodyForwardKinematics), inverse-kinematics, dynamics,
collision-geometry, jacobian-computation, and urdf-parser. Each module
pairs a real TS implementation with a companion #![no_std] Rust crate linked
by a *-rust-manifest.ts; for example inverse-kinematics.ts solves a
prioritised multi-task (end-effector / COM / gaze / posture)
damped-least-squares problem in TS, while rust-inverse-kinematics implements a
hierarchical QP over JOINT_COUNT = 52 with joint/velocity constraints.
Substantial and genuine on both sides.
Galatea locomotion module
The largest motion library (libs/galatea/locomotion/src, ~15.6k TS lines, 29
spec files). Beyond the classic bipedal controllers — gait-planner,
balance-controller, footstep-planner, step-controller, push-recovery,
stair-navigation, walking-styles (each with a companion Rust crate) — it
carries an extensive procedural-animation suite the domain README
under-documents: procedural-walk-cycle, procedural-bird-flight,
procedural-fish-swimming, procedural-snake-locomotion,
procedural-arthropod-locomotion, procedural-quadruped-locomotion,
procedural-reach-and-grab, procedural-head-look-at, procedural-lip-sync,
procedural-emotion-blending, procedural-appendage-animation,
secondary-motion, terrain-adaptive-foot-placement,
wind-reactive-fabric-hair, and control-rig-integration. All real TypeScript.
Galatea perception module
Computer vision and environment understanding (libs/galatea/perception/src),
TypeScript-only and substantial (~6.1k lines): audience-awareness,
camera-only-perception, depth-processing, fit-analysis,
garment-recognition, obstacle-detection, person-detection, slam, and
visual-servoing. The slam module (~848 lines) models a stereo visual-SLAM
pipeline with calibration, feature observations, landmarks, keyframes,
loop-closure events, and a mapping/localization-only mode switch.
Galatea pose-engine module
Humanoid pose generation and validation (libs/galatea/pose-engine/src):
breathing-simulator, contrapposto-solver, hand-pose-library,
micro-movement-gen, pose-library, pose-optimizer, pose-validation, and
transition-planner. It produces the lifelike "presence" behaviours (subtle
breathing, micro-movement, classical contrapposto stances) plus joint-limit and
garment-safety validation (JointLimitViolation, GarmentSafetyViolation
types). Each module has a real TS implementation backed by a companion Rust
crate.
Galatea safety module
ISO 13482 personal-care-robot safety infrastructure (libs/galatea/safety/src,
~5.1k TS lines): iso-13482 (operating-state machine, HAZOP guide-word
analysis, ISO 12100 risk assessment with Iso12100RiskLevel low→intolerable),
risk-assessment, force-limiting, emergency-systems, functional-safety
(watchdogs), regulatory-toolkit, audit-logger (tamper-aware event logging),
and access-control. Real, domain-specific safety-standard modelling rather
than generic CRUD.
Galatea sdk module
A namespace-parent plus the TypeScript developer client
(libs/galatea/sdk/src). Its index.ts re-exports client-ts/client.ts (~1.1k
lines: fleet/show/analytics operations and realtime robot-status subscriptions —
FleetRobotStatus, ScheduleShowRequest, startDueSchedules, etc.) and a
client-python/index.ts that is a typed manifest
(GALATEA_PYTHON_CLIENT_SDK_MANIFEST) pointing at the separate Python package.
The two SDK extension projects (analytics-sdk, show-sdk) and the Python
client are independent sibling projects.
Galatea analytics integration sdk
A developer SDK extension for analytics
(libs/galatea/sdk/analytics-sdk/src/analytics-sdk.ts, ~1.2k lines). Provides
custom-event schema definitions, event tracking, and aggregate/ratio metric
definitions for instrumenting and querying Galatea analytics. Real
implementation.
Galatea show authoring sdk
A developer SDK extension for show authoring
(libs/galatea/sdk/show-sdk/src/show-sdk.ts, ~943 lines). Offers builders for
path/pose/pivot tracks and formation templates, music-sync point import, and a
show validation/timing report (ShowValidationReport,
ShowValidationTimingSummary). Real implementation.
Galatea simulation module
Physics simulation and digital twin (libs/galatea/simulation/src, ~7.9k
lines): physics-engine (~1.5k lines, mujoco/isaac-sim backends,
urdf/mjcf model loading, contact/friction/damping parameter sets),
cloth-simulator, digital-twin, show-preview, rl-training-env (Gym-like),
wear-simulator, virtual-showroom, and scenario-tester. Real
simulation-orchestration TypeScript; the heavy physics backends are integration
targets, modelled here as typed parameter/interface layers.
Galatea whole-body-control module
Whole-body / operational-space control (libs/galatea/whole-body-control/src):
task-space-controller, impedance-controller, admittance-controller,
postural-controller, center-of-mass, and momentum-controller. Each is a
real TS controller with a companion Rust crate (95–190 lines of .rs per crate,
e.g. rust-momentum-controller) for the real-time path. It provides the
compliant- interaction and balance-regulation layer that locomotion and the AI
tiers drive.
unclassified (1)#
A typed Python client package (libs/galatea/sdk/client-python,
pyproject.toml, package galatea_client). It exposes GalateaClient with
FleetClient, show, and analytics sub-clients over a backend abstraction
(backend.py), models.py dataclasses, a py.typed marker, and
tests/test_client.py. The shipped backend is an InMemoryGalateaBackend, so
the package is exercisable end-to-end against an in-memory implementation rather
than a live service. Real, typed Python — the only non-TypeScript/Rust SDK in
the area.