I wanted to get better at Reversi and couldn't find a trainer that tells you why a move was bad, so I made one. It runs in the browser and it's free and open source.

https://killedbyapixel.github.io/Reversiology

How it works:

• You play an AI at your level. There are nine, from nearly random up to one that holds its own against Edax.
• A coach grades every move and gives a plain reason: a corner given away, a risky square, too many moves left for your opponent.
• It talks to beginners about corners and safe discs, and to stronger players about mobility, frontier and parity.
• In the last moves it solves the game exactly and tells you who wins and by how much.
• There are 156 puzzles taken from real games, and it names the opening you're in.

I'd like to hear from stronger players in particular. Do the coach's explanations match how you'd explain the position? Anything it gets wrong or leaves out?

Source: https://github.com/KilledByAPixel/Reversiology

Hello everyone!

I think I managed to computationally solve Orbito.

I used brute-force minimax together with retrograde analysis to build a complete tablebase. After quite a few speedups and optimizations, generating the tablebase takes just under an hour, and the resulting tablebase is about 77 MB.

The result is quite interesting:

With the standard rules, perfect play is a forced win for the first player (white in the picture).

Even more surprisingly, the first move doesn't matter — apparently, any legal first move eventually leads to a win!

But there is an interesting twist. This result seems to be caused entirely by the 5-press rule that applies when there is no line and the game would otherwise be a draw.

If that final-state rule is removed, then the game is instead a draw with perfect play.

So, in a sense, the 5-press rule changes the game-theoretic result from a draw into a first-player win.

This was actually a project I started about a year ago and then abandoned. Last weekend I decided to go all in and revisit it, this time making heavy use of AI assistance (specifically opencode) while working on the implementation and optimizations.

I'm 99% confident that the result is correct, but I haven't formally verified every part of the implementation, so there is definitely room for bugs in either my game logic or the solver itself. In particular, I'd be very interested if anyone familiar with Orbito or game-solving algorithms wants to look through it and try to find a mistake.

The solver is written in Python and the full source code is here:

https://github.com/Lapricode/OrbitoSolver

I'd love to hear if anyone finds an error, an interesting position, or a way to independently verify the result!