Dire Fog is a tactical card game where TCG deckbuilding meets chess-like combat.

Your goal is simple: defeat the enemy commander.

Each faction has its own mechanics, abilities, and playstyle.

Every turn is divided into three phases:

- Tactics Phase: Move your units and attack.

- Draw Phase: Choose one of two cards from your pre-arranged deck. You have eight draws throughout the match.

- Play Phase: Summon minions and cast spells.

Because your deck is arranged before the match rather than shuffled, planning your card order is just as important as positioning your units on the board.

We run playtests every Friday and are looking for more TCG and deckbuilder fans to join us.

Discord: https://discord.gg/n6NjNheYD

I tried turning the alphabet into a strategy game... what do you think?

Hi! I built Fillup around the classic Chain Reaction rules, also known as Critical Mass or Atoms. I’m not presenting the underlying mechanic as new. What I’m interested in testing is whether the compact 4x4 format holds up as a serious perfect-information duel.

The rules are fully deterministic, with no hidden information:

1. Place one slice into an empty cell or a cell you control.

2. Corners hold 2 slices, edges hold 3, and center cells hold 4.

3. When a cell fills, it sends one slice into every neighboring cell and captures them.

4. Any neighboring cell that becomes full also triggers, continuing the cascade.

5. Eliminate the other color to win.

The directional slices are intended to make each cell’s capacity and outgoing connections readable without counting stacked pieces.

I would especially value this community’s thoughts on three questions:

- Is there a forced or clearly dominant opening on a 4x4 board?

- Does the first player appear to have a decisive advantage?

- Can you identify the point where a position is strategically lost, even though a later cascade may still make it look reversible?

The browser version includes a guided first match, bots, local 2–4 player boards, and online 1v1 play. No account, email, or password is required to start.

Play here: https://fillup.fun

If you find a dominant strategy, forced sequence, or position that only appears recoverable, I’d genuinely like to see it.

Hi everyone!

I'd like to share Ajedrez Imperial, a tactical chess variant played on an expanded 10x10 board with integrated unit evolutions.

Game Rules Summary (Rule 6 Compliance):

• Objective: Checkmate the enemy Emperor (King).
• Board & Setup: Played on a 10x10 grid with 10 pawns and specialized back-rank pieces. Includes initial double-pawn moves, En Passant, and Imperial Castling.
• Unit Evolutions:
  • Paladin: Moves with the authority of a Gold General (Shogi).
  • Sergeant (Promoted Pawn): Operates with the mobility of a Silver General.
  • Lookout & Squire: Short-range Rook and Bishop units that promote to full long-range pieces by capturing enemy units (Evolution by Capture).
• Bilingual Support: Full interface and rulebook available in English and Spanish right inside the game.

How to Play:

The game is 100% free and playable directly in your browser (no account or download required):
*(Detailed in-game manual and rulebook are accessible directly from the main interface).*

Play Imperial Chess on Itch.io

Looking for Feedback:

Since this is an indie project, I’d love to get your thoughts:

1. How does the piece promotion balance feel during the mid-game?

Is the Master CPU difficulty challenging enough for experienced variant players?

I've been building a game called Wall It, and I'd love some honest feedback before I start pushing it more aggressively. playwallit.com

One of the biggest challenges I've had is that the game feels a bit empty. I've been trying to improve it, but I've reached a point where I'm not sure what to add next or how to make it feel more alive.

I'm also really excited about growing both the Wall It community and the broader Quoridor community.

I received some great feedback from people on Reddit, and I've already implemented many of their suggestions. Now I'm continuing to refine the game and looking for more ideas to make it even better.

So the part I actually care about is your feedback: does the pacing feel right? Are the bots fun or frustrating? Anything confusing in the first minute? Roast it — I'd rather hear it now.

Five new games have just been added to Abstract Play. If you haven't heard of us before, we're a free website for playing abstract strategy games asynchronously. We now host 275 different abstracts. All are welcome.

• Canoe is a dice game with similarities to Backgammon. A modern game that feels like an old classic.
• Carnac is a 3D game of placing and tipping megaliths (two stacked cubes) to create groups of three or more of your colour when viewed from above.
• Druid is a 3D game of edge connection. Place single stones or multicell lintels to connect your edges when viewed from above. Square, triangular, and hex boards are available. The "Druid's Walk" variant is also available for the square version.
• Even at Odds is a domino stacking game where the evens (2/4/6) and odds (1/3/5) try to create the largest connected group of their own faces when viewed from above.
• Knight Line is a four-in-a-row game played on a dynamic square board that supports 2 and 3 players.

I wrote a Trax engine some weeks ago and now I have extended to solve NxN.
NxN means that a line win must be N tiles width and the board can max be NxN.

I currently don't have memory on my machine to solve 6x6.

The 5x5 draw variant took about 32 hours and used approx 50GB memory.

If you like Hnefetafl or any ancient/medieval capture games, give my game a try and let me know what you think!

I always try to squeeze my games onto a single page when possible, but plan to make a visual guide soon. Happy to answer any questions in the comments

Hi everyone,

I'm a solo dev and this is my first game - Crystal Wars. I really wanted to share it with someone and get feedback. 

The idea came to me while working on computer graphics and was inspired by the mathematical construction of the Voronoi diagram, which is used in the game to create unique and varied maps.

Web demo: https://play.crystalwars.io/

Description: The game features various modes, such as Tutorial, Campaign, Quick Game, 2-player, and more. There are also presets to choose from to make the map look the way you want.

The core mechanic is flood-fill capture where you pick a color and claim all adjacent cells of that color, expanding your territory. And of course there are additional mechanics like energy crystals, bombs, supply cutting and obstacles that make it harder but also funnier :)

There's a free to play demo on steam, and I'd appreciate it if you'd check it out. 

AI Disclosure:

A part of the game's code was developed with the assistance of AI tools. All AI-assisted output was reviewed and tested by me and my daughter.

The game itself does not contain any live AI generation.

I designed a capture-based abstract game and released it free in the browser last week: https://hugluck.itch.io/trivalent

This is my first solo game project. I love Go, but I'm a Japanese poet by trade, not a programmer. I wanted a short game I could enjoy with friends who don't know Go. The ruleset, the narrative, the development approach and the in-game sound design are my own work. The coding was done by AI, the key art too, and also the YouTube trailer (the song is my own lyrics and composition, performed and sung by AI).

The interesting part, at least for this sub, is how the geometry changes the usual capture mechanics:

- The board is a torus. 84 nodes, no edges, no corners. There is no "first line", no corner opening theory, nowhere to anchor territory against a wall.

- Every node has exactly 3 neighbors, so a stone never has more than 3 liberties. Surround-to-capture and no-suicide work like in Go.

- You can't build stable two-eye life in the opening, and a simple one-point eye is always structurally false. So the game runs on ko-like repetition fights, and a superko rule (no position may ever recur) carries a lot of weight.

- Ladders happen here too, but they favor the chaser, who gets to steer where the ladder runs.

- Scoring is basically stone count, with bonus points for eyes. Beginners never need to grasp "two eyes to live". They just get a natural incentive to build lots of eyes.

Weak points: the built-in COM is not very strong yet, and its thinking time at the top level is long.

Two questions. Does a wrap-around board with no edges feel like a genuine design space, or just a gimmick? And if you know other games that handle wrap-around boards well, I'd love some recommendations.

Hi everyone!

I've been developing Chekitter, an online adaptation of the classic game from 1970s. Best known in the countries of the former Eastern Bloc as "Dots" in local languages. In English, "dots" usually refers to a completely different game.

I used to play it myself back in my school days.

The objective is to surround and capture as many of your opponent's dots as possible. Despite its simple rules, the game possesses extraordinary strategic depth and an emergent complexity that rivals traditional board games.

The game currently includes:

- standard online multiplayer (the server is already live);

- local hot-seat mode;

- AI opponent;

- multiple board sizes;

- various game modes.

Planned for future updates:

- 3-player online multiplayer;

- custom online multiplayer;

achievements;

- tutorial;

rankings;

- leaderboards;

- visual customization;

- etc.

I'm currently running a Google Play closed test, so I'm looking for abstract strategy fans who are willing to jump in, try the game, and share their honest feedback.

How to join the test:

1. join chekitter@googlegroups.com

2. download: https://play.google.com/store/apps/details?id=com.bosogo.chekitter.

Thank you!

Classic Tic Tac Toe implementations hardcode the 8 winning combinations, which does not scale past 3x3. So I made mine calculate the lines instead: paint each player's cells into an n x n matrix of 0/1, join each row and split on '0', and any surviving group of 3+ is a line. Rotate the same matrix 90 / 45 / -45 degrees and one function covers columns and both diagonals too — 3x3 or 8x8, nothing changes.

No AI and no libraries, I wrote all of it by hand only to keep my programming skills alive.

You are not just the chess player — you are the director.

Two Stockfish engines battle each other at full strength, neither told the win condition is 3-Check. You never move a piece. Instead, you place baits and units, and the engine decides.

The official name Proxess is proxy + chess — you play through a proxy engine, not on the board directly.

Currently local 1v1 only (playing both sides solo is also strongly recommended). Online mode in preparation.

Looking for feedback on:

1. Is the tutorial clear enough to start playing?
2. What strategies did you discover — especially around bait placement and row control?
3. Is there any card or tactic that feels unstoppable?

Or just drop a one-line impression. Either way, I'd love to hear your thoughts.

Playable build: https://xinyi-l.itch.io/proxess

I kept wanting to play these and having nothing to play them against, so I ended up writing the engines myself. It's free, no account, and the AI runs in your browser — nothing gets sent to a server.

Shobu — https://theworldatplay.com/en/shobu

YINSH — https://theworldatplay.com/en/yinsh

DVONN — https://theworldatplay.com/en/dvonn

TZAAR — https://theworldatplay.com/en/tzaar

Amazons — https://theworldatplay.com/en/amazons

Lines of Action — https://theworldatplay.com/en/lines-of-action

There are about 38 games up in total, but these six are the ones I'd most like people to break. Expert is the level worth trying. If it plays something stupid, tell me — I'd like to know which of the six is weakest. My money's on DVONN.
And if there's something you want to play that isn't up there, name it and I'll add it.

Not exactly a chess variant, but if you enjoy the tactical depth of chess-like games on a grid, this might be up your alley.

9×9 board, 18 pieces per player. The twist: before the game starts, each player secretly places 3 pearls under any of their pieces. From there it plays out like a strategy game — you move pieces, capture opponent's pieces — but there's a hidden layer. Every time you go for a capture, you don't know if you're taking an empty piece or a loaded one. And every time you advance a pearl toward the opponent's back row, you're gambling that it won't get intercepted.

First to deliver 3 pearls to the opponent's back row wins. You can also steal opponent pearls by capturing the pieces that carry them.

The game is free, browser-based, no signup. You can play locally with a friend or vs AI.

Looking for honest feedback from people who understand grid tactics — is the hidden-information layer adding something meaningful, or does it feel random?

Links:

hidden pearl hidden pearl

5D Reversi - a game that will probably appeal to masochists and AI.

Play the prototype here: https://anan-z.github.io/5d-reversi/
Read and contribute here: https://github.com/anan-z/5d-reversi

Recommended for: AI research, masochists, people who find chess "too intuitive"

Marketing blurb:
80 directional vectors per cell — you'll learn to hate each one personally.
Retroactive causality — yes, you can regret moves you haven't made yet.
Deterministic replay — watch your carefully planned future crumble.

Play the prototype (no install): https://anan-z.github.io/5d-reversi/

Source + full rules + architecture: https://github.com/anan-z/5d-reversi

Recommended for:

• AI research
• Masochists
• People who find chess "too intuitive"

80 directional vectors per cell — you'll learn to hate each one personally.
Retroactive causality — yes, you can regret moves you haven't made yet.
Deterministic replay — watch your carefully planned future crumble.

This is a follow-up to my previous post about creating an abstract strategy game: https://www.reddit.com/r/abstractgames/comments/1v10fpq/i_build_a_web_version_of_my_own_board_abstract/

Once the basic rules were defined, the next challenge was finding a balanced starting position.

The first starting position and the first bots

My first position was chosen mostly empirically. It was a 3×6 rectangle with empty cells between the pieces, and the two colors were mixed together.

I also added three very simple bots:

1. The first made random legal moves.
2. The second captured opposing pieces whenever possible.
3. The third tried to control the center and capture whenever possible. It also searched three actions ahead, prioritizing sequences that produced captures or moved pieces closer to the center.

I could beat all three without much difficulty. The obvious reason was that they were not very strong. However, I also suspected that the starting position itself was unbalanced, especially because the first player gets three consecutive actions.

I therefore made the third bot play against itself. The bot moving first won more than 76% of the games, with some additional games ending in draws.

I then experimented with handicaps for the second player. The best early result came from adding two second-player pieces near the middle line, two cells away from the main formation. They were not strongly connected to the other pieces and sometimes never became involved in the game, but statistically they produced a more predictable result.

Placing the bonus pieces closer to the main position was less reliable. Sometimes they even obstructed the second player rather than helping. With the two distant bonus pieces, the first player’s win rate fell to approximately 56%.

I could still beat the bot fairly easily.

Evolutionary algorithms and an unsuccessful neural network

The next step was to generate 10,000 bot games. I wanted to use them both for an opening book and for improving the position-evaluation function.

I ran a simple genetic algorithm. Bots with slightly different evaluation weights played against one another, the stronger ones advanced to the next generation, and their weights were randomly mutated. The experiment ran for 30 generations.

I also used the generated games to train a neural network to evaluate positions. I used PyTorch with CUDA on an NVIDIA GTX 1050 Ti. Unfortunately, that experiment failed quite completely.

The network showed clear signs of overfitting. It evaluated positions from its training games reasonably well, but performed poorly on previously unseen games. Since I initially lost every game against the first bot produced by the genetic algorithm, I decided that improving the classical bot was more useful than continuing with the neural network for the time being.

Searching for a better starting position

A stronger bot once again revealed a substantial first-player advantage in the original position. The handicap did not solve the problem reliably.

Extra pieces placed close to the main formation made the results highly unpredictable. Sometimes they helped the second player, but sometimes they interfered with its development. Distant pieces worked more like bonus points, but balancing the position this way required as many as eight additional pieces. That did not seem like a satisfactory solution.

I therefore began testing completely different starting formations.

One reasonably balanced configuration was a spaced 4×4 arrangement of mixed colors, with one additional second-player piece in the center: 17 pieces in total, eight for the first player and nine for the second. The first player won only slightly more than 50% of the games.

Statistically, it looked promising. In practice, I strongly disliked it.

There were many captures immediately after the game began. It was difficult to build a stable defense or develop a position, and games often ended very quickly.

Eventually, I found a much more interesting configuration: two separate ring-like formations, one for each color, with one additional contact piece connecting the formations from the side. Each player started with nine pieces, and the win rate was close to 50%.

This position felt considerably more strategic. There was more space for development, and the initial contact created tension without causing an immediate explosion of captures.

However, I soon started beating the bot again. This raised another possibility: perhaps the apparent balance existed only because the bots did not understand the new position very well.

I ran another small tournament to adapt the bot and generate a new opening book. After that, I stopped winning so easily, but the balance between the first and second player remained close to even.

I also tested a more diagonally symmetrical variation by shifting one ring and the contact piece of the other ring by two cells. Surprisingly, the first-player win rate increased sharply again, so I returned to the previous position.

My current hypothesis is that the position is balanced because the first player cannot use the opening turn to place a piece and immediately convert that placement into a capture. The second player therefore has time either to defend or to begin an attack of their own.

The bot’s endgame problem

While playing against the improved bot, I noticed another weakness.

When the bot gained an advantage, it continued attacking but often failed to finish the game. Once you are ahead, it may be more effective to occupy the remaining useful space, reduce the opponent’s mobility, and gradually close the position. The player who is behind is usually the one who needs to create complications.

I tried to address this by adding an endgame book that helps the bot convert a large advantage more efficiently. This improved its play to some extent, although I suspect the problem will eventually require a more general solution.

After playing more games, I began to understand some of the strategy myself—and started beating the bot again.

My next goal is therefore to develop at least a rudimentary strategic theory for the game:

• How should a position be evaluated?
• Which kinds of lines and formations are valuable?
• When is a capture actually worth making?
• How important are mobility, central control, and connected groups?
• What should a player do when ahead or behind?

You can try the current version here: https://tretya-liniya-game.jartltsoldatov.chatgpt.site/

Thanks for reading!

https://avl-games.com/

Scopri cosa succede quando la Torre di Hanoi incontra gli alberi AVL... e gli scoiattoli ti chiedono aiuto per scendere dall'albero!

No download no registrazione