Isaac Gym: GPU-Native RL Simulation

Updated 1 January 2026

Isaac Gym is a GPU-native simulation and reinforcement learning platform that integrates a PhysX-based engine with PyTorch for efficient robotic simulations.
It employs a zero-copy data flow architecture that bypasses CPU-GPU transfers, enabling simultaneous simulation of thousands of robotic environments.
Its advanced parallelization and core RL algorithms accelerate sim-to-real transfer and optimize performance across manipulation, locomotion, and aerial robotics.

Isaac Gym is a GPU-native simulation and reinforcement learning (RL) platform introduced by NVIDIA for high-throughput robot learning research and development. It combines a GPU-resident physics engine (based on PhysX) with direct PyTorch interoperability, enabling end-to-end RL data generation and policy training entirely within GPU memory. Isaac Gym allows the simultaneous simulation of thousands of parallel robotic environments in a single scene, furnishing 2–3 orders of magnitude speedup compared to CPU-based simulators. The platform has established itself as the technical foundation for subsequent frameworks such as Isaac Lab and Aerial Gym, and is used across manipulation, locomotion, and aerial robotics domains (Makoviychuk et al., 2021, NVIDIA et al., 6 Nov 2025, Kulkarni et al., 3 Mar 2025, Kulkarni et al., 2023, Albardaner et al., 2024, Serrano-Muñoz et al., 2022).

1. GPU-Native System Architecture

Isaac Gym deploys the full simulation and learning pipeline onto the GPU, operating via core modules: (1) a GPU-resident PhysX physics engine, (2) custom CUDA kernels for observation and reward computation, and (3) a direct interface to PyTorch for actor-critic inference and gradient updates. All parallel environments are instantiated in a single large physics scene, maximizing CUDA core utilization and enabling tens of thousands of environments per GPU. Key buffers—including positions, velocities, forces, quaternions, and control signals—are exposed as device pointers and wrapped as PyTorch tensors. This unified approach bypasses CPU–GPU memory transfers, eliminating traditional bottlenecks (Makoviychuk et al., 2021, NVIDIA et al., 6 Nov 2025).

2. Zero-Copy Data Flow and Interoperability

Isaac Gym’s zero-copy interface allows physics state tensors to be directly acquired using python calls such as gym.acquire_*_tensor, which return descriptors into GPU memory; these are wrapped into PyTorch tensors with gymtorch.wrap_tensor. Observations flow directly to network inference, and actions are written back directly into PhysX buffers prior to each simulation step. With this mechanism, the RL loop (simulate → observe → infer → act → repeat) executes entirely within GPU memory after initialization and logging, obviating all intermediate CPU staging (Makoviychuk et al., 2021, Serrano-Muñoz et al., 2022). This architecture is critical for high-frequency control and large batch RL.

3. Parallelization and Core Algorithms

Isaac Gym exploits fine-grained GPU parallelism on multiple levels. (a) Physics integration is performed in parallel over actors, joints, and contact constraints; (b) down-stream reward and observation computation uses vectorized CUDA kernels across all parallel environments; (c) RL rollouts and training steps proceed synchronously for all environments, maximizing hardware saturation. Contact resolution, which is the main computational bottleneck in multi-body physics, is addressed using a Temporal Gauss–Seidel (TGS) solver, which achieves sub-step equivalence and constraint convergence with just N global iterations rather than serial sub-stepping. As a result, throughput metrics (e.g., >540,000 env-steps/sec for Ant locomotion) far exceed CPU-based codes (Makoviychuk et al., 2021, NVIDIA et al., 6 Nov 2025, Serrano-Muñoz et al., 2022).

Task/Env	Num Envs	Time to Policy	Throughput (env-steps/s)
Ant	4096	~20 s	~540,000
Humanoid	4096	~4 min	~200,000
Franka Stacking	16,384	~25 min	N/A
Shadow Hand	N/A	~35min–6h	N/A

4. Mathematical Foundations

Dynamics in Isaac Gym follow a batch formulation for rigid-body and jointed-articulation systems:

Rigid-body integration:

$\dot{x} = v,\quad \dot{v} = M^{-1}(F_{ext} + J^\top \lambda)$

where $M$ is the mass/inertia matrix, $J$ is the constraints Jacobian, $\lambda$ are the impulse/constraint Lagrange multipliers.

Contact resolution (TGS method):

$\Delta v^i = M^{-1}(J^\top \lambda^i + b),\quad v \gets v + \frac{dt}{N}\Delta v^i,\quad \lambda^{i+1} = \mathrm{Project}_+(\lambda^i + J v + b)$

The projection operator enforces physically plausible constraint forces and friction geometries (Makoviychuk et al., 2021, NVIDIA et al., 6 Nov 2025). All equations are evaluated in batch over the $N$ parallel environments.

5. Practical Usage and API Integration

Isaac Gym is provided as a Python API compatible with contemporary RL frameworks via direct tensor sharing. Practitioners typically:

Configure physics and RL parameters (e.g., sim_params.use_gpu_pipeline, YAML/JSON file for RL hyperparameters).
Initialize the simulation and load URDF/MJCF assets.
Acquire state and control tensors; wrap as PyTorch tensors.
Execute RL training using direct tensor loops or third-party libraries (rl_games, rllib, stable-baselines3, skrl) leveraging Gymnasium-like APIs (Serrano-Muñoz et al., 2022).

A minimal RL loop includes direct physics stepping, observation inference, action computation, and control writing, all on the GPU:

from isaacgym import gymapi, gymtorch
gym = gymapi.acquire_gym()
sim = gym.create_sim(...)
root_buf = gym.acquire_actor_root_state_tensor(sim)
dof_buf = gym.acquire_dof_state_tensor(sim)
root_states = gymtorch.wrap_tensor(root_buf)
dof_states  = gymtorch.wrap_tensor(dof_buf)
while not done:
    gym.simulate(sim); gym.fetch_results(sim, True)
    obs = compute_obs(root_states, dof_states)
    actions = policy(obs)
    gymtorch.unwrap_tensor(a_buf)[:] = actions
    gym.step(sim)

(Makoviychuk et al., 2021, Serrano-Muñoz et al., 2022)

6. Domain-Specific Extensions and Sim-to-Real Transfer

Isaac Gym is the foundation for specialized frameworks. In manipulation, RL policies have been trained for the TIAGo mobile manipulator, showing close correspondence between simulated and real robot dynamics—provided that joint stiffness/damping and collision geometries match the hardware configuration (Albardaner et al., 2024). In aerial robotics, extensions like Aerial Gym and Aerial Gym Simulator use Isaac Gym’s batching and tensor API to simulate parallel multirotor fleets with GPU-accelerated geometric controllers, scene randomization, and custom rendering (e.g., Warp raycaster), reporting successful sim2real transfer in vision-based navigation and state-feedback control (Kulkarni et al., 2023, Kulkarni et al., 3 Mar 2025). Benchmarks in these contexts report physics throughput on the order of millions of steps per second and robust learning outcomes.

7. Successors and Ecosystem

Isaac Lab extends the Isaac Gym paradigm with GPU-native differentiable physics (Newton engine), RTX-based photorealistic rendering, multi-frequency sensor simulation, and modular actuator models. Domain randomization and data pipelines are integrated, and composable MDP interfaces facilitate both RL and imitation learning. Empirical benchmarks confirm Isaac Lab’s speedup over Isaac Gym for multi-modal and sensor-rich RL, with up to 1.8×–3× throughput gains depending on task (NVIDIA et al., 6 Nov 2025). The skrl library natively supports Isaac Gym, allowing multi-agent and multi-scope experiments with modular PyTorch models, demonstrating linear scaling in throughput and a seamless interface for RL research (Serrano-Muñoz et al., 2022). Isaac Gym remains the reference architecture for scalable, high-throughput robot simulation and learning.

8. Limitations and Ongoing Developments

Limitations include lack of explicit support for differentiable simulation (addressed in Isaac Lab), constraints on sensor realism and rendering speed for large batches (addressed by accessory raycasting frameworks), and the need for careful configuration—especially with respect to actuated joints, collision meshes, and fidelity parameters—when targeting sim-to-real transfer. Ongoing work focuses on further parallelizing camera and rendering computations, supporting more flexible actuator modeling, and integrating fully differentiable physics engines (NVIDIA et al., 6 Nov 2025, Kulkarni et al., 3 Mar 2025).

Isaac Gym represents a technical milestone in GPU-native simulation and robot learning, enabling RL research at previously infeasible scale and speed, and providing a foundation for both core RL tasks and specialized domains including manipulation and aerial robotics.