Robotics & Simulation

Make any C/C++ physics simulator differentiable in hours

AADC drops into MuJoCo, OpenFOAM, GROMACS, Drake, and any codebase with a scalar typedef. Exact adjoint gradients. No rewrite. JIT-compiled to bare metal.

157×
Faster gradient computation
MuJoCo POC
1 day
To integrate
Drop-in typedef
Try AADC on Your Simulator See Results

Every simulation needs gradients. Nobody can compute them efficiently.

Robotics

Policy optimisation, sim-to-real transfer, model predictive control. MuJoCo and Isaac use finite differences, which cost one extra run per parameter.

CFD

Shape optimisation for wings, turbines, heat exchangers. Hand-coded adjoints take person-years and cover 60% of the solver.

Drug Discovery

Force-field parameter optimisation. GROMACS has no built-in differentiation, so gradients mean a rewrite in a Python framework.

Replace `double` with `idouble`. That is the integration.

The 5-step process to differentiable simulation

1
Drop-in
Change scalar typedef to idouble
2
Identify
Mark inputs and outputs
3
Record
Run once to capture computational graph
4
Execute
JIT-compiled kernel runs at bare metal speed
5
Check
Verify gradient accuracy to machine precision
typedef change
// Before
typedef double mjtNum;    // MuJoCo
typedef double scalar;    // OpenFOAM
typedef double real;      // GROMACS
typedef double su2double; // SU2
// After
typedef idouble mjtNum;    // 157× faster gradients
typedef idouble scalar;    // Full solver AD (not partial)
typedef idouble real;      // Force field sensitivities
typedef idouble su2double; // JIT-compiled adjoint

Proven Results

Project Typedef Result Status
MuJoCo (robotics) mjtNum 157× faster, exact gradients POC complete
Drake (robotics) AutoDiffXd 30× faster trajectory-optimisation gradients than Drake's own AD at 1,004 variables; 6× at 104. Identical accuracy (both within 2e-8 of finite differences) Benchmark, March 2026
QuantLib (finance) Real 1770× XVA acceleration Production
ORE (risk engine) Real 245× acceleration Beta
SU2 (CFD) su2double Benchmark in progress Integration started
Drake (robotics) AutoDiffXd Reverse-mode upgrade Integration started

Why Not Alternatives?

Everything else requires a rewrite. AADC drops in.

Tool Integration Rewrite Gradients Speed Languages
AADC Drop-in typedef None Exact adjoint 157×+ C/C++, Python
NVIDIA Warp Full rewrite to Python DSL Complete Forward/Reverse GPU-bound Python only
Enzyme LLVM plugin, specific compiler versions Partial Forward/Reverse 9× slower than AADC C/C++, Fortran
CoDiPack Template library Moderate Tape-based 10-15× slower C++
PyTorch/JAX Full rewrite to framework Complete Tape/Tracing 10× slower Python
In-house Person-years of manual adjoint coding Complete Manual adjoint Varies Any

Who Uses AADC

Tier-1 banks in production
Intel technology partnership
Chartis QuantTech50 Category Leader
IEEE publication (CNC imitation learning)

MuJoCo Demo

Demo with explanation, coming soon

GIF demo will be added here

Ready to Make Your Simulator Differentiable?

Contact us for a research evaluation licence or see how AADC integrates with your codebase.

Contact Us for Evaluation How AADC Works

Frequently Asked Questions

How does AADC make a simulator differentiable?
AADC uses C++ operator overloading to intercept arithmetic operations. You change your simulator's scalar typedef (e.g., mjtNum, scalar, real) from double to idouble. AADC then records the computational graph during a single forward pass and JIT-compiles it into an optimised binary kernel that computes exact adjoint gradients.
What simulators has AADC been tested with?
AADC has been integrated with MuJoCo (robotics, 157× faster gradients), QuantLib (finance, 1770× acceleration), and ORE (risk engine, 245× acceleration). Integration with SU2 (CFD) is in progress. Drake (robotics) has a reproducible trajectory-optimisation benchmark: 30× faster gradients than Drake's own AutoDiffXd at 1,004 variables, with identical accuracy. Any C/C++ codebase with a scalar typedef can be made differentiable.
How does AADC compare to Enzyme-AD?
Enzyme-AD is an LLVM-based source transformation tool that requires specific compiler versions and has integration complexity. In benchmarks, Enzyme-AD is 9× slower than AADC. AADC integrates through a typedef change, with no compiler plugin and no change to the build system.
Does AADC require rewriting simulation code?
No. AADC is a drop-in integration. You change your scalar typedef from double to idouble, mark inputs and outputs, and run a single forward pass to record the computational graph. The rest of the simulation code, the physics, the numerics and the data structures, is unchanged.
Can AADC handle branching and control flow in simulation code?
Yes. AADC records the computational graph through whatever execution path your code takes during the recording run. Branches, loops, and conditional logic are all captured. For simulations where control flow varies significantly between samples, you can re-record the kernel as needed.
Does AADC compute forward-mode or reverse-mode gradients?
AADC computes exact reverse-mode (adjoint) gradients. Gradients with respect to every input cost about the same as one forward evaluation, which is what matters when the parameters are joint angles, force fields or boundary conditions by the thousand.