Skip to main content

Game theory framework, algorithms and game implementations

Project description

Game Gym

MIT Licence Build Status PyPI version codecov Coverage Status

A game theory framework providing a collection of games, common API and a several game-theoretic algorithms.

The goal of the project is to provide tools for buildng complex games (e.g. board games, with partial information or simultaneous moves), computation of approximate strateges and creating artificial intelligence for such games, and to be a base for robust value learning experiments.

Under active development, looking for ideas and contributors!



  • Outcome sampling MCCFR Nash equilibrium computation
  • Exact best response and exploitability
  • Approximate best response and exploitablity
  • Sparse SGD value learning (with values linear in known features)
  • Plotting strategy development (see plots for Matching Pennies, Rock-Paper-Scissors, Goofspiel(4))


  • General matrix games (normal form games), Rock-paper-scissors, Matching pennies, Prisoner's dilemma, ...
  • Goofspiel (GOPS)
  • One-card poker, Dice-poker

Game interface

For an exploration of API in Rust, see GTCogs.

To implement game you define one class derived from gamegym.Game with the following interface:

class MyRockPaperScissor(PartialInformationGame):
    ACTIONS = ("rock", "paper", "scissors")
    def __init__(self):
        # Set thenumber of players and all game actions
        super().__init__(2, self.ACTIONS)

    def initial_state(self) -> StateInfo:
        # Return node information, here player 0 is active and has all actions.
        # Note that in this simple game we do not use any game state.
        return StateInfo.new_player(state=None, player=0, actions=self.ACTIONS)

    def update_state(self, situation: Situation, action) -> StateInfo:
        # Return the node information after playing `action` in `situation`.
        if len(situation.history) == 0:
            return StateInfo.new_player(state=None, player=1, actions=self.ACTIONS)
        p1payoff = 1.0 # TODO: compute from `situation`, e.g. from `situation.history`
        return StateInfo.new_terminal(state=None, payoff=(x, -x))

# Create game instance
game = MyRockPaperScissor()
# Initial situation
s1 = game.start()
# Play some actions
s2 =, "rock")
s3 ="paper") # alias for, "paper")
# See game result
assert s3.is_terminal()
assert s3.payoff == (-1.0, 1.0)

The available base classes are PerfectInformationGame and PartialInformationGame (with specialised subclasses ObservationSequenceGame, SimultaneousGame and MatrixGame - which would be a better fit for Rock-Paper-Scissors).

The main auxiliary structs common to all games are StateInfo that contains the information about the game node itself, and Situation which additionally contains game history, accumulated payoffs, the game itself etc.

Game state is any structure the game uses to keep track of the actual game state, e.g. cards in all hands, game board state, map, ... This is not generally visible to players in partial information game, any observations are passed with observations=(p0_obs, p1_obs, public_obs) to StateInfo.

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

gamegym-0.2.0.tar.gz (29.4 kB view hashes)

Uploaded source

Built Distribution

gamegym-0.2.0-py3-none-any.whl (38.2 kB view hashes)

Uploaded py3

Supported by

AWS AWS Cloud computing Datadog Datadog Monitoring Facebook / Instagram Facebook / Instagram PSF Sponsor Fastly Fastly CDN Google Google Object Storage and Download Analytics Huawei Huawei PSF Sponsor Microsoft Microsoft PSF Sponsor NVIDIA NVIDIA PSF Sponsor Pingdom Pingdom Monitoring Salesforce Salesforce PSF Sponsor Sentry Sentry Error logging StatusPage StatusPage Status page