11/3/2026 - Argumentum: from card game to reproducible repositoryNews | Argumentum
Skip to main content
Home  › ... News

Argumentum: from card game to reproducible repository

11/3/2026 Evolution
Argumentum: from card game to reproducible repository

In April 2024, Argumentum was a card game ready to print. Today it is also a public repository in which every card is rebuilt from text files, in eight languages, with its mind maps and its ontology.

Illustration: docs/publication/articles/illustrations/1a-du-texte-a-la-carte.png, Argumentum repository, commit 981e5233 — a composite of a real excerpt of the taxonomy (nineteen lines, header included) and the real rendering of the “Sloppy Argument” card, with row 2,1.1 visible in the excerpt — the journey told in the section “How a card is born”.

The game

Argumentum is a card game about fallacies, those arguments that seem valid without being so. Each card describes a fallacy and gives its definition and an example. You learn to recognize it, then to counter it with an argument that holds up.

The game is played with three decks. The first gathers the large cards: the fallacies, the rules and a memo card. The second gathers the small cards: the scenarios, in which you have to recognize which fallacy is hiding in a given situation. The third, separate one describes the virtues of argumentation: the arguments that hold up.

A reference point, then a rebuild

The repository has existed since March 20, 2020.

One version remained the reference for a long time: commit 0087f0ec, from April 25, 2024. It was the one that produced the complete game. Between 2025 and 2026, the production pipeline was restored piece by piece, and above all equipped with tooling: each step now has its own check, and a change that would break a card no longer goes unnoticed.

How a card is born

Four steps, all starting from text files.

The data. One CSV file per family: the taxonomy of fallacies, the one for virtues, the scenarios, the rules. One row per item, and one column per language. It is the only place where the text of a card exists.

The template. A JSON file that contains the HTML and CSS of a card, with blanks to fill in. The rendering engine, CardPen, fills these blanks with the CSV data. The blanks are written between double curly braces: this is the syntax of Handlebars templates, a system that replaces labels with values.

The image. A remote-controlled browser opens the filled-in template and captures the card as a PNG image, at print resolution.

The document. A library, QuestPDF, assembles the pages: front and back, cutting marks, and, for the print-at-home version, several cards per A4 sheet.

What has been added

Eight languages. French, English, Russian, Portuguese, Spanish, Arabic, Persian and Chinese. Two of them, Arabic and Persian, are written from right to left, with a font dedicated to their alphabet.

The mind maps. The entire taxonomy drawn as a tree, one per language, exported as SVG — a vector image format that stays sharp at any size. HTML pages in the repository display them.

The ontology. Two OWL files, one for fallacies, the other for virtues. An ontology is a formal description of concepts and their relationships, written to be read by a machine: it allows software to know that a fallacy belongs to a family, that it has variants, and how it relates to the others. The taxonomy is also described there in SKOS, a standard vocabulary for publishing a thesaurus.

The Print & Play. In addition to the files intended for a printer, the repository produces A4 pages to print at home, cut out and play.

What the box contains

Item Cards
Fallacies 175
Rules 15
Memo 1, printed in 7 copies
Scenarios 167
Argumentative virtues (separate deck) 131

Two remarks for reading this table. 175 fallacies have a card, but the taxonomy describes 1,408 nodes: it goes down from the large families to the particular cases, and not all of them deserve a card. The virtues follow the same rule.

The tarot deck therefore comprises 197 cards to produce. With the 167 scenarios, the box holds 364. It holds 495 if you add the virtues.

These figures are counted on the repository’s CSV files, by the same rule as the automatic check that re-verifies this count at every change.

How we make sure nothing breaks

The checks do not copy the figures: they recalculate them, then compare them with what has been produced.

The number of cards in a deck is deduced from the configuration and the CSV files. A row lost in a data file therefore makes the verification fail, instead of silently producing an incomplete game.

Page size is measured on the PDFs themselves, with a tolerance of one millimeter: a document laid out in the wrong format is flagged even when its page count is right.

The mind maps have their links checked one by one, and their display pages must not be older than the drawing they contain — otherwise the page shows an outdated version of the tree.

A final check opens the deck and reads its first pages to verify that the rules appear there, in order. It cannot read text: these pages are images. It therefore compares the pixels of the first pages with those of the rule cards.

The checks that only read the repository run on every proposed change: the card count, the mind map links, and the self-tests of the PDF checks, which exercise their logic on cases built for the purpose. The checks that open the produced PDFs, for their part, run on a machine that has just regenerated the game: a full production takes hours, so it is not replayed at every change.

Everything is open

The code is published under the LGPL-3.0 license: you can read it, modify it, and reuse it, provided that modifications to the code itself remain under the same license.

The editorial corpus — the card texts — is under the Creative Commons BY-SA 4.0 license, which allows reuse and adaptation provided you give credit and share alike. This license does not cover the whole repository: it applies to the seven files listed in the LICENSE-CONTENT.md file, and to them alone — the five card text files and the two ontologies derived from them. For any other file, the code license applies.

Rebuilding the game takes a single command, from the root of the repository:

dotnet run --project Generation/Converters/Argumentum.AssetConverter/Argumentum.AssetConverter.csproj

The PDFs are written to the project’s output folder, one subfolder per language. This requires a .NET environment, and the card rendering engine served by a local website; the mind maps additionally require FreeMind, the software that draws them.

And now

The repository keeps moving forward: the taxonomy is being completed, the translations are being proofread, and the checks expand as new defects are found. Every card in the game thus remains reproducible from its text, and verifiable.


Sources: Argumentum repository, commit 33f25e82 (November 6, 2026). Counts established on Cards/Fallacies/Argumentum Fallacies - Taxonomy.csv, the virtues taxonomy, Cards/Scenarii/Argumentum Scenarii - Cards.csv and Cards/Rules/Argumentum Rules - Cards.csv. Licenses: LICENSE and LICENSE-CONTENT.md. Mind maps: folder Cards/Fallacies/Mindmaps. Ontology: docs/ontology/argumentum.owl.

‹ Back to the list

Contact Us

Newsletter Sign-Up

We were unable to confirm your subscription.
Your subscription has been confirmed.

Newsletter

Subscribe to our newsletter to keep up with the latest news from Argumentum.

We use Sendinblue as our marketing platform. By submitting this form, you acknowledge that the information you provide will be transferred to Sendinblue in its capacity as a data processor, in accordance with its terms and conditions of use.