cs.RONov 15, 2026

RoboKit: Accelerating Parallel Differentiable Optimization for Robot Learning

Authors: Jianglong Ye, Xuanbin Peng, Conor Mc Gartoll, Changwei Jing, Lai Wei, Jiali Chen, Xueyan Zou, Xiaolong Wang

Organizations: UC San Diego

Abstract

We present RoboKit, a high-performance, general-purpose toolkit for parallel differentiable optimization in robotics, built on three principles: (i) Performance and flexibility: GPU-parallel multi-seed solvers pair sampling with versatile optimizers, running 2-60×\times faster than task-specific baselines across seven tasks; (ii) Geometry, rendering and physics: hybrid and coarse-to-fine representations accelerate collision, differentiable rendering and simulation, optimizing 4096 grasps in 2.97 s; (iii) Integration with learning: costs are differentiable and simulation is parallel, so RoboKit both distills optimization into policies and trains RL; distilled policies run 9-240×\times faster at comparable accuracy, and RL reaches a GPU baseline's scores up to 2.1×\times sooner on the same simulator.

Figures & tables

Appendix figures & tables8 assets

Supplementary material from the paper’s appendix.

Appendix

Explore similar work

Nov 2, 2026

RoboScope Kit: Unified Interfaces for Fast and Scalable Embodied-AI Evaluation

Simulation benchmarks are the standard way to compare robot policies, but each benchmark brings its own evaluator, observation layout, and action convention, and evaluation is slow: 500 RoboTwin Easy episodes with one simulator and one model on one GPU take 359.7 minutes. Profiling the official StarVLA evaluator shows that simulation occupies CPU cores while the GPU averages 14.3% utilization. RoboScope Kit wraps each model once in a Python class called a Policy, and each benchmark once in an adapter around the benchmark's own evaluator, so the benchmark's rules and scoring stay unchanged. Scheduling runs simulator workers and Policy replicas as separate pools, sizes both from measured probes, and shards work deterministically across GPU instances; runtime optimization renders only the observations an action-chunk Policy reads. Adapters cover six benchmark families. On LIBERO-Long with a StarVLA checkpoint on one 48 GiB RTX 4090, the concurrency search selects twelve simulator workers sharing three Policy replicas, which evaluate 500 episodes 4.45×\times faster than the official StarVLA evaluation with equivalent success rates, 2.78×\times faster than RLinf, and 1.52×\times faster than vla-eval at its tuned configuration. With CUDA MPS, which lets the replicas run their kernels concurrently, the search selects sixteen workers sharing four replicas, 6.16×\times faster than StarVLA, 3.85×\times faster than RLinf, and 2.10×\times faster than vla-eval. On RoboTwin Easy, four GPUs with chunk-boundary observation complete the 500 episodes in 14.4 minutes, 25.04×\times faster than the single-GPU baseline, with identical success outcomes and terminal steps.
Jun 24, 2026

Scaling Nonlinear Optimization: Many Problems One GPU

Modern GPUs and software frameworks have made sampling-based methods, such as reinforcement learning and model predictive path integral control, increasingly popular in robotics. However, the logic these methods can execute per sample is limited to what has been implemented on the GPU. Nonlinear programs (NLPs) are one of the most expressive tools in robotics, reliably minimizing a cost while exactly enforcing general constraints. NLP optimizers were among the field's main workhorses, but were not designed for modern GPU hardware. Embedding NLPs such as trajectory optimization and inverse kinematics directly within each sample would be highly valuable, yet the only current option is to call a CPU solver per sample, possibly in parallel on a multi-core CPU. This bottlenecks the CPU, requires GPU-to-CPU-to-GPU transfers when the rest of the pipeline resides on the GPU, and leaves the GPU intermittently idle. To address this issue, in this work we present jaxipm, the first GPU-batched solver for generally constrained nonlinear optimization problems. Our approach is a JAX implementation of the battle-tested IPOPT algorithm, facilitated by eliminating control flow through heterogeneous iteration fusion, and minimizing GPU idle time through iteration-level batching. Our implementation enables solving hundreds of NLPs in parallel on a single GPU. We validate jaxipm on a range of quadrotor nonlinear model predictive control benchmarks, where on a single GPU we achieve between 30.7% and 69.9% of the throughput of 64 IPOPT instances running in parallel on a 64-core CPU. open-source codebase: https://github.com/johnviljoen/jaxipm
May 29, 2026

Batched Differentiable Rigid Body Dynamics in PyTorch for GPU-Accelerated Robot Learning

As robot control shifts toward large-scale reinforcement learning with in-loop dynamics computation, the community's reliance on CPU-bound libraries such as Pinocchio creates a throughput bottleneck in GPU-based training pipelines. We present BARD (Batched Articulated Rigid-body Dynamics), a self-contained PyTorch implementation of Featherstone's rigid-body dynamics algorithms, optimized for batched GPU evaluation and automatic differentiation. Three design choices make this efficient: a tiered lazy-evaluation cache that avoids redundant tree traversals, matmul-free joint transforms via pre-computed Rodrigues constants, and level-parallel propagation that reduces sequential operations to tree-depth batched steps. On five robot models (7-23 DOFs), BARD matches Pinocchio numerically while reaching up to 64x higher throughput for Forward Kinematics and 63x for Jacobians at batch size 4096 on an NVIDIA H200. We validate differentiability through gradient-based system identification on a 7-DOF manipulator, recovering link masses to 1.24% mean error under 5% torque noise, and integrate BARD into an Isaac Lab AMP training pipeline for an 11-DOF spined quadruped with 4096 parallel environments, where it is 8.5x faster than Pinocchio and 2.0x faster than ADAM for in-loop dynamics. BARD is open-sourced at: https://github.com/YueWang996/bard-pytorch-dynamics.