Genesis

https://genesis-world.readthedocs.io/en/latest/
Admin
Genesis is a universal, ultra-fast, Python-based physics engine and robotics simulation platform...
Tokens:1,291,052
Snippets:7,440
Trust Score:8.3
Update:6 days ago
Show doc for...
Tokens:
Raw
### Setup LuisaRender: fetch submodule and install render extras

Source: https://genesis-world.readthedocs.io/en/latest/user_guide/rendering/index.html

Commands to initialize the LuisaRender submodule and install the render extras. Run inside the genesis-world repository.

```bash
# inside the genesis-world repo
git submodule update --init --recursive
pip install -e ".[render]"

```

--------------------------------

### gs launch command example

Source: https://genesis-world.readthedocs.io/en/latest/user_guide/interaction/visualization.html

Opens an asset in the interactive viewer. Accepts Mesh, URDF, MJCF, or USD files, and loads every rigid entity in a USD stage. Starts paused; use -c to visualize collision geometry, -r to rotate, -s SCALE to scale, and -l to show link frames.

```bash
gs launch xml/franka_emika_panda/panda.xml

```

--------------------------------

### Install Genesis World from PyPI

Source: https://genesis-world.readthedocs.io/en/latest/_sources/index.md.txt

Install Genesis World using pip. Requires PyTorch to be installed first.

```bash
pip install genesis-world
```

--------------------------------

### Install NVIDIA GL libraries

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/overview/installation.md.txt

Install the NVIDIA GL libraries to ensure GPU rendering is active.

```bash
sudo apt update && sudo apt install -y libnvidia-gl-525
```

--------------------------------

### Run go2_backflip.py example

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/policy_training/examples/locomotion.md.txt

Command to execute the go2_backflip.py example with the 'single' environment. This example subclasses Go2Env to add a phase-based observation and loads a pre-trained TorchScript policy.

```bash
python examples/locomotion/go2_backflip.py -e single
```

--------------------------------

### Install dependencies for training

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/policy_training/examples/hover_env.md.txt

Install pip and the required packages: tensorboard and rsl-rl-lib>=5.0.0.

```bash
pip install --upgrade pip
pip install tensorboard "rsl-rl-lib>=5.0.0"
```

--------------------------------

### Install LuisaRender dependencies and render extras

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/rendering/index.md.txt

First step to set up the deprecated Luisa ray-tracing backend. Run inside the genesis-world repo to fetch submodules and install the render extras.

```bash
# inside the genesis-world repo
git submodule update --init --recursive
pip install -e ".[render]"
```

--------------------------------

### Install dependencies for Stage 1 RL training

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/policy_training/examples/manipulation.md.txt

Installs TensorBoard and rsl-rl-lib version 5.0.0 or higher, required for PPO training.

```bash
pip install tensorboard "rsl-rl-lib>=5.0.0"
```

--------------------------------

### Camera.start_recording()

Source: https://genesis-world.readthedocs.io/en/latest/api_reference/visualization/camera.html

Starts recording.

```APIDOC
## Camera.start_recording()

### Description
Starts recording.

### Method
start_recording

### Parameters
None

### Returns
None
```

--------------------------------

### Install Genesis World render extras for ImGui overlay

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/interaction/interactive_debugging.md.txt

Install the 'render' extras required for the ImGui overlay. If pre-built imgui-bundle wheels are unavailable, install imgui-bundle from source, which requires CMake. Enabling the GUI without this dependency raises an error.

```bash
pip install "genesis-world[render]"
```

--------------------------------

### Viewer.setup_camera()

Source: https://genesis-world.readthedocs.io/en/latest/api_reference/visualization/viewer.html

Sets up the camera with default parameters.

```APIDOC
## Viewer.setup_camera()

### Description
Sets up the camera with default parameters.

### Method
setup_camera

### Signature
setup_camera()

```

--------------------------------

### RigidVisGeom.vface_start

Source: https://genesis-world.readthedocs.io/en/latest/api_reference/engine/entity/rigid_entity/rigid_visgeom.html

Property that gets the starting index of the vgeom's faces in the rigid solver.

```APIDOC
## RigidVisGeom.vface_start

### Description
Get the starting index of the vgeom's faces in the rigid solver.

### Property
vface_start

### Returns
- **vface_start** (int) - The starting face index.
```

--------------------------------

### Backend selection examples: gs.gpu and gs.cpu

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/configuration/initialization.md.txt

Shows portable GPU initialization with fallback and forced CPU initialization for CI or debugging.

```python
gs.init(backend=gs.gpu)   # portable: use a GPU if present, else CPU
gs.init(backend=gs.cpu)   # force CPU, e.g. for CI or debugging
```

--------------------------------

### RigidVisGeom.vvert_start

Source: https://genesis-world.readthedocs.io/en/latest/api_reference/engine/entity/rigid_entity/rigid_visgeom.html

Property that gets the starting index of the vgeom's vertices in the rigid solver.

```APIDOC
## RigidVisGeom.vvert_start

### Description
Get the starting index of the vgeom's vertices in the rigid solver.

### Property
vvert_start

### Returns
- **vvert_start** (int) - The starting vertex index.
```

--------------------------------

### Minimal example: constant crosswind force field

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/physics/force_fields.md.txt

Creates a scene with SPH liquid, adds a constant force field, activates it, and steps the simulation. The field starts inactive and must be activated after building. The example uses gs.force_fields.Constant with direction (1,0,0) and strength 5.0.

```python
import genesis as gs

gs.init(backend=gs.cpu)

scene = gs.Scene(
    sim_options=gs.options.SimOptions(dt=4e-3, substeps=10),
    sph_options=gs.options.SPHOptions(
        lower_bound=(-0.5, -0.5, 0.0),
        upper_bound=(0.5, 0.5, 1.0),
        particle_size=0.01,
    ),
    show_viewer=True,
)

scene.add_entity(gs.morphs.Plane())
liquid = scene.add_entity(
    material=gs.materials.SPH.Liquid(),
    morph=gs.morphs.Box(pos=(0.0, 0.0, 0.65), size=(0.4, 0.4, 0.4)),
)

# Instantiate, then register with the scene *before* building.
wind = gs.force_fields.Constant(direction=(1, 0, 0), strength=5.0)  # 5 m/s2 along +X
scene.add_force_field(wind)

scene.build()

wind.activate()  # fields start inactive; turn it on to apply acceleration
for i in range(1000):
    scene.step()
```

--------------------------------

### Configure viewer and visual options with show_viewer=True

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/interaction/visualization.md.txt

Creates a scene with the viewer enabled, setting window resolution, camera pose and FOV via `ViewerOptions`, and visual properties like world frame, link frames, camera meshes, plane reflection, and ambient light via `VisOptions`. `camera_pos` and `camera_lookat` are in meters in a Z-up frame; `camera_fov` is vertical degrees. If `res` is `None`, a 4:3 window sized to half display height is used.

```python
scene = gs.Scene(
    viewer_options=gs.options.ViewerOptions(
        res=(1280, 960),
        camera_pos=(3.5, 0.0, 2.5),
        camera_lookat=(0.0, 0.0, 0.5),
        camera_fov=40,
    ),
    vis_options=gs.options.VisOptions(
        show_world_frame=True,  # draw the world coordinate frame at the origin
        world_frame_size=1.0,  # length of each axis, in meters
        show_link_frame=False,  # do not draw per-link frames
        show_cameras=False,  # do not draw camera meshes and frustums
        plane_reflection=True,
        ambient_light=(0.1, 0.1, 0.1),
    ),
    show_viewer=True,
)
```

--------------------------------

### gs.morphs.Nowhere

Source: https://genesis-world.readthedocs.io/en/latest/_sources/api_reference/engine/entity/morph/nowhere.md.txt

The Nowhere morph is a placeholder morph that carries no initial geometry. It is used for particle entities that start empty and are populated at runtime, for example the target of an emitter.

```APIDOC
## gs.morphs.Nowhere

### Description
The Nowhere morph is a placeholder morph that carries no initial geometry. It is used for particle entities that start empty and are populated at runtime, for example the target of an emitter.

### Usage
```python
import genesis as gs

# Example usage: create a particle entity with Nowhere morph
entity = gs.morphs.Nowhere()
```

### Notes
- This morph is a placeholder and does not define any initial geometry.
- It is typically used in conjunction with an emitter to populate particles at runtime.

```

--------------------------------

### Register custom ImGui panel with ImGuiOverlayPlugin

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/interaction/interactive_debugging.md.txt

Gets the auto-attached ImGuiOverlayPlugin from the viewer and registers a custom panel. The callback receives the live ImGui module, allowing use of any ImGui widgets. This example adds a simple text panel.

```python
from genesis.ext.pyrender.overlay import ImGuiOverlayPlugin

plugin = next(p for p in scene.viewer.plugins if isinstance(p, ImGuiOverlayPlugin))


def custom_panel(imgui):
    imgui.text("Custom Demo Panel")
    imgui.text("This panel was registered via register_panel()")


plugin.register_panel(custom_panel)
```

--------------------------------

### Minimal SurfaceDistanceProbe setup

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/sensing/surface_distance.md.txt

Initializes Genesis, creates a scene with a Shadow Hand robot and a duck mesh, adds a SurfaceDistanceProbe sensor on the palm link with one probe, builds the scene, steps it, and reads distances and nearest points.

```python
import genesis as gs

gs.init(backend=gs.cpu)

scene = gs.Scene()
robot = scene.add_entity(gs.morphs.URDF(file="urdf/shadow_hand/shadow_hand.urdf"))
duck = scene.add_entity(
    gs.morphs.Mesh(file="meshes/duck.obj", scale=0.06, pos=(-0.2, 0.4, 0.6)),
)

sensor = scene.add_sensor(
    gs.sensors.SurfaceDistanceProbe(
        entity_idx=robot.idx,
        link_idx_local=robot.get_link("palm").idx_local,
        probe_local_pos=((0.0, 0.0, 0.0),),  # one probe at the palm-link origin
        probe_radius=0.5,                     # max sensing range, meters
        track_link_idx=(duck.base_link_idx,),  # global link idx to measure against
    )
)

scene.build()
scene.step()

distances = sensor.read()        # shape ([n_envs,] n_probes), meters
points = sensor.nearest_points   # shape ([n_envs,] n_probes, 3), world frame
```

--------------------------------

### IPC Robot Grasp Cube Setup

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/theory/coupling/ipc_coupler.md.txt

Configures a Genesis scene with IPCCouplerOptions, adds a Franka arm with rigid material and coupling links, and adds a deformable cube with FEM elastic material. The example couples only the fingers and disables rigid-rigid and rigid-ground contacts.

```python
scene = gs.Scene(
    sim_options=gs.options.SimOptions(dt=0.01),
    coupler_options=gs.options.IPCCouplerOptions(
        constraint_strength_translation=10.0,
        constraint_strength_rotation=10.0,
        enable_rigid_rigid_contact=False,  # only finger-cube contact matters here
        enable_rigid_ground_contact=False,
    ),
)

franka = scene.add_entity(
    gs.morphs.MJCF(file="xml/franka_emika_panda/panda_non_overlap.xml"),
    material=gs.materials.Rigid(
        coup_type="two_way_soft_constraint",
        coup_links=("left_finger", "right_finger"),
        coup_friction=0.8,
    ),
)

cube = scene.add_entity(
    morph=gs.morphs.Box(pos=(0.65, 0.0, 0.03), size=(0.05, 0.05, 0.05)),
    material=gs.materials.FEM.Elastic(
        E=5.0e4,  # Young's modulus (Pa)
        nu=0.45,
        rho=1000.0,
        friction_mu=0.5,
        model="stable_neohookean",
    ),
)

```

--------------------------------

### Complete Hello Genesis World Script

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/getting_started/hello_genesis.md.txt

The full tutorial script that initializes Genesis, creates a scene, adds a plane and a Franka arm, builds the scene, and steps 1000 times.

```python
import genesis as gs

gs.init(backend=gs.cpu)

scene = gs.Scene()

plane = scene.add_entity(gs.morphs.Plane())
franka = scene.add_entity(
    gs.morphs.MJCF(file="xml/franka_emika_panda/panda.xml"),
)

scene.build()
for i in range(1000):
    scene.step()
```

--------------------------------

### SphericalPattern configuration

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/sensing/raycaster.md.txt

Constructs a spherical ray pattern with azimuth and elevation fields of view. Use fov and n_points for a typical setup, or override with angular_resolution or explicit angle arrays. A Velodyne VLP-16 example is fov=(360.0, 30.0), n_points=(1800, 16).

```python
gs.sensors.SphericalPattern(
    fov=(360.0, 60.0),   # (horizontal, vertical) degrees; a scalar is centered on 0deg,
                         # a (min, max) tuple gives an asymmetric range
    n_points=(128, 64),  # (horizontal, vertical) ray counts -> return_shape (128, 64)
    # angular_resolution=(0.25, 0.5),  # degrees per ray; overrides n_points
    # angles=(h_angles, v_angles),     # explicit angle arrays; overrides the rest
)
```

--------------------------------

### Build rigid-soft association from soft part (partial)

Source: https://genesis-world.readthedocs.io/en/latest/_modules/genesis/engine/entities/hybrid_entity.html

Starts building the rigid-soft association from the soft side, computing distances between particle positions and each link treated as a line segment. The snippet is truncated mid-function; it shows the initial loop setup and the computed line vector and length.

```python
def default_func_instantiate_rigid_soft_association_from_soft(part_rigid, part_soft):
    # compute distance between particle position and line segment of each link
    augment_link_world_coords(part_rigid)
    positions = part_soft.init_particles
    dist_to_links = []
    link_idcs = []
    geom_idcs = []
    trans_local_to_global = []
    quat_local_to_global = []
    for i, link in enumerate(part_rigid.links):
        geom = link.geoms[0]
        link_end_x_pos = (
            gu.transform_by_trans_quat(np.zeros((3,)), trans=geom.init_pos * 2, quat=geom.init_quat) + link.init_x_pos
        )  # TODO: check if this is correct

        p0 = link.init_x_pos
        p1 = link_end_x_pos

        line_vec = p1 - p0  # NOTE: assume a link is a line segment
        line_length = np.linalg.norm(line_vec)

```

--------------------------------

### gs.init(backend=gs.gpu)

Source: https://genesis-world.readthedocs.io/en/latest/_sources/api_reference/utilities/device.md.txt

Initializes Genesis World with automatic backend selection, trying CUDA, ROCm, Metal, then CPU, and warns if falling back to CPU.

```APIDOC
## gs.init(backend=gs.gpu)

### Description
Initializes Genesis World with automatic backend selection. It tries CUDA, then ROCm (gs.amdgpu), then Metal, then CPU, and warns when it lands on the CPU because no GPU was available.

### Method
Initialization function

### Parameters
- **backend** (gs.backend) - Required - The backend to use. Use `gs.gpu` for automatic selection.

### Example
```python
import genesis as gs

gs.init(backend=gs.gpu)

print(gs.backend)  # the backend it settled on: gs.cuda, gs.amdgpu, gs.metal, or gs.cpu
print(gs.device)  # the matching PyTorch device: cuda:0, mps:0, or cpu
```

### Notes
- If no GPU is available, it falls back to CPU with a warning.
- The `precision` argument decides the float width, and the dtype aliases follow it.
```

--------------------------------

### Install pyuipc

Source: https://genesis-world.readthedocs.io/en/latest/user_guide/theory/coupling/ipc_coupler.html

Install the optional pyuipc package, which provides the libuipc dependency required for IPC coupling. It is not installed with Genesis World by default.

```bash
pip install pyuipc

```

--------------------------------

### start method

Source: https://genesis-world.readthedocs.io/en/latest/_modules/genesis/recorders/base_recorder.html

Starts the recording thread if run_in_thread is True.

```python
@gs.assert_built
def start(self):
    """Start the recording thread if run_in_thread is True."""
    self._is_recording = True
    if self.run_in_thread:
        self.start_thread()
```

--------------------------------

### Checkpoint and restore a scene with pickle and __getstate__/__setstate__

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/configuration/checkpoints.md.txt

Shows how to save a scene's state after 100 steps, create a built copy via pickle, step further, and restore to the checkpoint. The checkpoint is device-resident and restoring also resets the gradient tape, sensors, recorders, and viewer.

```python
import pickle

scene.build(n_envs=16)
for _ in range(100):
    scene.step()

checkpoint = scene.__getstate__()  # a device-resident copy of the state at step 100
twin = pickle.loads(pickle.dumps(scene))  # a built copy of the scene, standing at step 100

for _ in range(50):
    scene.step()
scene.__setstate__(checkpoint)  # back to step 100, and the next 50 steps land where they did
```

--------------------------------

### Scene and drone setup in HoverEnv constructor

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/policy_training/examples/hover_env.md.txt

Builds a Genesis scene with a 100 Hz control loop, adds a ground plane and a Crazyflie drone, and builds the batched simulation with a given number of environments.

```python
self.dt = 0.01  # 100 Hz control loop
self.scene = gs.Scene(
    sim_options=gs.options.SimOptions(dt=self.dt, substeps=2),
    rigid_options=gs.options.RigidOptions(
        dt=self.dt,
        constraint_solver=gs.constraint_solver.Newton,
        enable_collision=True,
        enable_joint_limit=True,
    ),
    show_viewer=show_viewer,
)
self.scene.add_entity(gs.morphs.Plane())
self.drone = self.scene.add_entity(gs.morphs.Drone(file="urdf/drones/cf2x.urdf"))
self.scene.build(n_envs=num_envs)
```

--------------------------------

### Run LuisaRender demo

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/rendering/index.md.txt

Runs the demo script for the Luisa ray-tracing backend from the examples/rendering directory.

```bash
cd examples/rendering
python demo.py
```

--------------------------------

### Install gs-madrona batch renderer

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/rendering/index.md.txt

Installs the gs-madrona package from PyPI. Prebuilt wheels are available for x86 and Python >= 3.10.

```bash
pip install gs-madrona
```

--------------------------------

### Install OSMesa and enforce direct rendering

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/overview/installation.md.txt

Install the latest OSMesa and enforce direct rendering if the previous method fails.

```bash
sudo add-apt-repository ppa:kisak/kisak-mesa
sudo apt update && sudo apt upgrade
export LIBGL_ALWAYS_INDIRECT=0
```

--------------------------------

### Start training command

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/policy_training/examples/locomotion.md.txt

Runs the training script from the repository root. By default, it runs 4096 environments in parallel for 101 iterations under the experiment name `go2-walking`, saving checkpoints and `cfgs.pkl` into `logs/go2-walking/`.

```bash
python examples/locomotion/go2_train.py
```

--------------------------------

### Configure scene with simulation and viewer options

Source: https://genesis-world.readthedocs.io/en/latest/_sources/user_guide/getting_started/hello_genesis.md.txt

Creates a scene with custom simulation timestep (dt), gravity, and initial camera pose. dt is in seconds, gravity points down along -Z, and viewer options set the camera position, look-at point, and field of view.

```python
scene = gs.Scene(
    sim_options=gs.options.SimOptions(dt=0.01, gravity=(0, 0, -10.0)),
    viewer_options=gs.options.ViewerOptions(
        camera_pos=(3.5, 0.0, 2.5),
        camera_lookat=(0.0, 0.0, 0.5),
        camera_fov=40,
    ),
    show_viewer=True,
)
```

--------------------------------

### Import Nyx plugin and camera options

Source: https://genesis-world.readthedocs.io/en/latest/user_guide/rendering/nyx_renderer.html

Verify the installation by importing the Nyx plugin modules and NyxCameraOptions alongside Genesis World.

```python
import genesis as gs
import gs_nyx.nyx_py_renderer as npr
import gs_nyx.nyx_py_sdk as nps
from gs_nyx_plugin.nyx_camera_options import NyxCameraOptions

```

--------------------------------

### Install Omniverse Kit for material baking

Source: https://genesis-world.readthedocs.io/en/latest/user_guide/assets/usd_import.html

Installs omniverse-kit from the NVIDIA index and accepts the EULA non-interactively. Required for baking materials that are not UsdPreviewSurface.

```bash
pip install --extra-index-url https://pypi.nvidia.com/ omniverse-kit
export OMNI_KIT_ACCEPT_EULA=yes

```
Tokens:
Raw