GRiD

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.

Two entry points

Both entry points use the same generated CUDA.

Python wrappers

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).

Header-only CUDA

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 algebra

See 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.

Where things are documented

Repo map

Performance

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.

Citing GRiD

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}
}

License

MIT; see LICENSE.

Contributors

Brian Plancher	Zachary Pestrikov	Kwamena A	Danelle Tuchman	Ann Li
=	EmreAdabag	Cael Yasutake	Naren Loganathan	emilyburnett2003
pruyontrarakk	Kimiya Shahamat	Kimiya Shahamat