DEV Community: Ads Mastery Pro

Krillion Unlimited: the trivia game where the rarest answer wins

Ads Mastery Pro — Sat, 31 Oct 2026 09:08:03 +0000

Krillion Unlimited is a trivia game I built where the obvious answer is worth almost nothing. You get a prompt like "name a country that starts with S". Spain is correct, and it earns you 10 points. São Tomé and Príncipe is also correct, and it earns you 100, because almost nobody thinks of it. Seven prompts per dive, 25 seconds each, and your score is the total rarity of what you managed to catch.

The game is live and free at rabyss.com: endless dives, no account, no daily limit. On the site I call it the infinite game, and a few players have taken that as a personal challenge. This post is about the part that nearly sank the whole project: the answers.

Rarity is a data problem

The obvious way to score rarity is to count live submissions. If 400 players answer a prompt and only 2 of them say your answer, your answer is rare. That math works fine if you already have thousands of players.

A new game has twelve players. On a good day.

So version one of Krillion Unlimited does it the slow way. Every accepted answer is graded by hand into a tier before it goes into the bank:

Plankton, 10 points. The answer everyone gives in the first two seconds.
Too Clever, 15 points. Feels obscure. Is not. Every trivia fan's first "rare" answer lands here, which is exactly why it pays so little.
Schooler, 30 points. A solid answer most casual players miss.
Rare, 60 points. Genuinely uncommon.
Deep Cut, 85 points. The answer that makes other players say "wait, that's a thing?"
Deepest, 100 points. One or two per prompt, sometimes none.

Points turn into depth at 10 metres per point, so a perfect dive is 700 points and 7,000 metres down.

The bank currently holds 1,026 prompts and 35,554 graded answers. The grading rule I ended up with is two questions. Would a casual player say this in the first five seconds? Would a good player say it at all? Those two answers sort most of the bank without much argument. The fights happen in the middle tiers, and yes, I have had the "is Uruguay really only a Schooler?" argument with myself at 1 a.m.

Aliases ate my weekends

Players do not type canonical names. They type NYC, New York and New York City in the same match, and all three people mean the same place. JFK is an airport or a president depending on the prompt.

So every answer in the bank carries its aliases, and the checker is forgiving about spelling. When a typed answer is close to a bank answer, the game stops and asks "did you mean this one?" instead of marking it wrong. The 25 second clock pauses while that box is open. Marking someone wrong because my bank spells it differently is a me problem, not a player problem.

This is the least glamorous part of the whole build and it never really ends. The bank grew by 13,802 answers in a single expansion pass last month, and most of that growth was aliases and tier corrections on prompts that already existed. New prompts are the fun part. They are maybe a third of the work.

Multiplayer broke the tiers (politely)

Static tiers are fine for solo play. Multiplayer is a different animal. If three people in the same room all catch the same "rare" fish, that fish was not rare in that room.

Puffer Party, the multiplayer mode, grades against the room. A catch pays its bank tier only if you are the only one who landed it. Shared catches step down a tier for each extra player holding the same answer. It keeps the honest rare answers valuable and stops the whole room farming the same trick answer every round.

Two other things multiplayer forced on me:

Rooms cannot wait for humans. Tables stay alive with resident bots that play at 60 to 97 percent skill with think times of one to six seconds, and they give up their seats when real players sit down.
The realtime layer had to stay boring. Socket.io runs inside the same Node process as the Next.js app, one custom server file, polling transport only. One process, one deploy, very little to babysit at 3 a.m.
Being browser only, with nothing to install, has a side effect I did not plan for. The game opens fine on locked down school and office networks, the exact places where people go hunting for "unblocked" versions of every game they like. I will take that traffic, thank you.

What the daily results taught me

Curated tiers are a prediction. Real play is the correction.

I keep an eye on the recorded answers from the official daily dive (I publish them as a fan sheet, Krillion Answers Today, because I am exactly the kind of person who reads other people's answer sheets). One recent dive asked for a sport involving flips or somersaults. The rarest recorded answer was Course landaise, a French bull leaping tradition that almost nobody outside France has heard of. That is the kind of answer my tiers are trying to predict before anyone plays.

Some of my grades will be wrong. A Deep Cut that the whole internet suddenly knows about is just a Plankton with good PR. The plan is to recalibrate tiers against real catch data as it builds up, and let the bank earn its accuracy instead of assuming it.

The honest summary

If you build an answer based game, budget for the bank, not the code. The code took weeks. The bank is forever.

And if you play a dive and catch something you think I graded wrong, you are probably right. That argument is the game working as intended.

Wordle Solvers Are Entropy Machines — Here's Why

Ads Mastery Pro — Wed, 07 Oct 2026 08:08:32 +0000

TL;DR: A Wordle solver treats every guess as a math problem: it ranks candidate words by how much information they'd reveal (entropy), then filters the word list using green/yellow/grey feedback. Understand that loop and you'll play better even without a solver.

The difference between a casual Wordle player and a strong one isn't vocabulary. It's the opening guess.

Most people open with a word they like. A Wordle solver opens with the word that eliminates the most wrong answers no matter what happens. That single idea — scoring guesses by information instead of hope — is the entire engine. Let's break it down.

A Wordle solver starts with 2,300 suspects

Standard Wordle has roughly 2,300 possible answers. Before the first guess, a solver holds all of them. Every guess is a question asked to that list, and the color feedback is the answer:

🟩 Green — right letter, right spot. Lock it in.
🟨 Yellow — right letter, wrong spot. It lives somewhere else.
⬜ Grey — not in the word at all. Throw out every word containing it.

Three sharp guesses can collapse 2,300 candidates to a handful. The trick is picking guesses that collapse the list fastest.

Entropy: ranking guesses by information

Here's the core concept. For any candidate guess, imagine every possible feedback pattern it could produce (there are 243 for a 5-letter word). Some patterns split the remaining words evenly; others barely narrow anything.

Entropy measures the average information a guess delivers. A solver computes it for candidate openers and picks the max:

SOARE scores high — S, O, A, R, E are among the most frequent letters, so the feedback partitions the list efficiently.
ADIEU tests four vowels at once, instantly revealing the vowel structure.
XYLYL would score terribly — rare letters teach you almost nothing.

You don't need the formula memorized. The intuition is what matters: the best guess is the one that teaches you the most, not the one most likely to be right.

The filter loop (with code)

After each guess, the solver filters. Here's the logic in JavaScript — the same shape most open-source solvers use:

function filterWords(words, guess, feedback) {
  // feedback: array like ['grey','yellow','green','grey','yellow']
  return words.filter(word => {
    for (let i = 0; i < 5; i++) {
      const g = guess[i], f = feedback[i];
      if (f === 'green' && word[i] !== g) return false;
      if (f === 'yellow' && (word[i] === g || !word.includes(g))) return false;
      if (f === 'grey' && word.includes(g)) return false;
    }
    return true;
  });
}

// Example: guess SOARE, feedback tells us S is green, O is yellow
const remaining = filterWords(wordList, 'soare',
  ['green','yellow','grey','grey','grey']);
console.log(remaining.length); // a few dozen, down from ~2300

One guess, one filter pass, and thousands of words vanish. That's the loop: rank → guess → filter → repeat until one word remains.

The duplicate-letter trap

The edge case that breaks naive solvers: guess SPEED, get one green E. Is there a second E hiding? A simple "grey means absent" rule fails here — the word could be SLEEP or GREED.

Robust solvers track letter counts, not just presence: if E is green once and grey once, the answer contains exactly one E. Getting this right is the difference between a toy solver and a reliable one — and it's the same logic that trips up human players on words like CIVIC or ESPOUSE.

Watch a solver think in real time

Reading about the filter loop is one thing; watching 2,300 words collapse live is another. This free wordle solver lets you enter a guess with its color feedback and see the remaining candidates shrink after every round. Try your usual opener, then compare the solver's suggested next guess against your instinct — the gap between the two is exactly the entropy lesson above.
It's part of VowelnVault, a free unlimited Wordle game with daily puzzles and hints.

The takeaway

A Wordle solver isn't cheating — it's applied information theory. And the real prize isn't the tool, it's the mindset: once you start choosing openers for information instead of luck, your unassisted game jumps too.

What's your opener, and why? Do you play the entropy game with something like SOARE, go vowel-heavy with ADIEU, or trust a lucky word? Drop it in the comments — I'm curious which philosophy wins out. 🟩

For more word-game resources, explore this collection of useful links.