When I first started developing Unscrabbled, I had a simple question in mind:

What would happen if you combined the strategic vocabulary challenge of Scrabble, the satisfying match-and-drop mechanics of Two Dots, and the spatial logic of Squaredle — all inside a single word game?

That question turned into a surprisingly deep design and development journey. In this post, I’ll take you through how I created Unscrabbled, from grid logic and tile behavior to word detection and board evolution. If you’re a game dev, puzzle designer, or just someone curious about how this kind of game ticks, this one’s for you.

🎮 Game Loop Basics: What Happens When You Play

The core gameplay loop of Unscrabbled goes like this:

• Start with an 8x8 grid of random letter tiles.
• Find a valid word by selecting adjacent tiles in any direction (up/down/left/right, or diagonal).
• Submit the word to clear those tiles.
• Apply gravity — tiles above fall into the cleared space.
• Fill empty slots with new random letters from the top.
• Repeat until the player runs out of turns.

This sounds deceptively simple, but making it feel intuitive and rewarding required a lot of iteration.

🔤 Word Validation: Inspired by Scrabble and Wordle

The first challenge was validating words. Like Scrabble, we needed a solid dictionary backend — but with real-time performance and flexibility for casual players. We want to stay true to Scrabble, so we opted for a similar word list optimized for everyday vocabulary. The standard two-letter Scrabble words became important early in development to help manipulate the game board grid to create longer words so we created a custom dictionary similar to the Collins Scrabble Words (CSW).

Key considerations:

• Fast lookup using a customized dictionary file.
• Only allow selection of letter tiles that are part of a word from our custom dictionary.
• Simple visual to show how the word is removed and the letter tiles above slide into position for players to create new words.

🔄 The Grid Engine: Gravity, Refill, and Letter Dynamics

The grid behavior is where Two Dots and Candy Crush inspiration came into play.

When a valid word is submitted:

• Each tile in the word is marked for removal.
• Tiles above the removed tiles “fall” down vertically to fill the gaps.
• New tiles are generated at the top and fall into the grid.

This cascading mechanic was surprisingly tricky — we had to:

• Track empty spaces per column.
• Handle multiple clears in quick succession.
• Animate the falling behavior without blocking UI interactions.

for column in grid.columns:
    empty_slots = []
    for row in reversed(column):
        if grid[row][column] == EMPTY:
            empty_slots.append(row)
        elif empty_slots:
            target_row = empty_slots.pop(0)
            grid[target_row][column] = grid[row][column]
            grid[row][column] = EMPTY
            empty_slots.append(row)

🧠 Strategy Layer: Inspired by Squaredle

The real “hook” of Unscrabbled is strategic manipulation of the grid. While players can quickly grab short words for small points, skilled players aim to shape the board — just like Squaredle encourages thoughtful positioning.

For example:

• Playing around almost formed words until you drop the correct letter into place to complete the word 
• Dropping an ‘S’, 'ED', 'ING' onto  common words can open a big word.
• Planning clears to avoid isolating useful letters and vowel clean-up.

This emergent strategy wasn’t immediately obvious during development — it surfaced during early testing and became a core mechanic.

📈 Scoring System (The Heart of the Game)

Scoring in Unscrabbled is based on two factors:

• Average Word Value (AWV)
• Word Length Multiplier

AWV is calculated by adding the Scrabble values of each letter in the word and dividing by the number of letters in that word.

Example 1: TOO
T:1 + O:1 + O:1 = 3 → 3 ÷ 3 letters = AWV = 1.0

Example 2: ZOO
Z:10 + O:1 + O:1 = 12 → 12 ÷ 3 letters = AWV = 4.0

Once you calculate the AWV, it is multiplied by the base score based on word length. We use an exponential scoring system to reward longer words more heavily:

📈 Word Length Base Scores

• 2 letters: 4 points
• 3 letters: 8 points
• 4 letters: 32 points
• 5 letters: 64 points
• 6 letters: 128 points
• 7 letters: 256 points
• 8 letters: 512 points
• 9 letters: 1,024 points
• 10 letters: 2,048 points
• 11 letters: 4,096 points
• 12 letters: 8,192 points
• 13 letters: 16,384 points
• ...and so on (each length doubles the previous base score)

Tip: Words that begin and end with the same letter (forming a square) score double.

🧪 Lessons Learned

One of the earliest versions of the game board was inspired by the look of the game Dots (or Two Dots) where each letter was displayed inside a colored circle. Each letter had a unique color, and the board was filled with these colorful round tiles.

While visually interesting, this design made it difficult to select connecting letters accurately. The circular shapes around the letters created confusion during gameplay, especially when players tried to form words across adjacent tiles.

The image below shows an early version of the board after we updated it to use square tiles instead of circles. These tiles were much easier to tap or click, greatly improving the overall playability.

At this stage, there were still no animations. As a result, early testers struggled to understand how the board was updating or what was happening when words were found and removed — everything felt static and unclear.

• Playtesting early revealed strategies I didn’t even intend — especially in how players tried to “dig” for big letters like Q, Z, X.
• Mobile UI matters — the drag-to-select mechanic needed heavy tuning to avoid accidental selections, so we added the undo button
• Animations aren’t just polish — they help players understand cause and effect in a dynamic board.

⏳ Game End Logic: Limiting Infinite Play

In the very early stages of development, we didn’t have a clear way to end the game. Originally, players could keep finding words without any limit, and the game would continue indefinitely.

We introduced a turn system, where each player would start with 7 turns. To reward skill, we allowed players to earn an extra turn for every word they found that was five letters or longer.

However, once we tweaked the algorithm that generated vowels and consonants, one of our early power testers discovered they could play endlessly. They kept earning extra turns and never ran out — the game only ended when they were too tired to keep going!

To create a fair challenge and ensure consistent daily gameplay, we ultimately decided to cap each player at 50 words per daily board. This encourages strategic play while giving everyone a satisfying endpoint.

🛠 Tech Stack (Briefly)

• Frontend: JavaScript + HTML5 Canvas + CSS for custom rendering and fluid interactions.
• Backend: PHP for word validation and scoring.
• Dictionary: Custom simple txt file

🚀 What’s Next

• Continued tweaking of the vowel consonant and scoring algorithms
• More advanced leaderboard
• Possible bonuses and tile power-ups

Final Thoughts

Unscrabbled was born from a mashup of games I love — and it turned into a deep puzzle system with surprising strategic depth. If you’re into game design, especially in the word/puzzle space, I highly recommend tinkering with combining familiar mechanics in new ways. Play the game at Unscrabbled and let me know what strategies you discover. This game is still evolving, and I’m excited to keep building it in public.