Last week, with no paper and almost no announcement, Meta released Project SuperDex: a unified simulation platform for dexterous manipulation. A purpose-built physics engine, a robotics SDK, a desktop authoring studio, and a Gymnasium-style reinforcement learning harness, all in one C++ codebase under Apache 2.0. VR teleoperation on Quest 3 is on the roadmap for later this year. The demo tasks are threading screws, squeezing sponges, handling bags of fruit, and braiding rope.
The README leads with one sentence: a contact-rich physics engine built for tactile manipulation, applicable wherever stable contact and accurate sensing matter.
If you read The Missing Epidermis on this blog nine days ago, you will recognise that sentence. It is the thesis of that post, restated in a Meta README. Robotics spent a decade obsessed with where the arm is. The frontier has moved to what the hand is touching. Meta has been the most consistent large-lab investor in touch for years, from the DIGIT fingertip to ReSkin to the Sparsh touch models, and SuperDex is that conviction turned into infrastructure.
So I cloned the repository and read the source. What I found is worth walking through, because it gets something deeply right, it is honest about what it does not include, and the hole in the middle of it is precisely the layer we build.
What Meta Got Right
The physics engine, internally named Mochi, is serious work. Implicit time integration with a Newton solver. Contact through smoothed penalty forces with regularised Coulomb and viscous friction, so the mathematics stays differentiable where cruder engines snap. Deformable objects are real finite elements, tetrahedral meshes with reduced-order acceleration, which is why it can squeeze a sponge convincingly. And it is deterministic by construction: contact assembly is explicitly sorted so the same input produces the same trajectory every run. Anyone who has chased a bug through a nondeterministic simulator knows how much discipline that takes.
Contact-first turns out to mean something concrete. At every step you can query every contact point and get its position, its surface normal, the force vector across it, the penetration depth, and the velocity of each surface at the point of contact. The simulator will hand you the complete ground truth of touch, at whatever rate you ask for it.
One more detail made me sit up. Among the robot assets, next to the hands and arms, is the collision and render geometry for a real commercial tactile fingertip: the Seed Robotics SINGLEX-3, mounted on a Tesollo five-fingered hand, released under Apache 2.0 with the sensor maker's blessing. Two collision models ship for it, a smooth dome and a ridged one. Ridges, on a fingertip, in a physics engine. Somebody at Meta cares about how texture becomes vibration. That is the right thing to care about.
The Reader Did Not Ship
Now look at the sensors directory of the robotics SDK. It contains a base class and a camera. That is the complete list.
The tactile fingertip asset declares its sensor like this: type SENSOR_SEED_V1_MLP, parameters in a file called internal/seed.superdex_sensor. That file is not in the release. The name tells you the rest of the story. MLP is a multilayer perceptron. The thing that turns simulated contact into a sensor reading, the part that feels, is a trained neural network, and it stayed inside Meta.
I do not say this as a gotcha. It is the field's default architecture, stated unusually plainly: physics you can read and verify, then a learned black box where the feeling should be, then a policy network trained by reinforcement learning on top of that. Millions of simulated trials against a reward function, then the sim-to-real gap, the moment the trained policy meets a world the simulator did not perfectly predict. The whole platform exists to make that loop faster, and on its own terms it will succeed.
But notice what the stack never produces: an inspectable account of what touch means. Ask it whether the part has started to slip and the answer is buried in the weights of two networks, one imitating a sensor and one imitating a skill. Ask it how confident it is and there is no principled answer at all.
The Arrow Points the Other Way
SuperDex models the world in the forward direction. Humans write down the physics, the physics manufactures synthetic experience, gradient descent compresses that experience into behaviour, and then everyone hopes the compression survives contact with reality. The world model is given. The understanding is correlational.
We run the arrow backwards. Causal-state induction starts from the raw stream a real sensor emits and induces the structure in it: two histories belong to the same state exactly when they predict the same future. Nobody writes the physics down. There is no reward function, no gradient, and no separate training phase. The model that comes out is not a weight matrix; it is a machine you can read, state by state, transition by transition. And it is small enough to run where the sensor is, on a computer that costs less than the fingertip.
Neither direction is simply better. A simulator earns its keep wherever real trials are expensive or dangerous, and manipulation trials burn hardware. Induction earns its keep because reality is the one dataset with no rendering gap. The interesting question is not which wins. It is what happens when you connect them, because they are missing opposite things. SuperDex has a perfect world and no reader. We have a reader and, until our tactile hardware arrives, a thin world.
Causation Streams: What We Would Do With SuperDex
To our engine, a sensor was never a device. It is a causation stream: bytes arriving over a wire whose changes carry the structure of a process. A drone's telemetry is one. A PLC's registers are one. A web server's traffic logs are one. And a deterministic simulator emitting contact points at a kilohertz is one too. The engine cannot tell the difference, and that is the point.
Concretely, four things fall out, in increasing order of ambition.
- Tap the stream. A small standalone process registers SuperDex's contact query and writes each contact event as a flat binary record to a socket: position, normal, force, slip velocity. Our engine ingests it as just another wire protocol, the same way it already speaks to robot-arm and flight simulators. No SDK crosses the boundary in either direction.
- Rehearse touch before the hardware exists. The vibration signature of a ridged fingertip crossing a surface, the force transient when grip goes from stable to incipient slip: SuperDex generates unlimited hours of this with perfect ground truth, because the simulator knows the exact instant slip begins. That is a synthetic tactile corpus for causal induction, available months before a physical rig is assembled, with the induced states checked against labels the physics provides for free.
- Replace the black box with a reader you can read. Induce the causal states of the contact stream directly. Stable grasp, incipient slip, gross slip, texture classes: if the mathematics is right, these emerge as states of the induced machine, each one inspectable, each transition an explicit prediction. That is what SENSOR_SEED_V1_MLP is approximating from the outside, delivered as structure instead of weights.
- Measure the sim-to-real gap instead of discovering it. This is the one I find genuinely exciting. Induce one machine from SuperDex's simulated SINGLEX-3 contact stream. Induce a second from the physical SINGLEX-3, the very sensor whose geometry ships in the repository. The two machines are directly comparable objects. Where their states and transition structure agree, the simulator is faithful. Where they diverge, that divergence is the sim-to-real gap, expressed per regime rather than as a policy failing on a bench. Today the field crosses that gap blind. It could cross it with a map.
None of this needs Meta's cooperation, which is the quiet beauty of an Apache-licensed release with an honest query API. But it would be better with it.
What the Release Signals
Step back from the source code and read the strategy. A frontier lab just spent years of engineering on the premise that contact and accurate sensing are where robotics gets decided, and its next module is teleoperation on a consumer VR headset, which means collecting human manipulation data at consumer scale. The physical world is the next data war, and touch is its richest front. I made that argument in The Physical-World Turn; SuperDex is the strongest evidence yet that the largest labs agree.
Where we differ is on what happens to the signal. The industry's reflex is to capture physical data and ship it away to train ever larger models. We build the layer that understands the signal at the machine, while it runs, on hardware cheap enough to disappear into the robot. Meta built a beautiful rehearsal hall for hands. Someone still has to build the sense of touch that walks out of the rehearsal and onto the stage.
One mind. Many bodies. Many senses. And now, somewhere to practise.
References and Further Reading
The Release
- Project SuperDex. Meta (facebookresearch), August 2026. Physics engine, robotics SDK, studio, and RL harness under Apache 2.0.
- Seed Robotics. Maker of the SINGLEX-3 tactile fingertip whose geometry ships in the SuperDex assets.
Meta's Decade of Touch
- DIGIT: A Novel Design for a Low-Cost Compact High-Resolution Tactile Sensor. Lambeta et al., IEEE RA-L (2020).
- ReSkin: Versatile, Replaceable, Lasting Tactile Skins. Bhirangi et al., CoRL 2021.
- Sparsh: Self-Supervised Touch Representations for Vision-Based Tactile Sensing. Higuera et al., CoRL 2024.
The Mathematics: Reading a Stream Instead of Writing a World
- Inferring Statistical Complexity. Crutchfield & Young, Physical Review Letters 63 (1989). The founding paper: causal states and ε-machines.
- Computational Mechanics: Pattern and Prediction, Structure and Simplicity. Shalizi & Crutchfield, Journal of Statistical Physics 104 (2001). Causal states as the unique minimal sufficient statistic of a process.
- Computational Mechanics of Input-Output Processes. Barnett & Crutchfield (2015). The ε-transducer: sensing and acting through one machine.
This piece continues the argument of "The Missing Epidermis" and "The Physical-World Turn". At Senua AI the same causal-state engine already flies drones, drives industrial machines, and watches network traffic. A simulator is just one more stream.