tinysim 0.0.1__py3-none-any.whl

tinysim/topdown_driving/widget.py

@@ -0,0 +1,60 @@
+import pathlib
+import anywidget
+import traitlets
+import asyncio
+import numpy as np
+from IPython.display import display
+from jupyter_ui_poll import ui_events
+
+from . import TopDownDrivingEnv, LOCAL_WALLS
+
+
+class TopDownDrivingWidget(anywidget.AnyWidget):
+    _esm = pathlib.Path(__file__).parent / "sim.js"
+
+    sim_state = traitlets.Dict(default_value={}).tag(sync=True)
+    wall_positions = traitlets.List(default_value=LOCAL_WALLS).tag(sync=True)
+    
+    _viewport_size = traitlets.Tuple(
+        traitlets.Int(), traitlets.Int(), default_value=(800, 600)
+    ).tag(sync=True)
+    _view_ready = traitlets.Bool(default_value=False).tag(sync=True)
+
+    def __init__(self, viewport_size=(800, 600), sim_env=None):
+        self._viewport_size = viewport_size
+        super().__init__()
+        if sim_env is None:
+            sim_env = TopDownDrivingEnv()
+
+        self.sim_env = sim_env
+        self.copy_py_state(self.sim_env.reset())
+
+    def render(self):
+        display(self)
+
+        try:
+            with ui_events() as ui_poll:
+                while not self._view_ready:
+                    ui_poll(100)
+        except Exception:
+            pass
+        
+    
+    def copy_py_state(self, sim_state: dict):
+        self.sim_state = {
+            "x": sim_state["x"].tolist(),
+            "y": sim_state["y"].tolist(),
+            "angle": sim_state["angle"].tolist(),
+        }
+
+    async def step(self, action: int, dt: float = 0.01) -> dict:
+        sim_state = self.sim_env.step(action)
+        self.copy_py_state(sim_state)
+
+        await asyncio.sleep(dt)
+        return sim_state
+
+    async def reset(self) -> dict:
+        sim_state = self.sim_env.reset()
+        self.copy_py_state(sim_state)
+        return sim_state

tinysim-0.0.1.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: tinysim
+Version: 0.0.1
+Summary: small modular simulation environments
+Author-email: Matthew Taylor <matthew.taylor.andre@gmail.com>
+Project-URL: Homepage, https://github.com/MatthewAndreTaylor/TinySim
+Keywords: jupyter,simulation
+Classifier: Framework :: Jupyter
+Classifier: Framework :: Jupyter :: JupyterLab
+Classifier: Framework :: Jupyter :: JupyterLab :: 4
+Classifier: Framework :: Jupyter :: JupyterLab :: Extensions
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: anywidget
+Requires-Dist: jupyter-ui-poll
+Provides-Extra: warp
+Requires-Dist: warp-lang==1.8.1; extra == "warp"
+
+
+# TinySim 
+
+[![PyPI](https://img.shields.io/pypi/v/coderbot-sim.svg)](https://pypi.org/project/coderbot-sim)
+[![Jupyterlite](https://jupyterlite.rtfd.io/en/latest/_static/badge.svg)](https://matthewandretaylor.github.io/CoderBots/lab?path=example.ipynb)
+
+The goal of this project is to create more minimal simulation environments for robotics and machine learning.
+
+Existing solutions like [ROS 2](https://github.com/ros2) and [Gymnasium](https://gymnasium.farama.org/) come with many heavy dependencies.
+
+Additionally they are usually difficult to get setup and may require domain specific knowledge to use.
+Simulation environments should be able to run in any notebook environment and require fewer dependencies.
+
+
+## Get Started 🚀
+
+To use the baseline Python only simulation environments.
+
+```bash
+pip install tinysim
+```
+
+To use the [warp](https://github.com/NVIDIA/warp) simulation environments.
+
+```bash
+pip install tinysim[warp]
+```
+
+
+

tinysim-0.0.1.dist-info/RECORD

@@ -0,0 +1,33 @@
+tinysim/__init__.py,sha256=ptkxqwWun-Tw-L2-zUTm2fqunNgdLBkdU3DHF1wAMBI,197
+tinysim/_tk_base.py,sha256=kzF-41H56A5FWNxtMhlvEbl3iH8Wp04zTqAxTcjRPDM,1279
+tinysim/flappy/__init__.py,sha256=lUHGteFeYRb2vQ3-x9WxnKWM7sfsDwIHoVps732JIDY,3482
+tinysim/flappy/sim.js,sha256=g8ycKdJGopu0Z5CeBgtF8Rr2Pe64dTFcSiYh7hzYPzU,3190
+tinysim/flappy/tk.py,sha256=DUJqy0uPn-AvNE4tuA3a4Dh6xaj0twsUOP8leqGgBX4,2458
+tinysim/flappy/widget.py,sha256=zyaoW-rWgAkmbCY7yrSYyAZDUQaAPnuQEzldSawkOnI,1597
+tinysim/frogger/__init__.py,sha256=gA2jvG_WDZRpZY0Zg_aJmWrdsk2siIL49wjFTRfOSxo,5227
+tinysim/frogger/sim.js,sha256=b1HfEtFZFbbsrZNtltuWO4h-QM4Fw3XjMRydwm5l2NU,3081
+tinysim/frogger/tk.py,sha256=3A1wnWcOBCoRNSI4-oHFbMpRwf0iwdV54GBgtAxVufo,2823
+tinysim/frogger/widget.py,sha256=Bvb6aUiVqJTHTdd6EzpCp0FqpRa0bl9RNcK12_weiPM,1810
+tinysim/mountain_car/__init__.py,sha256=V3Qxj_ydWAqOJiQUqmIRegBe9GNjU82BfbG2XvV0OQg,1986
+tinysim/mountain_car/sim.js,sha256=z7kxl7LbkRglfzXxmrBbwz2vMYdQV84QP3WhE0hoPVQ,4581
+tinysim/mountain_car/styles.css,sha256=a8Bc64RdRNB1uWsBdpMEQA9STZO8mVAB2vvIPhhYuik,63
+tinysim/mountain_car/tk.py,sha256=EbnLirA0Q5egJaDUzu_WkGjbofbclwYUcHIvvifNt0Y,4256
+tinysim/mountain_car/widget.py,sha256=bUIXsofy5moBXMDBdIOVvRi59NFbLRRQ1WZcwm_mYG8,1726
+tinysim/simple_amr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tinysim/simple_amr/example_maps.py,sha256=38duuHbd6HvhQBIIcg9PWokNMjkasPSsKPjHnBhv9qQ,3307
+tinysim/simple_amr/sim.js,sha256=2YW2YWEEe-QWgJGLAdpt1aZi__sLL5ML84fv1s90poY,11575
+tinysim/simple_amr/styles.css,sha256=t85kXf0xyrq5ldL-j_pV0FEekWoorK63T_ZorWEgBOw,1087
+tinysim/simple_amr/widget.py,sha256=dmNcftB7-Z9Kf3hQ0MBaJvo97eyjCA6R74oEkHASMas,2557
+tinysim/topdown_driving/__init__.py,sha256=HiRpxQNeu4IIOPFraGHLTO2F0VNISAk6bUiK1rsbZTE,6228
+tinysim/topdown_driving/sim.js,sha256=5jmyQk4zp4KFhaG-uTsW_Cq1gHoIkR9d2Cv_ezDKarM,3076
+tinysim/topdown_driving/tk.py,sha256=8UB95ZjIJiUQeXC5w3pXkjukOJXfisLKrfIn0bVFzjU,4751
+tinysim/topdown_driving/track_0.json,sha256=3zPfPX72s5zxs4znoO8rXBqGNciai10Jbl2rFCaACow,15338
+tinysim/topdown_driving/widget.py,sha256=UqhV9Dps8BQTwTFP1g2wlmzql2ooAhAU8-YF8OmpoD8,1734
+tinysim_warp/cart_pole/__init__.py,sha256=fITV-kzKqhvgqek4_qBkL1OeAYFfdpv1Xp7PkM9h0EY,8349
+tinysim_warp/quadruped/__init__.py,sha256=GZUb4GGaVIVTgnm98DEthSmZ36uWxsGeHH7qafawtOE,6398
+tinysim_warp/simple_quadruped/__init__.py,sha256=iXnFzJQzDhhJtK0EYgJF8_4r-QMb7QtEbmdHxcul2_M,5334
+tinysim_warp/simple_quadruped/simple_quadruped.urdf,sha256=UfyGROUD5Qlf_t5ISipE2L7uQPBl-hwFnmRsjNL9yH4,8311
+tinysim-0.0.1.dist-info/METADATA,sha256=T3JEKYm1o7dE59b_gMb_6PnYWEFz3MDWi6kJS-GBNfw,1954
+tinysim-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tinysim-0.0.1.dist-info/top_level.txt,sha256=JsBSgxajxod2mlNodBvwkBsn3vMHse0jLqqni2Q5-9Y,21
+tinysim-0.0.1.dist-info/RECORD,,

tinysim-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tinysim-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+tinysim
+tinysim_warp

tinysim_warp/cart_pole/__init__.py

@@ -0,0 +1,259 @@
+# written by: Matthew Taylor
+# source: https://github.com/MatthewAndreTaylor/WarpSimBalance
+
+try:
+    import warp as wp
+    import warp.sim.render
+except ImportError:
+    raise ImportError(
+        "Warp is not installed. Install using `pip install coderbot_sim[warp]`"
+    )
+
+import numpy as np
+
+
+def compute_env_offsets(num_envs, env_offset=(5.0, 0.0, 0.0)):
+    env_offset = np.array(env_offset, dtype=float)
+    axis = np.nonzero(env_offset)[0]
+    axis = axis[0] if len(axis) else 0
+    env_offsets = np.zeros((num_envs, 3))
+    env_offsets[:, axis] = np.arange(num_envs) * env_offset[axis]
+    env_offsets -= env_offsets.mean(axis=0)
+    env_offsets[:, 1] = 0.0
+    return env_offsets
+
+
+class CartPoleExample:
+    def __init__(self, use_cuda_graph=False, headless=False, num_envs=3):
+        self.actions = np.array([0.0, 0.5, -0.5])
+        self.num_envs = num_envs
+
+        fps = 60
+        self.frame_dt = 1.0 / fps
+        self.sim_substeps = 10
+        self.sim_dt = self.frame_dt / self.sim_substeps
+
+        self.initialize()
+
+        self.integrator = wp.sim.SemiImplicitIntegrator()
+        self.renderer = wp.sim.render.SimRendererOpenGL(
+            self.model, "example", headless=headless
+        )
+
+        # CUDA graph
+        self.use_cuda_graph = (
+            use_cuda_graph
+            and wp.get_device().is_cuda
+            and wp.is_mempool_enabled(wp.get_device())
+        )
+        if self.use_cuda_graph:
+            with wp.ScopedCapture() as capture:
+                self.simulate()
+            self.graph = capture.graph
+
+        self.step(actions=[1] * self.num_envs)
+
+    def create_cartpole(self):
+        """Create cartpole system using pure Python/Warp API"""
+        builder = wp.sim.ModelBuilder(gravity=-0.3)
+        pole_size = wp.vec3(0.04, 1.0, 0.06)
+        cart_body = builder.add_body(
+            origin=wp.transform(wp.vec3(0.0, 2.0, 0.0), wp.quat_identity()), m=1.0
+        )
+        builder.add_shape_sphere(body=cart_body, radius=0.1, density=100.0)
+        pole_body = builder.add_body(
+            origin=wp.transform(wp.vec3(0.0, 2.5, 0.0), wp.quat_identity()), m=0.01
+        )
+        builder.add_shape_box(
+            body=pole_body,
+            pos=wp.vec3(0.0, 0.0, 0.0),
+            hx=pole_size[0] / 2.0,
+            hy=pole_size[1] / 2.0,
+            hz=pole_size[2] / 2.0,
+            density=50.0,
+        )
+        builder.add_joint_revolute(
+            parent=cart_body,
+            child=pole_body,
+            axis=wp.vec3(0.0, 0.0, 1.0),  # rotation around Z-axis
+            parent_xform=wp.transform(wp.vec3(0.0, 0.0, 0.0), wp.quat_identity()),
+            child_xform=wp.transform(
+                wp.vec3(0.0, -0.5, 0.0), wp.quat_identity()
+            ),  # joint at pole base
+            limit_ke=1.0e4,
+            limit_kd=1.0e1,
+        )
+        builder.add_joint_prismatic(
+            parent=-1,
+            child=cart_body,
+            axis=wp.vec3(1.0, 0.0, 0.0),
+            parent_xform=wp.transform(wp.vec3(0.0, 2.0, 0.0), wp.quat_identity()),
+            child_xform=wp.transform(wp.vec3(0.0, 0.0, 0.0), wp.quat_identity()),
+            limit_lower=-5.0,
+            limit_upper=5.0,
+            limit_ke=1.0e4,
+            limit_kd=1.0e2,
+        )
+        builder.joint_axis_mode = [wp.sim.JOINT_MODE_FORCE] * len(
+            builder.joint_axis_mode
+        )
+        return builder
+
+    def set_cart_trajectory(self, actions):
+        if len(actions) != self.num_envs:
+            raise ValueError("Length of actions must match number of environments.")
+
+        act = np.zeros(self.model.joint_dof_count, dtype=np.float32)
+        dof_indices = np.arange(self.num_envs) * 2 + 1
+        act[dof_indices] = self.actions[actions]
+        wp.copy(self.model.joint_act, wp.array(act, dtype=wp.float32))
+
+    def is_fallen(self, pole_quat):
+        qw = float(np.clip(pole_quat[3], -1.0, 1.0))
+        tilt = 2.0 * np.arccos(qw)  # radians, in [0, pi]
+        max_tilt = np.deg2rad(90.0)
+        return tilt > max_tilt
+
+    def step(self, actions):
+        """Apply action and step the simulation for one environment timestep.
+
+        Returns (observation, reward, terminated)
+        """
+        self.set_cart_trajectory(actions)
+        if self.use_cuda_graph:
+            wp.capture_launch(self.graph)
+        else:
+            self.simulate()
+
+        self.sim_time += self.frame_dt
+        obs = self.get_state_vector()
+        pole_quat = obs[1:5]
+        terminated = self.is_fallen(pole_quat)
+        return obs, 1.0, terminated
+
+    def simulate(self):
+        for _ in range(self.sim_substeps):
+            self.state.clear_forces()
+            self.state = self.integrator.simulate(
+                self.model, self.state, self.state, self.sim_dt
+            )
+
+    def reset(self):
+        self.initialize()
+        return self.step(actions=[1] * self.num_envs)
+
+    def initialize(self):
+        self.sim_time = 0.0
+        builder = wp.sim.ModelBuilder()
+        offsets = compute_env_offsets(self.num_envs)
+
+        for i in range(self.num_envs):
+            builder.add_builder(
+                self.create_cartpole(),
+                xform=wp.transform(offsets[i], wp.quat_identity()),
+            )
+
+        self.model = builder.finalize()
+        self.model.joint_attach_ke = 1000.0
+        self.model.joint_attach_kd = 1.0
+        self.state = self.model.state()
+
+        wp.sim.eval_fk(
+            self.model, self.model.joint_q, self.model.joint_qd, None, self.state
+        )
+        self.joint_act_np = np.zeros(self.model.joint_dof_count, dtype=np.float32)
+        self.joint_act_wp = wp.array(
+            self.joint_act_np, dtype=float, device=wp.get_device()
+        )
+        self.model.joint_act = self.joint_act_wp
+
+    def render(self):
+        self.renderer.begin_frame(self.sim_time)
+        self.renderer.render(self.state)
+        self.renderer.end_frame()
+
+    def get_state_vector(self):
+        cart_id = 0
+        pole_id = 1
+
+        # convert transforms to numpy
+        body_q = self.state.body_q.numpy()
+        body_qd = self.state.body_qd.numpy()
+
+        # --- Cart ---
+        cart_pos = body_q[cart_id]  # [px, py, pz, qx, qy, qz, qw]
+        # cart_pos = cart_pos[[0, 2]]
+        cart_pos = cart_pos[[0]]
+
+        # --- Pole ---
+        pole_quat = body_q[pole_id][3:]  # quaternion part
+        pole_vel = body_qd[pole_id][3:]  # angular velocity part
+
+        return np.concatenate([cart_pos, pole_quat, pole_vel])
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument(
+        "--device", type=str, default=None, help="Override the default Warp device."
+    )
+    parser.add_argument(
+        "--num-frames", type=int, default=1200, help="Total number of frames."
+    )
+    parser.add_argument(
+        "--manual-control", action="store_true", help="Enable manual control."
+    )
+
+    args = parser.parse_known_args()[0]
+
+    if args.manual_control:
+        print("Manual control enabled")
+        import keyboard
+
+    with wp.ScopedDevice(args.device):
+        example = CartPoleExample(use_cuda_graph=True)
+
+        terminated = False
+        check_terminated = True
+
+        for i in range(args.num_frames):
+            if args.manual_control:
+                # Manual control logic
+                if keyboard.is_pressed("k"):
+                    action = 2
+                elif keyboard.is_pressed("l"):
+                    action = 1
+                else:
+                    action = 0
+
+            else:
+                # Example control signals
+                if i < 200:
+                    action = 0
+                elif i < 255:  # 260
+                    action = 2
+                else:
+                    action = 0
+
+            obs, reward, terminated = example.step(actions=[action] * example.num_envs)
+            # print(f"Step {i}")
+
+            if check_terminated and terminated:
+                print("Pole fallen")
+                check_terminated = False
+
+            example.render()
+
+            # print("State Vector:", obs)
+            # print("Reward:", reward)
+            # print("Terminated:", terminated)
+
+        state = example.reset()
+        print("Reset State Vector:", state)
+        example.render()
+
+        example.renderer.save()

tinysim_warp/quadruped/__init__.py

@@ -0,0 +1,203 @@
+import math
+import os
+
+import numpy as np
+
+try:
+    import warp as wp
+    import warp.examples
+    import warp.sim.render
+except ImportError:
+    raise ImportError(
+        "Warp is not installed. Install using `pip install coderbot_sim[warp]`"
+    )
+
+
+def compute_env_offsets(num_envs, env_offset=(5.0, 0.0, 0.0)):
+    env_offset = np.array(env_offset, dtype=float)
+    axis = np.nonzero(env_offset)[0]
+    axis = axis[0] if len(axis) else 0
+    env_offsets = np.zeros((num_envs, 3))
+    env_offsets[:, axis] = np.arange(num_envs) * env_offset[axis]
+    env_offsets -= env_offsets.mean(axis=0)
+    env_offsets[:, 1] = 0.0
+    return env_offsets
+
+
+class RobotDogExample:
+    def __init__(self, use_cuda_graph=False, headless=False, num_envs=8):
+        articulation_builder = wp.sim.ModelBuilder()
+        rot_x = wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), -math.pi * 0.5)
+        rot_y = wp.quat_from_axis_angle(wp.vec3(0.0, 1.0, 0.0), math.pi * 0.5)
+        xform = wp.transform(wp.vec3(0.0, 0.65, 0.0), rot_y * rot_x)
+        wp.sim.parse_urdf(
+            os.path.join(warp.examples.get_asset_directory(), "quadruped.urdf"),
+            articulation_builder,
+            xform=xform,
+            floating=True,
+            density=900,
+            armature=0.01,
+            stiffness=200,
+            damping=1,
+            contact_ke=1.0e4,
+            contact_kd=1.0e2,
+            contact_kf=1.0e2,
+            contact_mu=1.0,
+            limit_ke=1.0e4,
+            limit_kd=1.0e1,
+        )
+
+        builder = wp.sim.ModelBuilder()
+
+        self.sim_time = 0.0
+        fps = 100
+        self.frame_dt = 1.0 / fps
+
+        self.sim_substeps = 10
+        self.sim_dt = self.frame_dt / self.sim_substeps
+
+        self.num_envs = num_envs
+        offsets = compute_env_offsets(self.num_envs)
+
+        for i in range(self.num_envs):
+            builder.add_builder(
+                articulation_builder, xform=wp.transform(offsets[i], wp.quat_identity())
+            )
+            builder.joint_q[-12:] = [0.2, 0.4, -0.6, -0.2, -0.4, 0.6, -0.2, 0.4, -0.6, 0.2, -0.4, 0.6] # fmt: skip
+            builder.joint_act[-12:] = [0.2, 0.4, -0.6, -0.2, -0.4, 0.6, -0.2, 0.4, -0.6, 0.2, -0.4, 0.6] # fmt: skip
+            builder.joint_axis_mode = [wp.sim.JOINT_MODE_TARGET_POSITION] * len(
+                builder.joint_axis_mode
+            )
+
+        # finalize model
+        self.model = builder.finalize()
+        self.model.ground = True
+        self.model.joint_attach_ke = 16000.0
+        self.model.joint_attach_kd = 200.0
+        self.use_tile_gemm = False
+        self.fuse_cholesky = False
+
+        self.integrator = wp.sim.FeatherstoneIntegrator(
+            self.model,
+            use_tile_gemm=self.use_tile_gemm,
+            fuse_cholesky=self.fuse_cholesky,
+        )
+
+        self.renderer = wp.sim.render.SimRendererOpenGL(
+            self.model, "example", headless=headless
+        )
+        self.state_0 = self.model.state()
+        self.state_1 = self.model.state()
+
+        wp.sim.eval_fk(
+            self.model, self.model.joint_q, self.model.joint_qd, None, self.state_0
+        )
+
+        self.use_cuda_graph = (
+            use_cuda_graph
+            and wp.get_device().is_cuda
+            and wp.is_mempool_enabled(wp.get_device())
+        )
+        if self.use_cuda_graph:
+            with wp.ScopedCapture() as capture:
+                self.simulate()
+            self.graph = capture.graph
+
+    def simulate(self):
+        for _ in range(self.sim_substeps):
+            self.state_0.clear_forces()
+            wp.sim.collide(self.model, self.state_0)
+            self.integrator.simulate(
+                self.model, self.state_0, self.state_1, self.sim_dt
+            )
+            self.state_0, self.state_1 = self.state_1, self.state_0
+
+    def set_leg_poses(self, actions):
+        action_space_size = 12 * self.num_envs
+        if len(actions) != action_space_size:
+            raise ValueError(
+                f"Expected {action_space_size} actions, but got {len(actions)}"
+            )
+
+        wp.copy(self.model.joint_act, wp.array(actions, dtype=wp.float32))
+
+    def step(self, actions):
+        self.set_leg_poses(actions)
+
+        if self.use_cuda_graph:
+            wp.capture_launch(self.graph)
+        else:
+            self.simulate()
+        self.sim_time += self.frame_dt
+
+    def render(self):
+        self.renderer.begin_frame(self.sim_time)
+        self.renderer.render(self.state_0)
+        self.renderer.end_frame()
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument(
+        "--device", type=str, default=None, help="Override the default Warp device."
+    )
+    parser.add_argument(
+        "--num-frames", type=int, default=300, help="Total number of frames."
+    )
+    parser.add_argument(
+        "--num-envs",
+        type=int,
+        default=3,
+        help="Total number of simulated environments.",
+    )
+
+    args = parser.parse_known_args()[0]
+
+    with wp.ScopedDevice(args.device):
+        example = RobotDogExample(num_envs=args.num_envs)
+        # [
+        #     (front right leg out),
+        #     (front right leg forward),
+        #     (front right forearm forward),
+
+        #     (front left leg out),
+        #     (front left leg forward),
+        #     (front left forearm forward),
+
+        #     (back right leg out),
+        #     (back right leg forward),
+        #     (back right forearm forward),
+
+        #     (back left leg out),
+        #     (back left leg forward),
+        #     (back left forearm forward),
+        # ]
+        # left and right directions are reversed
+
+        actions = [0.2, 0.4, -0.6, -0.2, -0.4, 0.6, -0.2, 0.4, -0.6, 0.2, -0.4, 0.6] * args.num_envs # fmt: skip
+
+        for i in range(args.num_frames):
+            example.step(actions)
+            example.render()
+
+            if i % 10 == 0:
+                # Stretch the right leg to the side
+                # actions[0] += 0.1
+
+                # Stretch the right leg forward
+                actions[1] += 0.1
+
+                # Strecth the forearm foward
+                # actions[2] += 0.1
+
+                # Stretch the left leg forward
+                actions[4] -= 0.1
+
+                # Back right leg backwards
+                # actions[7] += 0.1
+
+        example.renderer.save()