GenerativeDynamics
A modular robotics framework

Generative
dynamics
on manifold.

Connect generative models, manifold geometry, and robot learning. Turn structured proposals into motion that responds to constraints and contact.

PYTHON 3.10–3.12JAX-FIRST0.1.0 ALPHA
SIMULATION + REAL ROBOTS
Adaptive contactMGA · Simulation
G1 · AR obstacles2GO · Real robot · 1×
Feasible footholds2GO · Simulation · 1×
Corridor navigation2GO · Simulation · 1×
Compliant contactMGA · Real robot · 1×
Contact-rich insertionMGA · Real robot · 1×
Humanoid pushingMGA · Simulation · 1×
Force regulationMGA · Simulation · 1×
Contact unjammingMGA · Simulation · 1×
Planning.Control.Learning.
Shared tasks. Composable constraints. Interchangeable algorithms.
The framework in motion

One stack.
Many ways to move.

From coordinating robots to maintaining contact, explore original demonstrations from the research behind the framework.

A connected research trajectory

What should guide
generation?

Dynamics, constraints, geometry, and contact feedback. Each work opens the next question in making generated behavior useful for robots.

Can we generate dynamically feasible, collision-free motion without demonstration training, and use that planner to coordinate a team of robots?

A useful motion plan must obey the robot's dynamics and avoid collisions, even when many robots share the same space. MDOC brings these requirements inside model-based diffusion: candidate controls are corrected during rollout, and known dynamics turn them into executable state trajectories. The planner estimates its denoising direction from evaluated rollouts without learning from demonstrations. MDOC-CBS then uses the same low-level mechanism to resolve conflicts between robots.

Dynamics rolloutsCBF projectionMulti-robot coordination
Explore MDOC

Connected ideas, distinct problem settings. Each method has its own scope, evidence, and trade-offs.

Built to compose

A framework for
the next idea.

Swap the algorithm, keep the task.

Compare generative planners and control methods through shared environments, configurations, and evaluation protocols.

Learn priors. Refine with models.

Reuse policy checkpoints or learned trajectory distributions, then guide candidates with dynamics, geometry, and constraints.

Bring your own components.

Add planners, robot tasks, constraints, metrics, and visualizations through explicit interfaces and registries.

Define the task

Dynamics · Objectives · Geometry

Robot models, task costs, collision geometry, and physical constraints.

Generate & refine

Planners · Priors · Constraint solvers

Interchangeable algorithms, learned proposals, and geometry-aware updates.

Connect to execution

Controllers · Governors · Observers

Replanning, feedback, safety components, and inspectable results.

Start with one trajectory

Your task.
Your planner.
Your Python.

Create a planar task and use 2GO directly. The CPU example needs no robot simulator or pretrained checkpoint.

Install the package and optimization extras first. Repository access is required while the release is being prepared.

plan_to_goal.py · Python API
import jax
import numpy as np

from genedynamics.envs import make_env, make_energy
from genedynamics.solvers import TwoGOSolver
from genedynamics.core.backends.runtime import (
    RuntimeBackendManager,
)

RuntimeBackendManager.set_backend("jax", device="cpu")
env = make_env("single_integrator_box_2d")
planner = TwoGOSolver(
    dynamics=env,
    energy=make_energy("single_integrator_box_2d"),
    backend=RuntimeBackendManager.get_backend(),
    dt=env.dt, horizon=20, Nsample=128, Ndiffuse=16,
)
plan = planner.solve(
    np.array([0.8, 0.8], dtype=np.float32),
    horizon=20, rng_key=jax.random.PRNGKey(0),
)
next_state = env.transition(
    np.array([0.8, 0.8], dtype=np.float32),
    plan.actions[0],
)
Plan → execute the first action → replan
Research behind the framework

A growing body of work.

Each method contributes a different piece of the planning and control stack. Read the ideas, inspect the evidence, and find the corresponding recipe.

Build on the ideas.

Start with a CPU example, then explore constraints, learning, and robot tasks.

Open the documentation