AADC: the compiler for numerical models

Record the model once. Everything else follows.

AADC records a C++ or Python model as it runs and compiles the recording to machine code. The kernel runs 6× to 1000× faster than the code it came from, returns every derivative at an adjoint factor below one, runs the same recording on AVX2, AVX-512, Apple Silicon and ARM, and, in our latest release, keeps a record a validator can read.

Major Wall Street and global banks run it on more than $4 trillion of derivatives. The same compiler trains a gas storage dispatch policy, prices an insurer's variable annuities and differentiates a robot's trajectory optimiser. The community edition is free.

  • < 1 adjoint factor: the value plus every derivative, faster than the value alone
  • 39 s gas storage dispatch policy trained with exact gradients: $2.19M, where RL took 4 h for $1.07M
  • 30× trajectory-optimisation gradients against Drake's own AD at 1,004 variables
  • 4 weeks to first production results
$ pip install aadc
Successfully installed aadc-2.22.2
>>> f.compile("auto")         1,000,000 FX trades priced in 0.4 s
>>> ws.reverse()              2,564 sensitivities in 2.0 ms
$ AADC_TRACE=1 ./price      74,428 steps recorded, 100% attributed
>>> targets                   AVX2  AVX-512  Apple Silicon  ARM   NVIDIA, in development

Recognised by

  • undefined: 12th in the Quantitative Analytics 50, five category awards
  • undefined: 18th in the Insurance Risk Analytics 50
  • undefined: 25th in the BuySide Risk Analytics 50, up from 47th
  • undefined: Innovation of the Year, technology
  • undefined: 13th in the Quantitative Analytics 50, five category awards
  • undefined: Technology Newcomer of the Year
  • undefined: Best AI-Powered Deep Tech Company, UK
  • undefined: Shortlisted: FinTech Start-up of the Year
  • undefined: 10th in the QuantTech50, four category awards
  • undefined: Accenture FinTech Innovation Lab London, class of 2023

Who this is for

  1. Engineers who ship simulations in C++ or Python

    and are asked for sensitivities, a calibration or an optimiser the code was never written for.

  2. Validators who need evidence from the binary

    not a description of what the model is meant to do.

  3. Teams who have tried automatic differentiation before

    and know where it hurt: the tape, the calibration, the discontinuities, the rewrite.

What it does

  1. Record

    Change the scalar type, run the model once. The recording is the whole calculation: every operation, comparison and input. How it works →

  2. Compile

    The recording becomes a kernel: vectorised, multi-threaded, built for the CPU it runs on. The same recording compiles for AVX2, AVX-512, Apple Silicon and ARM; NVIDIA double precision is in development. Benchmarks →

  3. Differentiate

    Every sensitivity in one reverse pass, exact, at adjoint factor below one. Calibration inside the model is differentiated through automatically. Automatic IFT, Risk.net 2022 →

  4. Prove

    AADC_TRACE=1 ties every step to the file and line that produced it and hands the record to the validator: every hard-coded constant with its line, every market-dependent branch with its distance to switching, which inputs a number depends on and which it provably does not. AADC Tracer →

  5. Deploy

    Kernels are binaries. Source stays on-premises; the kernel goes to the cloud, the desk or a live server, and is thrown away when the model changes. Deployment →

Sound familiar?

Two doors

Community edition

Python, free for non-commercial and academic use. The interpreter and every JIT backend at full speed on AVX2, Apple Silicon and ARM. Python 3.10 to 3.14 on Linux, macOS and Windows.

On PyPI ↗

Enterprise

C++ and Python. The C++ SDK, AVX-512, kernels compiled ahead of time for deployment, production use, the Tracer on your production binary, and the engineers who wrote the compiler, on your code. NVIDIA double precision is in development.

What people who have used it say