pydgens 1.0.0

Python/JAX-based numerical solvers for dynamic/differential game equilibria

PYDGENS: Python/JAX Differential Game Equilibria Numerical Solvers

Documentation · Examples · API · Solvers · GitHub

PYDGENS provides numerical solvers for approximating equilibrium solutions in multi-player, general-sum dynamic and differential games. The package currently focuses on linear-quadratic feedback Nash games, iterative linear-quadratic methods for nonlinear games, and augmented-Lagrangian workflows for constrained games.

	Multi-car intersection Naive collisions compared to an iLQ feedback solution. Source · Docs
	Satellite Lady-Bandit-Guard One LQ feedback Nash strategy rolled out from many initial states. Source · Docs · spacegym-kspdg

Installation

pip install pydgens

PYDGENS requires Python 3.12 or newer.

Solvers

PYDGENS currently supports three main solver paths. See the solver notes for a sparse theory map and references.

Solver	Use case	Equilibrium style
LQ	Linear dynamics with quadratic costs	feedback Nash
iLQ	Nonlinear unconstrained games	local feedback Nash
AL	Constrained nonlinear games	local open-loop Nash (pre-release, beta)

Usage Example

Define and solve for the local Nash equilibrium of a nonlinear game by combining a time grid, dynamics, player costs, and player-owned control slices:

import jax.numpy as jnp
import pydgens as pdg

x0 = jnp.array([4.0, 4.0, 0.0, 0.0])  # px, py, heading, speed

game = pdg.game(
    tg=pdg.time_grid(nt=34, dt=0.1),
    dynamics=pdg.nonlinear_dynamics(
        nx=4,
        nu=2,
        dynamics=lambda t, x, u: jnp.array([
            x[3] * jnp.cos(x[2]),
            x[3] * jnp.sin(x[2]),
            u[0],
            u[1],
        ]),
    ),
    players=[
        pdg.player(
            name="turn",
            joint_ctrl_slice=slice(0, 1),
            cost=pdg.player_cost(
                running=lambda t, x, u: x[0] ** 2 + x[1] ** 2 + u[0] ** 2,
            ),
        ),
        pdg.player(
            name="speed",
            joint_ctrl_slice=slice(1, 2),
            cost=pdg.player_cost(
                running=lambda t, x, u: (x[3] - 1.0) ** 2 + u[1] ** 2,
            ),
        ),
    ],
)

solution = pdg.solve(game, x0=x0, method="ilq")
print(solution)

Further examples of solving for equilibria in differential games can be run directly with:

python -m pydgens.examples.tug_o_war  # minimal linear-quadratic (LQ) game
python -m pydgens.examples.unicycle   # nonlinear game solved with iterative method
python -m pydgens.examples.constrained_integrators  # constrained game solved Lagrangian method

A comprehensive list of examples is included in the examples documentation.

Disclaimer

DISTRIBUTION STATEMENT A. Approved for public release. Distribution is unlimited.

This material is based upon work supported by the Under Secretary of War for Research and Engineering under Air Force Contract No. FA8702-15-D-0001 or FA8702-25-D-B002. Any opinions, findings, conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the Under Secretary of War for Research and Engineering.

© 2026 Massachusetts Institute of Technology.

Subject to FAR52.227-11 Patent Rights - Ownership by the contractor (May 2014)

SPDX-License-Identifier: MIT

The software/firmware is provided to you on an As-Is basis.

Delivered to the U.S. Government with Unlimited Rights, as defined in DFARS Part 252.227-7013 or 7014 (Feb 2014). Notwithstanding any copyright notice, U.S. Government rights in this work are defined by DFARS 252.227-7013 or DFARS 252.227-7014 as detailed above. Use of this work other than as specifically authorized by the U.S. Government may violate any copyrights that exist in this work.