Minimalist game design with Compile
Exploring minimalist game design and how Compile's multi-use cards create strategic depth with just a few simple game components
Welcome to Skeleton Code Machine, an ENNIE-nominated and award-winning weekly publication that explores tabletop game mechanisms. Check out Public Domain Art and Fragile Games to get started. Subscribe to TUMULUS to get more design inspiration delivered to your door each quarter!
The last two weeks, we explored mechanisms in two solo TTRPGs. First we looked at the use of custom index cards in Menagerie of the Void. Most recently, how the Chaplain’s Game subverts expectations in Mechs into Plowshares.
This week we are looking at how Compile: Main 1 uses cards in an interesting way — creating strategic depth by covering and uncovering parts of the cards.
Compile: Main 1
While largely abstract, Compile: Main 1 (Yang, 2024) does have an ostensibly cyberpunk theme:
Compile is a competitive card game where players are rogue AI competing one-on-one in a race to compile their 3 protocols, rewriting reality in their new language.
The protocol cards represent concepts that your AI is researching: Spirit, Death, Fire, Metal, Gravity, Plague, Water, Darkness, Speed, and so on. Mechanically they represent different decks of cards that will be used in the game. Each set of protocol cards has it’s own special focus. For example:
Spirit: Flipping cards, shifting cards, and drawing cards
Death: Deleting cards, drawing cards
Fire: Discarding cards for effect
Life: Flipping cards, top deck play, and drawing cards
In all, there are 12 different protocols in the game. Each player drafts three and combines them to form a deck almost like you would in Magic: The Gathering or Android: Netrunner.1
Lane Battlers
Compile is an example of a lane battler, a family of games that includes Battle Line (Knizia, 2000), Schotten Totten (Knizia, 1999), Radlands (Piechnick, 2021), Omen: A Reign of War (Clowdus, 2011), and Air, Land, & Sea (Perry, 2019).
In a lane battler, there are several battles occurring on the table, each one separated into its own lane as part of the overall tableau of cards. There is usually limited interaction between lanes, but each lane contributes to the overall victory conditions.
In the case of Compile, each player places their three protocol cards at the center of the table, each one opposing one of the other player’s protocols. This creates three lanes with two protocols in each one. Players are then (generally) limited to playing only cards that match the lane’s protocols during the game. For example one lane might have Fire and Darkness in the center, meaning that only Fire and Darkness cards can be played into that lane.
Compile’s rules are packed into just two pages, but they are surprisingly deep and complex. I’m not going to explain the whole game here, other than to say that each card has a value on it. The goal is to place cards that add up 10+ in a given lane and “compile” it before your opponent does the same. Compile all three of your protocols and you win.
The really interesting part is how commands are shown and used on the cards.
Top, Middle, Bottom Commands
Cards in Compile have a value (usually 0 - 5), an associated protocol name/icon (e.g. Water) and three sections on their face-up side:
Top command (persistent): Passive effects that are always active while the card is face-up. Active unless the card is flipped face-down.
Middle command (immediate): One-shot effects that are resolved as soon as the card is played face-up, but also when it is flipped back to face-up or uncovered.
Bottom command (auxiliary): Additional passive effects, but only while the card is face-up and the bottom of the card is uncovered.
New cards added to a lane are placed on top of the existing cards so that they cover the middle and bottom of the cards, but not the top. This allows the top command (persistent) to remain in effect while the middle and bottom commands become covered and inactive.
By itself, this wouldn’t be too interesting, but when combined with commands that allow cards to be flipped, shifted between lanes, and covered/uncovered, it creates some really interesting choices.
For example, you might want to shift or delete (i.e. remove) an opponents card to reduce their compile value (10+ is the goal), but doing so might uncover an immediate or auxiliary command.2
Multi-use cards
Cards can be used to store a large amount of information beyond suit and rank.
Compile is a good example of this. The front of the card contains six explicit pieces of information: protocol, value, icon, top command, middle command, and bottom command. The back of each card also contains a value (always 2).
The card position on the table (i.e. lane) and facing (face-up or face-down) encode additional information about the game. The overlapping of cards (i.e. covering the middle and bottom) creates yet more information storage, adding mechanical depth to the game.
The entire game consists of 84 double-sided cards, and that’s it other than a folded sheet of rules.3 It’s a good lesson in creating a compact game with a minimal number of components. With a different design paradigm, I could see this game having been a larger box with punchboard tokens and additional cards.
Conclusion
Some things to think about:
Minimum Viable Components: The concept of minimum viable product is sometimes given as a way to get started on a game’s design — creating the absolute smallest version of workable rules. It can be an equally useful exercise to try to reduce the number and type of components while retaining the same mechanisms. Not only could this simplify the experience for players, it might lead to manufacturing cost reductions as well.
Tags vs. text: Take a look at the protocol card images above. A different game might have included a paragraph about how each protocol (i.e. faction) should be played. Instead single words (i.e. tags) and phrases are used. They work just as well to communicate the protocol’s strengths.
Theme vs. Mechanism: Compile includes almost no Layer 3 thematic elements. It does, however, use Layer 2 baked-in thematic elements at every opportunity. The art and action names all convey the cyberpunk/programming theme.
What do you think? Do you enjoy lane battler games? Could the top, middle, bottom idea of the Compile cards be adapted to other types of games?
— E.P. 💀
P.S. “A beautiful, straight-forward, and inspiring book.” Get ADVENTURE! Make Your Own TTRPG Adventure, the latest guide from Skeleton Code Machine, now at the Exeunt Press Shop! 🧙
Skeleton Code Machine is a production of Exeunt Press. All previous posts are in the Archive on the web. Subscribe to TUMULUS to get more design inspiration. If you want to see what else is happening at Exeunt Press, check out the Exeunt Omnes newsletter.
Compile, while almost nothing like Android: Netrunner, does seem to scratch the same itch for me as a 1v1 lane battle game. It’s use of flipping, shifting, and rearranging cards in the tableau can give some similar vibes. As a huge Android: Netrunner fan, I think this is some of the appeal of the game for me.
I generally don’t enjoy “memory” games, and that might be my one complaint with Compile. You really need to remember what the opponent’s cards are so you know what will be uncovered if you flip or shift their cards. If you have an excellent short term memory, this wouldn’t be a problem.
There is also one “Control” card that can be optionally used with additional rules.
A game I've been really enjoying is the Mistborn Deckbuilding Game. Like Compile, some cards have different effects that can be used in different circumstances. Some are passive, some are played normally, some for extra resources, and some can be played off-turn. I think it's an excellently designed game and I'd recommend checking it out if you haven't.
Compile looks like a very interesting game. Enjoyed reading about it.