BEHAVIOR-1K Documentation

OmniGibson is an Embodied AI research platform built on NVIDIA's Omniverse. It provides a high-fidelity simulation environment characterized by:

• Photorealistic Visuals and Physical Realism: High-quality rendering and physics.
• Advanced Material Support: Support for fluid and soft body simulations.
• Large-Scale Assets: High-quality scenes and objects.
• Dynamic States: Kinematic and semantic object states that change dynamically.
• Robotics: Mobile manipulator robots equipped with modular controllers.
• Standardized Interface: An OpenAI Gym interface for easy integration with reinforcement learning workflows.

The simulator provides several object classes that can be imported into the environment. Most objects are initialized using a name or a file path (located within igibson.assets_path) and provide a load() function to import the object into PyBullet. This load() function is typically invoked by the Simulator via import_object or import_object methods.

Supported object types include:

• YCBObject
• RBOObject
• ShapeNetObject
• Pedestrian
• ArticulatedObject (provides APIs to get/set object pose)
• URDFObject
• SoftObject
• Cube
• VisualMarker
• VisualShape

OmniGibson supports six types of controllers categorized by their purpose and the robot morphology they target:

• General Controllers: Agnostic to robot morphology; can be used on any robot.
• Locomotion Controllers: Specifically for robots with navigation capabilities.
• Manipulation Arm Controllers: Designed to control a robot's end-effector pose.
• Manipulation Gripper Controllers: Designed to control a robot's gripper joints.

The BEHAVIOR Challenge requires agents to solve 100 full-length household tasks within the BEHAVIOR-1K environment. The challenge evaluates an agent's ability to combine high-level reasoning, long-horizon navigation, and dexterous bimanual manipulation in house-scale scenes.

Challenge Specifications

• Tasks: 100 full-length household tasks.
• Environments: 7 scenes (including 4 new scenes).
• Evaluation Track: Single track using RGB + depth + proprioception.
• Demonstrations: 20,000 human teleoperation demos (approx. 1,950 hours).
• Baselines: π0.5 (pi0.5) and GR00T N1.7.
• Ranking Metric: Average task success score with BDDL partial credit.

Important Dates

• Challenge Launch: 07/02/2026
• Submission Deadline: 10/16/2026
• Winners Announcement: 11/04/2026

The 2026 BEHAVIOR Challenge offers an $11,000 prize pool distributed as follows:

• 1st place: $5,000
• 2nd place: $3,000
• 3rd place: $2,000
• Outstanding open-source solution: $1,000

The downloaded assets directory follows this structure:

• models/: Contains robot models (e.g., ant, fetch, locobot), interactive objects, articulated objects, and scene components.
• networks/: Contains the pretrained model.pth (the "goggle" network used in Gibson V1).
• test/: Contains mesh files used for verifying renderer installation.
• example_configs/: Contains sample configuration files (deprecated).

assets
├── models
│   ├── ant
│   ├── ...
│   └── ycb
├── networks
│   └── model.pth
├── test
│   └── mesh
└── example_configs
    └── {}.yaml

A Prim (short for "primitive") is the fundamental building block of the Omniverse scene representation (the "stage"). It represents a single scene component such as a rigid body, joint, light, camera, or material.

In OmniGibson, Prim classes encapsulate underlying Omniverse UsdPrim instances, providing direct access to low-level Omniverse APIs. Each Prim instance is uniquely identified by its prim_path, a filepath-like string (e.g., /World/robot0/gripper_link) that defines its name and its position in the scene hierarchy.

BDDL is an object-centric domain-specific language based on predicate logic, designed for the BEHAVIOR benchmark for embodied AI agents. It is used to define realistic and complex activities in simulation by symbolically expressing an activity's initial and goal conditions.

Key capabilities of the BDDL codebase include:

• Parsing BDDL files (including custom ones).
• Compiling symbolic definitions into grounded physical simulations.
• Efficiently checking success and progress at every simulator step.
• Solving goal conditions to measure fine-grained progress for evaluation.

iGibson provides four distinct scene types depending on your requirements for complexity and interactivity:

• EmptyScene and StadiumScene: Simple scenes with flat grounds and no obstacles. Best for debugging.
• StaticIndoorScene: Loads static 3D scenes from igibson.g_dataset_path. It handles floor information, mesh loading, and builds internal traversability graphs for pathfinding.
• InteractiveIndoorScene: Loads fully interactive 3D scenes from igibson.ig_dataset_path. It includes advanced features like material/texture randomization, object randomization, scene quality checks, partial scene loading (by category, room type, or instance), and APIs to change the state of articulated objects (e.g., opening fridges).

Most scenes are loaded via a load() function, which is typically invoked by the Simulator using import_scene or import_ig_scene.