Generative dynamics on manifold.
For robotics: Planning. Control. Learning.

Website · Documentation · Get started · Examples · Learning · Environments · Constraints · Architecture · Roadmap

Full-quality video · Demonstrations and sources · Run the examples

GenerativeDynamics connects generative models, manifold geometry, and robot learning in one modular robotics stack. Learn reusable priors, shape generative trajectory updates with dynamics and constraints, and connect plans to closed-loop control. Shared task, solver and execution interfaces let you swap algorithms, compose controllers and add robots. Use components directly in Python or run complete experiments from a configuration.

• 2026-10-09 — Added GPU and Docker quickstarts, a batched constraint example, and explicit device checks.
• 2026-10-09 — Added a direct Python planning example, a unified paper and hardware gallery, learning workflows, and planner, environment and constraint catalogues.
• 2026-10-05 — Prepared the V1 release candidate with six task families, optional integrations, user documentation and CPU validation evidence.

Follow CHANGELOG.md for new environments, planners and integrations.

See device and integration support for the qualified paths, and architecture for the interfaces behind these features.

Create a planar environment, give it a 2GO planner, and move from (0.8, 0.8) to the origin. This example runs on CPU without a simulator or model checkpoint.

git clone https://github.com/hhhhzl/genedynamics.git
cd genedynamics
python -m venv .venv
source .venv/bin/activate
python -m pip install -e ".[optimization]"

import jax
import numpy as np

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

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,
)

state = np.array([0.8, 0.8], dtype=np.float32)
for step in range(60):
    key = jax.random.fold_in(jax.random.PRNGKey(0), step)
    plan = planner.solve(state, horizon=20, rng_key=key)
    state = env.transition(state, plan.actions[0])
    if np.linalg.norm(state) < 0.1:
        break

print(f"Goal error: {np.linalg.norm(state):.3f}")

The CPU validation reaches the goal in 48 steps, with Goal error: 0.099. Run the complete example with python examples/plan_to_goal.py, or follow the Python API walkthrough to adapt it.

On Linux with an NVIDIA GPU, install the CUDA stack and increase the candidate batch without changing the application loop:

python -m pip install -e ".[optimization]" \
  -r requirements/gpu-jax.txt "jax[cuda12]==0.6.2"
JAX_PLATFORMS=cuda python examples/plan_to_goal.py --device gpu --samples 1024
JAX_PLATFORMS=cuda python examples/batched_constraints.py --device gpu --samples 4096

The examples check array placement and fail when the requested GPU is unavailable. The GPU recipes cover MDOC, MD-COAS, 2GO and batched constraints. MGA CUDA qualification is deferred.

With the existing development images, mount the checkout and run the same loop:

docker run --rm -v "$PWD:/workspace" -w /workspace \
  genedynamics/dev-cpu:local python examples/plan_to_goal.py --device cpu

docker run --rm --gpus all -v "$PWD:/workspace" -w /workspace \
  -e JAX_PLATFORMS=cuda genedynamics/train-gpu:local \
  python examples/plan_to_goal.py --device gpu --samples 1024

The NVIDIA container requires Linux and the NVIDIA Container Toolkit. Results remain in the mounted checkout. See the Docker guide for prerequisites, batch examples and headless simulation.

For configured experiments, the first-run guide covers result artifacts and resuming runs. The installation guide covers CUDA, simulator assets, learned planners and deployment extras.

Start with one of our four methods. Each recipe connects an algorithm to a task, its dependencies and an inspectable configuration.

The recipe catalogue explains setup and assets. The homepage also includes original paper demonstrations: MDOC multi-robot coordination is available in its original project, and MGA humanoid contact footage previews research beyond the qualified V1 recipes. See the demo map for the distinction.

Generative models are part of the architecture: learn a trajectory distribution, reuse a policy as a control-sequence prior, or perform model-based generative inference directly from dynamics and objectives.

Learning dependencies and checkpoint setup are documented in the learning guide.

Six task families share the planning and evaluation stack. Each links to a ready-to-inspect configuration.

The environment catalogue lists configuration keys, interfaces, assets and implementation links. MuJoCo, MJX and Brax are simulation adapters; support depends on the selected recipe.

🟢 Ours marks our algorithms. Each entry links its original paper or current implementation; configuration variants are documented in the planner reference.

Naming: CFS-MBD is the historical implementation name for MD-COAS. Learned integrations require their optional dependencies and checkpoints. See planner setup and implementation notes.

Compose CBF action filters, CFS trajectory projections and adaptive augmented-Lagrangian scheduling with a numerical solver below.

Install .[optimization] for the optional QP dependencies. See the constraint reference for CBF/CFS variants, scheduling and solver-specific limits.

A planning call maintains a batch of candidate trajectories. Constraints participate in the sampling loop: they correct candidates, change feasibility weights, or shape the geometry of the next generative update.

MDOC/MD-COAS compose CBF/CFS corrections; 2GO budgets projection probes; MGA evaluates learned horizon proposals alongside model-based candidates. SafeDiffuser uses batched Torch QPs during denoising; DPCC combines Torch sampling with CPU trajectory projections. Numerical paths are documented per integration.

See batched constraints and generative samples for tensor shapes, each planner's data flow and a runnable JAX batch example.

Define a robot task, then compose planner plugins, constraints and geometry, and learned models or priors. Run through the experiment framework or direct Python API. Environment adapters connect to simulation; explicit trajectory adapters connect selected plans to the separate deployment stack.

Observers, metrics and replay span the workflow. Saved trajectories and outcomes support offline policy training, diffusion-model training and reliability calibration. Each workflow selects the components it needs; model-based planners can also run without learned checkpoints.

Read the architecture guide, configure a task, or add a plugin.

• Policy learning, learned diffusion and reusable priors
• JAX planning and composable constraints
• Six task families and planner baselines
• Configured experiments, metrics and replay
• MGA CUDA qualification and humanoid walking/push
• Torch planner parity; Rust/C++ control and I/O
• Panda/xArm7 controllers and ros2_control
• Async planning/control and fault recovery
• VLA proposals and OpenPI/LeRobot adapters
• Live perception and dynamic scenes
• Reproducible hardware benchmarks

Roadmap details · Current compatibility · Validation evidence

Bring a planner, a robot task, an integration or a documentation improvement. Start with CONTRIBUTING.md. Community guidelines are in CODE_OF_CONDUCT.md; vulnerability reporting is in SECURITY.md.

The solvers build on research algorithms; the framework provides the interfaces and runtime around them. Use CITATION.cff when citing the project, and the papers linked above when using individual methods.

GenerativeDynamics is released under the MIT License. Bundled third-party components retain their own licenses; see third-party notices.