Unlike

• 

  In-Game Screenshot

• 

• 

• 

• 

• 

Inspiration

I love logic games that teach one simple rule and then reveal surprising depth. I wanted to create something with the accessibility of Sudoku or Minesweeper, but with a mechanic that felt genuinely different and worked naturally on a phone.

That idea became Unlike, a neighbor-logic puzzle about relationships between cells rather than numbers alone.

What it does

Every cell is either solid or outlined. A numbered clue tells you how many of its orthogonal neighbors—above, below, left, and right—must be unlike that cell.

For a clue cell (c), the rule is:

[ k_c = \sum_{n \in N(c)} [x_n \ne x_c] ]

Here, (N(c)) is the set of neighboring cells and (x) represents each cell’s state.

Players use these clues to deduce the entire board. Unlike includes guided tutorials, progressive levels, three difficulty modes, a deterministic daily puzzle, hints, undo and redo, accessibility support, themes, statistics, and offline play.

How I built it

Unlike is a native iOS app built with SwiftUI. I separated the project into a presentation layer and two testable Swift packages:

• UnlikeEngine handles puzzle generation, constraint propagation, validation, grading, and hints.
• UnlikeRules handles progression, rewards, themes, and gameplay policies.
• The SwiftUI app provides the board, tutorials, level selection, daily puzzle, settings, and visual feedback.

The generator creates candidate boards entirely on-device. Each puzzle is passed through a solver that counts solutions and rejects boards that are ambiguous, repetitive, unbalanced, or inappropriate for their intended difficulty.

The solver models every clue as a small constraint involving no more than five Boolean values. It repeatedly removes unsupported possibilities until reaching a fixed point. Harder puzzles can also require single-cell contradiction analysis.

Because flipping every cell preserves all “unlike” relationships, each board needs a pinned reference cell to break that symmetry and produce one definite solution.

Challenges I faced

The hardest challenge was not drawing the board—it was proving that every generated puzzle was fair.

A puzzle can look convincing while having multiple solutions, no logical opening move, or a difficulty level that does not match the player’s experience. I built a bounded solution counter, uniqueness filtering, and a grading system based on deduction depth and required case analysis.

Hints presented another challenge. Simply revealing the correct cell would solve the immediate problem without teaching the player anything. Instead, Unlike generates hints from the deduction the solver discovered, allowing it to explain why a move follows from a clue.

The final major challenge was onboarding. The rule is compact, but understanding that a clue compares its neighbors to its own state is initially unfamiliar. I addressed this with interactive tutorial boards, highlighted relationships, contextual explanations, and a learning mode that introduces the mechanic one step at a time.

What I learned

I learned that procedural generation and puzzle design cannot be separated. A generator must evaluate not only whether a board is solvable, but whether solving it produces an enjoyable sequence of deductions.

I also learned that the same constraint-propagation system can power several parts of the experience: solution validation, difficulty grading, hints, and automated testing.

During development, I validated 1,200 generated prototype puzzles across three difficulty levels. Every accepted board had a unique solution, an available opening deduction, and a difficulty profile matching its category.

Most importantly, I learned that teaching is part of the game design. Once the tutorial and hints began explaining relationships instead of merely showing answers, Unlike became much easier to understand without losing its depth.

Built With

• admob
• avfoundation
• google
• ios
• storekit-2
• swift
• swift-package-manager
• swiftui
• uikit
• xcode
• xctest