Inspiration

Junction Nine started as a family project.

I had begun making puzzle games with my kids as my earliest playtesters and sounding board. I wanted to build games that respect the player's attention: something you can stop and think about, put down, discuss, and come back to later - without timers, streaks, ads, or pressure to keep playing.

A game can be compelling because you want to come back to it - not just because you can't put it down.

The specific idea for Junction Nine came after a lecture at my daughter's math camp mentioned a 2011 paper by Alex and Andrew Sutherland exploring the mathematics of a 3×3 rotation puzzle.

I was fascinated that such a small board could contain an enormous number of possible states, yet every one could still be solved within a fixed number of moves.

A 3×3 board with nine distinct tiles, each of which can have two orientations, has:

$$ 9! \times 2^9 = 185{,}794{,}560 $$

possible board states.

Sutherland and Sutherland established through exhaustive analysis that every state in this 3×3 system can be solved in nine spins or fewer.

That became the starting point for Junction Nine: could I take that underlying mathematics and turn it into a visual puzzle that feels intuitive rather than academic?

What it does

Junction Nine is a minimalist 3×3 puzzle built around colored paths and one simple move: select a rectangular section of the board and spin it 180 degrees.

The goal is to rearrange the tiles until the paths connect seamlessly across the board. A single spin can complete one connection while breaking another, so rules that take seconds to understand can lead to puzzles that require real spatial reasoning.

Every puzzle included in Junction Nine is solver-verified with a known shortest solution. That creates a second challenge: you can solve a puzzle without solving it optimally.

Finishing the board is one goal. Finding the best solution is another.

The interface is deliberately restrained. Connected paths remain clear while broken connections and displaced tiles are muted, allowing the board itself to communicate progress. By default, the solved board also appears beneath the puzzle as a reference; players can turn it off for a greater challenge.

The game launched with three packs:

  • Origin: 30 puzzles, completely free.
  • Transfer: 30 additional puzzles for a one-time $2.99 purchase.
  • Interchange: 30 additional puzzles with new palette for a one-time $2.99 purchase.

Then just days ago, we launched two more 30-puzzle packs completing the Transit Line collection, alongside five 30-puzzle packs from the Confection Line, adding a candy-inspired theme to the line puzzles. Customers can now also purchase a collection for $9.99 and an All Access pass for current and future games for $16.99.

There are no ads and no subscriptions.

How we built it

Junction Nine was built as a solo development project, with my kids continuing to playtest and react to the game as it evolved.

I studied computer science in college, including AI, but hadn't seriously coded in years. Modern AI development tools changed what was possible. I built my first mobile game primarily using Replit; for Junction Nine, I expanded my toolset to include Claude Code as well.

I used Replit particularly around the monetization work, including integrating RevenueCat and working through the purchase and entitlement flow. RevenueCat manages access to the paid Transfer pack.

The solver behind Junction Nine allows the game to know the shortest solution for every puzzle we ship rather than estimating difficulty or optimality by intuition.

Building the game was only part of the project. A surprising amount of the work involved turning a functioning puzzle into something that could actually ship through both Apple and Google: in-app purchases, entitlements, sandbox testing, reviewer access, purchase restoration, store assets, and the edge cases that only appear when a real app meets a real store.

Challenges we ran into

One of the first challenges was designing the tiles themselves. They needed to be distinct enough to reason about when scrambled, while making potential connections visually inferable rather than arbitrary.

Another challenge was deciding how much information to give the player. I didn't want a traditional hint button that simply hands out the next move. Instead, the solved board can serve as a reference while the puzzle itself continuously communicates which paths and tiles are out of place.

As I tested the game, I realized that without some anchor tiles showing correct placement and a reference solved board, a casual player could find the puzzle unnecessarily opaque. Finding the right balance between deduction and frustration became an important part of the design.

The purchase flow created a completely different class of problems: sandbox accounts that already owned a product, free-redemption flows across different stores, restoring purchases in a way that makes sense to the player, and ensuring that RevenueCat entitlements reliably turn locked content into playable content.

These issues weren't glamorous, but solving them was part of turning Junction Nine from a prototype into a real product.

Accomplishments that we're proud of

I'm most proud that the mathematical idea survives all the way into the finished game.

Junction Nine isn't simply using "math" as a theme. The solver actually knows the optimal solution to every puzzle included in the game, giving a small 3×3 board a surprising amount of underlying depth.

I'm also proud of how little the game asks from the player outside the puzzle itself. There are no timers, streaks, ads, energy systems, or subscriptions. It is designed to be opened when you feel like thinking and closed when you're done.

And on a personal level, I'm proud that Junction Nine became the second game to grow out of what started as a family project. My kids have been some of the toughest playtesters I could ask for, and their reactions have repeatedly pushed the games further.

What we learned

One of the biggest lessons was that simple rules and simple implementation are very different things.

"Spin part of a 3×3 board until the paths connect" can be explained in seconds. Building the solver, generating worthwhile puzzles, communicating state visually, handling orientation correctly, creating an approachable progression, and making the purchase system survive real App Store and Google Play behavior were much larger problems.

I also learned how effectively modern AI development tools can let one person move between very different layers of a project. Claude Code helped me move quickly between game logic, UI, debugging, and iteration, while Replit and RevenueCat helped close the gap between having a playable game and having a product with working monetization.

Most importantly, the project reinforced the design principle that started it: a mobile game doesn't have to demand constant engagement to be compelling.

Sometimes the right experience is one that gives you a problem, gives you room to think, and is perfectly happy to wait until you come back.

What's next for Junction Nine

The initial release contained 90 puzzles, with the current release containing 300 puzzles split between two themes: a metro line map and a candy-inspired map. However, the underlying mathematical space contains more than 185 million possible states. That gives Junction Nine substantial room to grow with new puzzles and new tile designs without changing the core mechanic.

The next step is to see how real players approach the game: where they get stuck, how often they find the optimal solution, which difficulty levels are most satisfying, and whether they prefer playing with or without the solved-board reference.

That feedback can guide future puzzle packs, tile designs, and new challenges.

The first 300 puzzles are the beginning. The underlying idea has a much larger world left to explore.

Built With

Share this project:

Updates

Submission history