README.md

metadata

license: cc-by-nc-4.0
pretty_name: Jaipur - Online Card Game Replays
task_categories:
  - reinforcement-learning
tags:
  - board-games
  - card-games
  - jaipur
  - game-ai
  - imperfect-information
  - two-player
language:
  - en
size_categories:
  - 10K<n<100K
configs:
  - config_name: default
    data_files:
      - split: train
        path: data/games.parquet
  - config_name: players
    data_files:
      - split: train
        path: data/players.parquet
dataset_info:
  - config_name: default
    features:
      - name: game_id
        dtype: string
      - name: variant
        dtype: string
      - name: player_0
        dtype: string
      - name: player_1
        dtype: string
      - name: winner
        dtype: int8
      - name: num_rounds
        dtype: int8
      - name: num_turns
        dtype: int16
      - name: round_scores
        sequence:
          sequence: int16
      - name: turns
        list:
          - name: round
            dtype: int8
          - name: actor
            dtype: int8
          - name: action_type
            dtype: string
          - name: action_goods
            sequence: int8
          - name: market
            sequence: int8
          - name: deck_size
            dtype: int8
          - name: actor_hand
            sequence: int8
          - name: opponent_hand
            sequence: int8
          - name: coin_stacks
            sequence:
              sequence: int8
          - name: bonus_stacks
            sequence:
              sequence: int8
          - name: actor_coins
            sequence:
              sequence: int8
          - name: actor_bonuses
            sequence: int8
          - name: actor_score
            dtype: int16
          - name: opponent_score
            dtype: int16
    splits:
      - name: train
        num_examples: 38077
  - config_name: players
    features:
      - name: player_id
        dtype: string
      - name: num_games
        dtype: int32
      - name: num_wins
        dtype: int32
      - name: win_rate
        dtype: float32
      - name: num_games_as_p0
        dtype: int32
      - name: num_games_open_info
        dtype: int32
      - name: num_games_original
        dtype: int32
    splits:
      - name: train
        num_examples: 4264

Jaipur: Online Card Game Replays

A dataset of 38,000+ complete Jaipur card game replays from human players on Yucata.de.

Jaipur is a two-player trading card game where players compete as merchants, buying and selling goods to earn the most money. It features imperfect information (hidden deck and opponent hand), delayed rewards, and strategic tension between short-term gains and long-term planning.

Why This Dataset?

Jaipur is an excellent benchmark for game AI research:

• Imperfect information: Players cannot see the deck or (in the original variant) the opponent's hand, requiring belief tracking and risk assessment
• Mixed strategy space: Actions include taking goods, selling sets, and multi-card trades
• Compact but deep: Games are short (~20-40 turns) but strategically rich
• Two variants included: Open information (both hands visible) and original rules (hidden hands), enabling research on how information availability affects strategy

Dataset Structure

Games (data/games.parquet)

Each row is one complete game. The turns column contains the full sequence of game states and actions.

Column	Type	Description
game_id	string	Unique anonymized game identifier
variant	string	"open_info" or "original" (whether hands are visible)
player_0	string	Anonymized player ID (consistent across games)
player_1	string	Anonymized player ID
winner	int8	0 = player_0 won, 1 = player_1 won, -1 = unknown
num_rounds	int8	Number of rounds played (1-3, best of 3)
num_turns	int16	Total turns across all rounds
round_scores	list[list[int16]]	Per-round scores [[p0_r1, p1_r1], [p0_r2, p1_r2], ...]
turns	list[struct]	Ordered list of turn records (see below)

Turn Schema

Each element in the turns list is a struct with the state before the action and the action taken:

Field	Type	Description
round	int8	Round index (0-based)
actor	int8	Which player acted (0 or 1)
action_type	string	"take", "sell", or "trade"
action_goods	list[int8]	Signed goods delta for actor: [D, G, S, Cl, Sp, L, Ca]. Positive = gained, negative = given away
market	list[int8]	Market goods count: [D, G, S, Cl, Sp, L, Ca]
deck_size	int8	Cards remaining in draw pile
actor_hand	list[int8]	Actor's hand: [D, G, S, Cl, Sp, L, Ca]
opponent_hand	list[int8]	Opponent's hand (always present in data, even for original variant)
coin_stacks	list[list[int8]]	Remaining coin values per good [[D coins], [G], [S], [Cl], [Sp], [L]], ordered highest-first
bonus_stacks	list[list[int8]]	Remaining bonus token values [[3-set], [4-set], [5-set]]
actor_coins	list[list[int8]]	Coins actor has earned per good [[D coins], ..., [L coins]]
actor_bonuses	list[int8]	Bonus token values actor has earned
actor_score	int16	Actor's current score (goods + bonus coins)
opponent_score	int16	Opponent's current score

Goods order: Diamond (D), Gold (G), Silver (S), Cloth (Cl), Spice (Sp), Leather (L), Camel (Ca) — 7 types. Coin stacks cover the 6 tradeable types (no camel coins).

Players (data/players.parquet)

Aggregated statistics for each unique player across all games.

Column	Type	Description
player_id	string	Anonymized player ID (matches player_0/player_1 in games)
num_games	int32	Total games played
num_wins	int32	Total wins
win_rate	float32	Win rate (wins / games with known outcome)
num_games_as_p0	int32	Games played as player 0 (first mover)
num_games_open_info	int32	Games played in open info variant
num_games_original	int32	Games played in original variant

Quick Start

from datasets import load_dataset

# Load all games
ds = load_dataset("noidvan/jaipur")
game = ds["train"][0]

print(f"Variant: {game['variant']}")
print(f"Winner: player_{game['winner']}")
print(f"Turns: {game['num_turns']}")

# Iterate through turns
for turn in game["turns"]:
    print(f"  Round {turn['round']}, Player {turn['actor']}: {turn['action_type']}")
    print(f"    Market: {turn['market']}, Deck: {turn['deck_size']}")

# Load player stats
players = load_dataset("noidvan/jaipur", "players")

Game Rules Summary

• Setup: 5 cards in market (3 camels + 2 goods initially), each player gets 5 cards
• Turn actions:
  • Take: Pick one good from market (deck refills) or take all camels
  • Sell: Sell 1+ cards of same type for coins (premium goods require selling 2+)
  • Trade: Swap 2+ cards with market (can offer camels)
• Coins: Each good type has a coin stack with decreasing values (sell early = more coins)
• Bonuses: Selling 3/4/5+ cards earns a random bonus token
• Round end: 3 coin stacks empty OR deck exhausted. Most coins wins the round.
• Game end: Best of 3 rounds (first to 2 "seals")

Variants

Variant	Games	Description
open_info	~33,000	Both players can see each other's hands
original	~5,500	Standard rules — opponent's hand is hidden

The opponent_hand field is populated for all games regardless of variant (the server records full state). The variant field indicates what information was available to players during play, which affects their strategy.

Source & License

• Source: Game replays from Yucata.de, an online board game platform
• License: CC-BY-NC-4.0
• Privacy: All player identities are anonymized with irreversible hashing. Original usernames are not recoverable from the dataset. The player ID "unknown" represents unknown users (~1,400 games); They are excluded from the players table.

Citation

@dataset{jaipur_replays_2026,
  title={Jaipur: Online Card Game Replays},
  author={Yifan Lin},
  year={2026},
  url={https://huggingface.co/datasets/noidvan/jaipur},
  license={CC-BY-NC-4.0}
}