Skip to content

EdenEden

Embodied-AI Development Environments Nexus

A robot-learning framework built on Genesis: write a task as one typed config, train it across thousands of GPU-parallel environments, then run the same policy on a real robot.

Get started View on GitHub

Eden teaser: a G1 skateboarding, a G1 filling a cup at a tap, two hands playing piano, sixteen hands reorienting cubes, G1 squads crossing terrains, a Franka writing EDEN on a whiteboard, fin-ray fingers grasping an apple, a UR5e inserting a peg, a lineup of robots, a LimX Oli with two Wuji hands moving a chair, a batched splat render and a lineup of dexterous hands

What Eden gives you

A task is one typed config

Scene, observations, actions, rewards, terminations, events, curricula and the learning runner live in one Pydantic object. It validates when you construct it, saves to JSON or YAML, and turns its variants into CLI flags.

Composable terms

Observations, rewards, terminations, commands, events and curricula are small registered terms. A plain function with a decorator becomes a new one, and eden terms --grep <text> finds an existing one with its parameters.

Robots and objects

Humanoids, quadrupeds, arms and dexterous hands come as ready-made robot options, and composite rigs bolt a hand onto an arm. Robot and object assets download on first use.

Physics and sensing

The Genesis solvers (rigid, PBD, MPM, SPH, FEM) are set through EnvOptions, plus Mochi, an implicit solver that couples rigid, soft, cloth and rod bodies. Cameras render through a rasterizer, a batch renderer or the Nyx path tracer, next to depth, lidar, tactile, IMU, contact and audio sensors.

Motion and demonstration data

Load human-motion datasets, retarget them to robots, estimate motion from video, teleoperate with GELLO, Meta Quest, PICO or the Wuji Glove, and record or script demonstrations into HDF5 and LeRobot datasets.

Train, export, deploy

Train with rsl_rl (the default), rl_games, skrl or Stable-Baselines3, on one GPU or many. Export a policy to ONNX or TorchScript, check it against MuJoCo with eden deploy --mujoco, then run it on hardware with eden deploy.

From install to a trained policy

pip install eden-world                  # or, in a clone of the repository: uv sync
eden list                               # every registered task and its variant flags
eden train --task reacher               # train a Yam arm to reach sampled targets
eden inference --task reacher --checkpoint <path/to/model.pt> --vis
eden inference --policy homie --vis     # roll out a published policy, no training needed

Installation covers platforms and optional extras, and the Quick start walks through these commands and where their output goes.

A task is one config

The reacher task, abridged from eden/tasks/benchmark/reacher/config.py, the template every built-in task follows:

@TASK_REGISTRY.register(modifiers=(ReacherDifficultyMod,))  # adds `eden train --task reacher --difficulty hard`
class ReacherConfig(EdenRLConfig):
    env_options: EnvOptions = EnvOptions(num_envs=4096, episode_length_s=9.0, sim_dt=0.01, sim_substeps=2, ...)
    scene_options: SceneOptions = en.scenes.Empty(robot=en.robots.Yam())
    observation_options: ObservationManagerOptions = ObservationManagerOptions(
        policy=ObservationGroupOptions(
            dofs_pos=observations.DofsPos.configure(entity_name="robot"),
            dofs_vel=observations.DofsVel.configure(entity_name="robot"),
            ...
        ),
    )
    action_options: ActionManagerOptions = ActionManagerOptions(
        joint_pos_controller=actions.ImplicitPDController.configure(
            entity_name="robot", dofs_name="joint*", scale=0.05, reference_source=ReferenceSource.DELTA,
        ),
    )
    command_options: CommandManagerOptions = CommandManagerOptions(
        reaching_target=UniformT3Command.configure(x_range=(0.3, 0.5), y_range=(-0.1, 0.1), z_range=(0.25, 0.35)),
    )
    reward_options: RewardManagerOptions = RewardManagerOptions(
        reaching_task=RewardTerm.configure(func=reaching_reward, weight=1.0, params={...}),
        action_rate=RewardTerm.configure(func=rewards.action_rate_l2, weight=-0.01),
    )
    termination_options: TerminationManagerOptions = TerminationManagerOptions(
        timeout=DoneTerm.configure(func=terminations.time_out, time_out=True),
    )
    runner_options: RslRlOnPolicyRunnerOptions = RslRlOnPolicyRunnerOptions(...)

Key concepts explains each piece, and Your first task builds one from scratch.

A Go2 with LiDAR in a scanned tunnel

Sensors: a Go2 with LiDAR in a scanned tunnel.

Two hands playing piano

Multi-modality: playing piano, with sound synthesised from the pressed keys.

A G1 filling a glass at a kitchen tap

Beyond rigid bodies: a G1 fills a glass with water at a kitchen tap.

Sixteen environments rendered with a batched Gaussian-splat background

Batch rendering: batched Gaussian-splat backgrounds behind a heterogeneous simulation.

A lineup of humanoids, quadrupeds, a wheeled quadruped and arms

Embodiments: built-in robots, composite rigs and object sets.

Published controllers running in Eden

Policy zoo: published controllers run as shipped with eden inference --policy <name>.

Motion datasets replayed on robots

Motion datasets: loaders that share one motion format.

Human motion retargeted to robots with SOMA

Cross-embodiment retargeting with eden retarget.

Human-object demonstrations retargeted with the object onto robots and hands

Human-object retargeting: the object comes along, onto a rig or a hand.

Massively parallel training of a G1

Train at scale: eden train --task <task> --num_envs 4096, across GPUs with DDP.

Three policies in MuJoCo sim-to-sim

Sim-to-sim: eden deploy --task <task> --checkpoint model.pt --mujoco.

The same three policies on the real robots

Sim-to-real: eden deploy --task <task> --checkpoint model.pt.

A humanoid cartwheel tracked from motion capture

Motion tracking with the native motion manager.

A G1 with Inspire hands and an Oli with Wuji hands moving objects

Human-object interaction: humanoids with dexterous hands move objects.

A caregiver humanoid helping another sit up in bed

Multi-agent RL: two agents with their own observations, actions and rewards.

A trained policy wiping a bar with a foam sponge

Soft-body manipulation: a trained policy wipes a bar with a foam sponge.

Two arms folding a towel

Cloth manipulation: two arms fold a towel in half.

A cable routed around two spools into a port

Cable routing: a cable routed around two spools into a port.

Calligraphy with a modeled brush

Calligraphy with a modeled Chinese brush.

A wet-acrylic painting of The Starry Night

Wet-acrylic painting, with the wet paint blending.

Scenes from ported benchmark suites

Benchmark suites: LIBERO, robosuite, SIMPLER, PolaRiS and more, reimplemented.

Where to go next

Get started

Install Eden, train and watch a policy, and learn the handful of ideas every task is built from.

Task suites

The registered tasks by family, and how to list, train and evaluate them.

Building tasks

Task configs, variants, terms, entities and environments, in depth.

Training and deployment

Training runs and checkpoints, other RL libraries, multi-GPU training, the policy zoo, export and deployment.

Examples

Runnable projects, policy demos and single-capability recipes, browsable with eden examples list.

Reference

Every eden command and its flags, the environment variables Eden reads, and the API reference.

Acknowledgments

Eden builds on these open-source projects:

Citation

If you use Eden in your research, please cite:

@misc{Eden,
  author = {Eden Authors},
  title = {Eden: One Task Definition from Simulation to Real Robots},
  month = {November},
  year = {2026},
  url = {https://github.com/embodied-ai-nexus/Eden}
}

Eden is released under the Apache 2.0 License.