Alloy: A Multi-Material Physics Engine for Robot Learning

Pranay Gupta, Deepanshu RohillaarXiv 2026 · arXiv

TL;DR

Alloy is a new open-source physics engine designed to bridge the gap between rigid-body robotics and the "messy" real world of cloth, liquids, and granular materials. By providing a unified interface that automatically routes objects to specialized solvers and scales across thousands of GPU-parallel worlds, Alloy enables reinforcement learning for complex, multi-material tasks while remaining uniquely accessible to both human engineers and AI coding agents.

What Problem Does This Paper Address?

Most current simulators used for large-scale robot learning are "rigid-body first." While they excel at simulating metallic robot arms and blocks, adding non-rigid elements like a wet towel, a flexible cable, or a pile of sand usually requires researchers to manually "glue" together different physics engines. This process is brittle, requires hand-tuned time steps, and often fails silently, leaving researchers unsure if a robot failed because of a bad policy or a simulation glitch.

Furthermore, as LLM-based "coding agents" increasingly write simulation code, there is a growing need for engines that provide clear, machine-readable errors and built-in documentation rather than just dense C++ headers.

Methods

Alloy operates as a high-level orchestration layer built on top of established solvers like MuJoCo, Newton, and NVIDIA Warp. Its architecture follows a clear pipeline:

  1. Unified Scene Description: Users define a scene using a single Python interface. Each object is paired with a "material card"—a JSON-like file containing physical properties (density, stiffness, friction).
  2. Automatic Routing: A router analyzes the material cards and geometry to assign each object to the most appropriate solver (e.g., SPH for liquids, VBD for cloth, or MuJoCo for rigid robots).
  3. Coupling via Proxy Bodies: To make different solvers talk to each other, Alloy uses "proxy bodies." For example, a robot gripper (rigid) appears as a proxy inside the cloth solver to exchange forces and poses during every control step.
  4. Health Monitoring: Every parallel world is assigned a health grade (OK, DEGRADED, or INVALID). If the physics "explodes" in one world (e.g., due to non-finite values or extreme penetration), that specific world is frozen or reset without stopping the entire batch.
Figure 2: How a scene becomes a simulation. Each object is routed to one solver. When a scene uses more than one solver, a coupler joins them inside every control step. A health monitor grades every parallel world after each exchange.

Datasets

While Alloy is an engine rather than a static dataset, the authors provide a significant library of assets to kickstart research:

  • Robot Models: Nine pre-configured robots, including the Franka arm, Unitree Go2, and UR10e.
  • Material/Object Cards: A library of 90 material cards and 118 object cards, with an extended downloadable library of over 5,000 object cards.
  • Benchmarks: The paper evaluates performance using a "cold test" where an AI agent (Claude 3.5 Opus) was tasked with writing training code for walking, cable handling, and pouring tasks from scratch using only the engine's internal documentation.

Key Insights and Ideas

  • Agent-Centric Design: Alloy is built for the "Model Context Protocol" (MCP). It treats AI agents as first-class users by shipping documentation inside the package and ensuring every error message includes a suggested fix.
  • Physics Health as a Signal: By grading the health of each simulation world, Alloy allows RL algorithms to distinguish between a robot falling over (a policy failure) and the ground plane disappearing (a physics failure).
  • Dynamic Step Selection: The engine automatically chooses exchange intervals based on the "stiffness" of the interface between materials, preventing the common problem of high-frequency oscillations when rigid and soft bodies interact.

Key Results

Alloy demonstrates impressive scaling and reliability on a single NVIDIA L4 GPU:

  • Throughput: For a task involving three objects in a bin, throughput increased ~377x when scaling from 1 to 512 parallel worlds.
  • Agent Success: In the "cold test," an AI agent successfully trained a Unitree Go2 quadruped to walk in just 15.5 minutes and achieved a 100% success rate on a custom cup-pouring task after two iterations.
  • Accuracy: The engine showed high agreement with closed-form physics references, such as the Euler buckling load for columns and the catenary sag of hanging cables (see Table 4 in the paper).
  • Reliability: In a test stacking 1,024 towers of blocks, Alloy recorded zero physics errors over a 5-second simulation across all worlds.
Figure 1: Scenes simulated in Alloy. (a) A Franka arm pours water from a bottle into a glass; the water is simulated with Alloy’s liquid solver, coupled to the robot’s rigid-body contact. (b) A Franka arm routes a cable through a clip toward a socket; the cable is an articulated chain in the rigid-body solver. (c) A gripper pushes an AA cell into a sprung battery holder, simulated with rigid-body contact. (d) 1,024 parallel worlds of one robot task in a single frame. Panels (a), (c) and (d) are rendered with Blender Cycles, (b) with Alloy’s path-traced camera.

Limitations and Future Work

The authors note that Alloy is currently in an early "0.x" release. Key limitations include:

  • Interface Stability: As an early-stage project, API breaking changes are expected.
  • Feature Gaps: Not all physical phenomena are fully supported yet; the authors maintain a "keep-in-mind" list of current omissions on their documentation site.
  • Solver Dependencies: While Alloy unifies solvers, it is still reliant on the underlying performance and constraints of the engines it wraps (MuJoCo, Warp, etc.).

Future work will likely focus on expanding the library of supported materials and further refining the "agent-first" tools to allow for even more autonomous environment generation.

Summary updated

Abstract

Robots handle much more than rigid objects: towels, cables, water, sand. The simulators used to train robots at scale are strongest on rigid bodies, and adding another material usually means a second engine and hand-written glue between the two. We present Alloy, an open-source physics engine for robot learning in which rigid robots, cloth, cables, liquids, granular material and soft bodies share one scene. Each object is described once; Alloy assigns it to a solver suited to its material, couples the solvers inside every control step, and runs the scene in many parallel worlds on one GPU, or on a CPU. Every world carries a health grade, to help tell a failure of the physics from a failure of the policy. Alloy is built on Newton, MuJoCo Warp and Warp, and it is written to be driven by coding agents: its documentation ships inside the package, every error names its fix, and the engine is exposed as tools over the Model Context Protocol. In a cold test, agents that had never seen Alloy installed a pre-release from the package index and trained policies for walking, cable handling and pouring on a single GPU. We also report how throughput grows with the number of worlds, depth-camera throughput, agreement with closed-form references, and a reliability test over a thousand worlds.
BibTeX
@misc{gupta2026alloy,
  author = {Pranay Gupta and Deepanshu Rohilla},
  title = {{Alloy: A Multi-Material Physics Engine for Robot Learning}},
  year = {2026},
  eprint = {2611.16312},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.16312},
}
Figure