GRiD is a GPU-accelerated library for robot dynamics, kinematics and collisions with analytical derivatives and Hessians.
GRiD generates optimized, robot-specific CUDA C++ from a URDF: rigid-body dynamics, kinematics, their analytical
first- and second-order derivatives, and a plant layer for trajectory optimization. The generated code is exposed as
a NumPy handle, a jax.jit-able FFI surface, torch.autograd-aware ops, or a single header-only grid.cuh for use
in your own kernels. Every algorithm runs as one CUDA block per problem and is batched across problems; results are
bit-deterministic and independent of the thread count. The same model and API rebuild for each target architecture,
with one artifact per sm_XX. GRiD builds on URDFParser for URDF parsing,
RBDReference for Pinocchio-validated reference dynamics and
GLASS for GPU linear algebra.
The full documentation is the website, https://a2r-lab.org/GRiD/: installation, tutorials, the How do I…? index, concepts, API reference, benchmarks and validation. This README points to it.
Version 0.5.1 is on PyPI; 0.5.0 was the first packaged release. GRiD is alpha software and APIs may change between minor versions (see the changelog). The GPU test receipt and the release timing ran on Linux x86-64 with CPython 3.12, CUDA toolkit 13.2 and one RTX 5090 (sm_120); CPython 3.10, 3.11 and 3.13 wheels are built and import-checked on CPU in CI, and the CPU test lane runs on 3.10, 3.12 and 3.13. Other toolkits, GPUs and interpreters are untested; the compatibility page lists the exact environment. The original ICRA 2022 paper describes the implementation preserved in the archival robot-acceleration/GRiD repository; it does not describe the feature set or the performance of this release.
Both entry points use the same generated CUDA.
load_robot(urdf) generates, compiles and caches the robot's CUDA and exposes it as batched NumPy, JAX or PyTorch
calls. No CUDA code is required.
pip install grid-rbd # code generator + NumPy backend + grid-generate CLI
pip install "grid-rbd[jax]" # or "grid-rbd[torch]", "grid-rbd[all]"import numpy as np, grid_rbd
robot = grid_rbd.load_robot("grid_assets/robots/iiwa14.urdf",
algorithm_list=["forward_dynamics"], enable_mujoco_kernels=False)
q = np.zeros((8, robot.nq), dtype=np.float32)
qd, tau = (np.zeros((8, robot.nv), dtype=np.float32) for _ in range(2))
print(robot.forward_dynamics(q, qd, tau).shape) # (8, 7)See Python wrappers and
installation.
Deep tutorial: gradient descent through GRiD with plain JAX
(examples/jax/ik_gradient_descent.py).
Generate one self-contained grid.cuh and #include it in your own kernels. This path needs only the generator and
nvcc: no per-robot .so and no Python at runtime.
pip install grid-rbd
grid-generate robot.urdf -o grid.cuh # -f floating base, --algorithm-list to trim
nvcc -arch=sm_90 -std=c++17 my_kernel.cu # the header vendors its GLASS linear algebraSee Generate CUDA for a robot and
examples/cuda/.
Deep tutorial: fuse dynamics into your own kernel
(examples/cuda/fused_control_step/, checked and timed against the host-function path).
Installation needs no GPU or compiler. Registering a robot compiles its CUDA on a machine with a compatible NVIDIA
GPU, CUDA toolkit and C++17 host compiler; the first load takes minutes and later loads reuse the cache. To develop
GRiD, or to use the sample URDFs in grid_assets/robots/, work from a checkout: git clone --recursive https://github.com/A2R-Lab/GRiD.git && cd GRiD && bash install/base_install.sh && source .venv/bin/activate.
A Docker image with grid-rbd, jax[cuda12], a cu128 torch wheel and the generated iiwa14 header is published as
ghcr.io/a2r-lab/grid:<version> (install/docker/Dockerfile; run with --gpus all). A conda recipe
(install/environment.yml) and a uv recipe are on the
installation page; neither is tested in CI.
| Topic | Site page |
|---|---|
| Everyday tasks, index of everything | How do I…? |
Python API (register_robot/load_robot, backends, env knobs, fp64 alpha) |
Python wrappers |
grid-generate CLI, the generated header, debug/print helpers |
Generate CUDA for a robot |
Floating-base conventions (pinocchio / legacy orderings), URDF parsing |
URDF API |
| Supported joints, algorithms and restrictions; per-backend inventory | CUDA support status · backend coverage |
C++ API layers (*_device / *_kernel / host wrapper) |
codegen architecture |
| Tests, signed GPU receipts, fixing a red receipt CI job | CUDA validation |
Benchmark harness, bench-only troubleshooting (e.g. --ptxas-opt-level) |
benchmarks |
| Release measurements and their method | release measurements |
| Contributing, adding an algorithm | contribution guidelines · adding an algorithm · CONTRIBUTING.md |
| Directory | Owns |
|---|---|
grid_codegen/ |
the code-generation engine: emits grid.cuh and the checked-in generated binding regions, driven by the abi_specs.py table |
bindings/ |
the grid-rbd Python package (NumPy/JAX/torch handles over a cached per-robot .so); see bindings/README.md |
grid_assets/ |
ten sample URDFs (robots/) + tuned per-GPU launch configs (launch_configs/) |
test/ |
pytest suites + the split-suite/receipt machinery |
examples/ |
notebooks/ (Python tour), codegen/, cuda/; see examples/README.md |
docs/ |
the Sphinx site (source/), the cover page (landing/), agent_debugging_guide.md, design_history/ |
external/, install/ |
peer submodules (GLASS, RBDReference, URDFParser); install scripts and requirements files |
The release measurements (September and October 2026, one NVIDIA RTX 5090 and an Intel Core Ultra 9 285K) cover RNEA, its analytical gradient and its Hessian on iiwa14, go2 and G1 at batch sizes 16 to 1024. Ratios are baseline time over GRiD time, so values above 1x favor GRiD. The method, every timing boundary and the caveats are on the release measurements page, and the benchmark harness reproduces the collection.
If you use GRiD in your research, please cite our paper "GRiD: GPU-Accelerated Rigid Body Dynamics with Analytical Gradients":
@inproceedings{plancher2022grid,
title={GRiD: GPU-Accelerated Rigid Body Dynamics with Analytical Gradients},
author={Brian Plancher and Sabrina M. Neuman and Radhika Ghosal and Scott Kuindersma and Vijay Janapa Reddi},
booktitle={IEEE International Conference on Robotics and Automation (ICRA)},
year={2022},
month={May}
}
MIT; see LICENSE.
 Brian Plancher |
 Zachary Pestrikov |
 Kwamena A |
 Ann Li |
 = |
 Cael Yasutake |
 Naren Loganathan |
 pruyontrarakk |