Liars' Letters

Liars’ Letters is like Liar’s Poker but with words insteads of poker hands.

There’s a fun card game called Liar’s Poker where players get dealt cards that only they can see, then name escalating poker hands that they think exist among all the cards until someone calls bullshit. The rules I’ve played with are pretty similar to those described here.

I adapted this game to use words instead of poker hands and it’s quite fun. I call it Liars’ Letters. I actually forgot it existed until a friend suggested we play it again recently, so I’m taking the opportunity to write up the rules.

Components

You’ll need some letter tiles. Scrabble or Bananagram tiles will do just fine. Remove any blanks.

Word Sets

Players are going to be declaring sets of words that they think exist among the letter tiles that everyone is dealt. We’ll need to define what a word set is, and when one word set is higher than other.

A word set is any non-empty multiset of words, where each word is either (i) an individual letter, or (ii) a word in the language you’re playing in. (A multiset is a set that can contain duplicates.) Acronyms and proper nouns aren’t allowed, or else nearly every triple of three letters would be a word. You may want to pick some canonical definition of which words are allowed, like whether they’re in the Scrabble dictionary.

To decide whether one word set is higher than another, check which one has the longest word: that set is higher. If they’re tied for longest word, cross off the longest word from each set and then repeat, comparing what’s left of each set. For example:

• bigger > big, g, er
• big > it, is, so
• i, c, d, big, b > c, d, big, b
• big, big > it, is, so, big
• bigger, b = larger, b

Another way of describing this is that it’s the lexicographic comparison of the lengths of each word set, each sorted from high to low. In Python:

def lengths(xs):
    return sorted(map(len, xs), reverse=True)

def is_higher(xs, ys):
    return lengths(xs) > lengths(ys)

To Play

Put all the tiles face down and scramble them.

For the first round:

• Everyone is dealt one letter tile. You can view your own letter, but not others’ letters.
• Pick a starting player. They declare a word set.
• In clockwise order, players take a turn. Go around as many times as necessary. On your turn, you must either (i) raise by declaring a higher word set, or (ii) call bullshit.
• Once a player calls bullshit, everyone reveals their letters, and you check whether the most recently declared word set exists among all the letters:
  • If the word set exists, then the player who called bullshit gains a letter tile for all future rounds.
  • Otherwise the previous player (who declared the word set that doesn’t exist) gains a letter tile.
  • If a player would gain a fifth letter tile, they’re out of the game instead.

Future rounds are similar, except:

• Each player draws their accumulated number of letter tiles.
• The starting player is the player who last took a turn who’s still in the game.
• Rounds alternate between clockwise and counterclockwise.

Continue until there’s only one player remaining. That player is the winner.

One Final Rule

There’s one extra rule that’s useful in the rare circumstance that you believe the previous player’s declared word set, but can’t name a higher one because you think they’ve named all the letters on the table and constructed the longest possible words from them.

The extra rule is that you’re allowed to call “exact”, instead of raising or calling bullshit. If you call “exact”, reveal all the letters and check to see if the last declared word set not only exists but is the highest possible word set. If so, both you and the previous player lose a letter tile (you can go down to 0 but not below). Otherwise, you gain a letter tile.

This should happen very rarely. If you end up using this rule much you should find less truthful friends.

September 15, 2026