Skip to content
Lizely

Word Chain Game

Build five verified no-repeat word links from each previous word's final letter.

Privacy: your files never leave your device. All processing happens locally in your browser.

How to use

  1. 1.Read the previous word and the highlighted final letter; your next single English word must begin with that letter.
  2. 2.Type a word from the game's fixed local dictionary and press Enter or tap Link word; words already used in the chain are rejected.
  3. 3.Complete five valid links for 1,000 points, and remember that a second distinct rejected word locks the chain until Restart.

About Word Chain Game

Word Chain Game is a focused five-round vocabulary puzzle built around one exact rule: the first letter of every new word must equal the final letter of the previous word. The opening seed is shown on the board, along with the one letter required for the next entry. Submit a valid link and that accepted word becomes the new end of the chain. Complete five links to earn 200 points per round and an exact final score of 1,000.

This version uses a small, fixed local dictionary so every round is deterministic, testable, and available without a network request. A submitted word must satisfy three independent checks. It must be present in the game dictionary, it must start with the visible required letter, and it must not have appeared earlier in the current chain. The dictionary membership check matters: a plausible-looking string is not accepted merely because its first letter matches. The no-repeat check also applies even when a reused word would otherwise form a valid letter link.

Input normalization is intentionally narrow and predictable. Leading and trailing spaces are removed, and ASCII letters are converted to lowercase before validation. This means uppercase or mixed-case versions behave like their lowercase spelling. Blank entries, punctuation, digits, hyphens, and multi-word phrases are treated as malformed input and ignored without changing the score, round, attempt history, or current word. The game is designed around single English words using the letters a through z.

The accepted spellings are reference data rather than invented labels. Princeton WordNet 3.1 is the primary lexicon. During preparation, its official HTTPS dictionary archive returned HTTP 200, and each of the six nouns was read directly from the archive's dict/index.noun file. Six Cambridge Dictionary entry pages independently cross-check the same spellings and noun senses, and every page also returned HTTP 200. The exact accepted list remains out of the accessible page DOM, so the interface does not reveal future answers before they are played.

The visible interface gives only the information required by the rule: the current word, its final letter, the round count, score, number of words used, and number of unique misses. It never renders a candidate list, hidden answer menu, solution path, or data attribute containing future accepted words. After you submit an accepted entry, the field clears and the next required letter updates. Keyboard players can type normally and press Enter to submit. The input and submit button both provide at least a 44-pixel interaction height for comfortable touch use, and the layout constrains long text so narrow screens do not develop page-level horizontal overflow.

Each round permits one distinct rejected word before locking on the second. A rejection can come from a wrong first letter, a word outside the local dictionary, or a repeated word. Checking the same normalized wrong word again is deduplicated: surrounding spaces or uppercase letters do not create a new signature. A second different rejected signature sets the game to deadlocked. The input and submit button then become disabled, and only Restart restores the deterministic seed, empty attempt set, first round, and zero score. This makes the failure rule observable and prevents extra submissions from mutating a locked state.

The test suite separates product logic from its oracle. It owns a literal seed, a literal five-word path, and an independent Set representing the expected dictionary. Its own lowercase, trim, and last-letter comparison functions prove every adjacent path link without calling the product normalizer or validator to generate expected results. Ten external golden cases cover the six dictionary spellings, case and whitespace normalization, an accepted tail link, a rejected tail mismatch, and a rejected repeat. Additional state-machine tests cover the full five-link path, exact 200-point increments, exact 1,000 completion, malformed input no-ops, unknown dictionary words, normalized duplicate rejection, second-distinct-rejection deadlock, locked-state immutability, terminal-state immutability, and deterministic Restart.

Everything runs locally in the browser as a client-side L1 game. Typed words are not uploaded for validation, and playing does not require an account. The shared GameShell supplies the score display, local best-score behavior, Restart, and Boss Key. Because the fixed dictionary and path are deliberately compact, this is a rule-reading and chain-reasoning challenge rather than an exhaustive English dictionary product. The limitation is disclosed: common English words outside this audited local set will be rejected. That bounded scope keeps every accepted spelling independently reviewable and ensures that the same input always produces the same result.

Methodology & sources

The fixed noun spellings are checked against Princeton WordNet 3.1 dict/index.noun and independently against Cambridge Dictionary. Product validation trims and lowercases ASCII input, requires local dictionary membership, compares newWord[0] with previousWord.at(-1), and rejects any word already in usedWords. Tests use a separate literal Set and path oracle rather than product validation to derive expected results.

Frequently asked questions

Related tools

Mini Games guides

View all