Skip to main content
AirGen currently supports four fundamental types of robots:
  • Aerial robots including quadrotors and VTOL platforms.
  • Wheeled robots including cars, forklifts, and ground rovers.
  • Quadrupeds such as the Ghost V60 and Unitree Go2 platforms.
  • Computer-vision (CV) agents for passive sensing workloads.
Even though these robot categories have different methods for control, AirGen provides a common API structure for sensors, cameras, and planning.
Which robot types are initialized in the AirGen Simulation environment depends on the configuration as selected through the session configuration GUI for OpenGRID or defined through the session configuration file for GRID Enterprise.

​
AirGen Client

AirGen exposes a native Python client hierarchy that mirrors the simulator subsystems. Every robot controller inherits from VehicleClient, which provides core capabilities such as sensor streaming, ground-truth access, weather controls, and environment queries. Form-factor specific clients extend this base:
  • MultirotorClient controls aerial platforms and VTOL craft.
  • CarClient drives wheeled robots, forklifts, and rovers.
  • LeggedClient targets quadrupeds such as the Ghost V60 and Unitree Go2.
GRID notebooks still initialize convenience wrappers from grid.robot (for example, AirGenDrone). Those helpers delegate to the AirGen clients described here; this page focuses on the underlying simulator SDK so you can work directly with the native AirGen interfaces.

​
Instantiating Clients

Create the client that matches your robot category. The defaults connect to the session’s Commander host; override ip, port, or timeout_value if you are running outside a managed GRID session. 
import airgen

drone = airgen.MultirotorClient()
car = airgen.CarClient()
quadruped = airgen.LeggedClient()
Each client shares the same pattern for enabling API control, arming motors, and issuing motion commands: 
drone.enableApiControl(True)
drone.armDisarm(True)
drone.takeoffAsync().join()
All motion APIs accept an optional robot_name. When you omit it, AirGen operates on the first robot defined in the session configuration (alphabetical order), which keeps single-robot scripts concise while still supporting heterogeneous fleets.

​
VehicleClient Capabilities

VehicleClient is the common base class for every robot type. It surfaces:
  • Sensor retrieval (simGetImages, getLidarData, getGpsData, …).
  • Ground-truth queries (simGetVehiclePose, simGetGroundTruthKinematics).
  • Environment controls (simSetWeatherParameter, simSetTimeOfDay).
  • Scene interaction helpers (object spawning, removal, tagging).
Instantiate it directly when you only need simulator-wide utilities: 
sim = airgen.VehicleClient()
state = sim.getImuData(robot_name="drone0")

​
MultirotorClient Highlights

MultirotorClient adds 6-DoF flight primitives: 
drone.takeoffAsync().join()
drone.moveByVelocityAsync(3.0, 0.0, 0.0, duration=2.0)
drone.rotateToYawAsync(90.0)
Use body-frame variants (moveByVelocityBodyFrameAsync, moveByAngleRatesThrottleAsync, etc.) when you need commands relative to the aircraft heading. VTOL nacelle control and gain tuning APIs are also available for advanced vehicles.

​
CarClient Highlights

CarClient provides Ackermann and differential-drive commands: 
from airgen import CarClient, CarControls

car = CarClient()
car.enableApiControl(True)
car.setCarControls(CarControls(throttle=0.4, steering=0.15))
car.getCarState()
Leverage dataset-friendly helpers such as simPlotPath and simShowRoad for autonomy workflows.

​
LeggedClient Highlights

LeggedClient exposes step-based and Cartesian gait control for quadrupeds: 
from airgen import LeggedClient

quadruped = LeggedClient()
quadruped.enableApiControl(True)
quadruped.standAsync().join()
quadruped.stepAsync(x=0.5, y=0.0, z=0.0).join()
Advanced APIs let you configure gait generators, body orientation targets, and joint gains, enabling precise locomotion research.

​
Ground Truth

The airgen client also allows access to simulation ground truth. For example, we can access the pose and kinematics for a specific robot via 
import airgen
client = airgen.VehicleClient()
pose = client.simGetVehiclePose(robot_name="drone0")
kinematics = client.simGetGroundTruthKinematics(robot_name="drone0")
where simGetVehiclePose returns a Pose object consisting of 3D position and quaternion vectors, and simGetGroundTruthKinematics returns a KinematicsState object made up of pose, twist, and acceleration.

​
Multi-Robot Control Patterns

To coordinate multiple robots, reuse a single client instance and pass the appropriate robot_name per call. For example, with a multirotor fleet: 
import airgen

client = airgen.MultirotorClient()

def takeoff_and_pan(client, robots):
    for name in robots:
        client.enableApiControl(True, robot_name=name)
        client.armDisarm(True, robot_name=name)
        client.takeoffAsync(robot_name=name)
    for name in robots:
        client.moveByVelocityAsync(3.0, 0.0, 0.0, 2.0, robot_name=name)
        client.rotateToYawAsync(90.0, robot_name=name)

takeoff_and_pan(client, ["drone0", "drone1"])
This pattern issues independent commands per robot while sharing the same connection. When you omit robot_name in a call, the first robot from the session settings (alphabetically sorted) is used.

​
Environment

The client also provides access to the simulation environment, including object interactions, weather, time of day, etc. as detailed in the Environment section.

​
Robot-Specific Interface

The MultirotorClient, CarClient, and LeggedClient classes provide additional, form-factor specific controls and functionality on top of VehicleClient. These additional features are described in the MultirotorClient, CarClient, and LeggedClient reference pages.