Ludemic Building Blocks for General Game Systems

This direction is merged into another direction: ludemic game representation. Its last version stays readable and citable here.

Version 1 of 112 papers21 conceptsfrozen 2026-10-04

Traditional General Game Playing (GGP) systems often rely on low-level logic, such as the Game Description Language (GDL). While mathematically rigorous, GDL is essentially the "assembly language" of games: it is verbose, difficult for humans to read, and computationally expensive for AI to process. A growing body of research suggests a shift toward ludemes—high-level, modular building blocks that represent fundamental concepts of play.

The Problem with Low-Level Logic

In a logic-based system, even a simple rule like "a bishop moves diagonally" must be decomposed into a series of first-order logic clauses. As Eric Piette, Cameron Browne, and colleagues argue in Ludii - The Ludemic General Game System, this lack of abstraction makes it nearly impossible to swap components—like changing a square board to a hexagonal one—without rewriting the entire rule set.

This verbosity creates a "semantic gap." Humans think in terms of "sliding," "jumping," or "capturing," but the machine sees only a web of logical predicates. This makes debugging difficult and prevents AI agents from easily identifying the structural similarities between different games.

Ludemes as High-Level Primitives

The core intuition behind the Ludii system, detailed in Ludii General Game System for Modeling, Analyzing, and Designing Board Games, is to treat games as a composition of ludemes. A ludeme is a high-level primitive that encapsulates a specific behavior or equipment type, such as a "tiling," "dice," or a "step" move.

By using these predefined units, researchers can describe complex games with significantly less code. This succinctness provides three primary advantages:

  1. Human Readability: Designers can author games using concepts they already understand.
  2. Computational Efficiency: Because the system understands the "meaning" of a ludeme (e.g., a sliding move), it can use optimized code to execute that move rather than evaluating thousands of logical clauses.
  3. Modularity: Rules become "plug-and-play." You can take the movement rules from one game and apply them to the board of another with minimal friction.

From Atoms to Evolution

This modular approach allows researchers to treat game design as a search through a "game space." In Pitako - Recommending Game Design Elements in Cicero, Tiago Machado and Julian Togelius demonstrate how decomposing games into discrete "atoms" of behavior allows AI to recommend new mechanics to designers, acting as a creative partner.

Similarly, Swen E. Gaudl and Michael Cook 0001 explore "Fluidic Games" in Exploring Novel Game Spaces with Fluidic Games, where players can navigate a subspace of game mechanics by tuning high-level facets like physics and scoring rules. This turns the act of playing into an act of design.

Applications in AI and Archaeology

The benefits of ludemic representation extend beyond design. In The 2022 Ludii AI competition, Dennis J. N. J. Soemers and others showed that high-level abstractions allow AI agents to generalize across thousands of distinct environments. Because the agents interact with standardized components—similar to the graph-based boards and decks used in the TAG framework by Raluca D. Gaina et al. in Design and Implementation of TAG: A Tabletop Games Framework—they can apply learned strategies to new, unseen games.

Furthermore, this modularity is essential for Digital Archæoludology. As outlined in Foundations of Digital Archæoludology, researchers use these high-level building blocks to reconstruct historical games from incomplete data. By testing thousands of rule variations through rapid AI self-play, they can identify which configurations are most plausible, effectively "filling in the blanks" of human history through the language of ludemes.

Finally, because these descriptions are high-level and structured, they can even be translated back into human language. Eric Piette and Matthew Stephenson demonstrate in Automatic Generation of Board Game Manuals that a ludemic system can automatically generate coherent, readable rulebooks, bridging the gap between machine-readable code and human-understandable play.

Papers in this version

History & citationVersion 1 · 2026-10-04

Merged into another direction · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_ludemic_building_blocks_for_general_game_02d28d8e,
  title = {Ludemic Building Blocks for General Game Systems},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/ludemic-building-blocks-for-general-game-systems/rdr_02d28d8eea0741dfae268e9247739fb7},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_ludemic_building_blocks_for_general_game_02d28d8e_v1,
  title = {Ludemic Building Blocks for General Game Systems},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/ludemic-building-blocks-for-general-game-systems/rdr_02d28d8eea0741dfae268e9247739fb7/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}