Darkgammon: Choose Your Side

This is a submission for the June Solstice Game Jam

What I Built

Play Darkgammon

Two weeks ago, I had a simple idea for a lightweight one-on-one gaming platform: choose a game, invite a friend with a link, and start playing immediately.

I began with Tic-Tac-Toe. Last week, the idea evolved into an online backgammon game built around the domain tavla.be and the Turkish wordplay “tavla.be/ni”, which is roughly equivalent to “rizz me up.”

The first version allowed players to invite each other, play a complete browser-based backgammon match, replay the game afterward, and export that replay as a shareable video.

Then I discovered the June Solstice Game Jam. Unfortunately, I found it only last night.

That meant one thing: last-day development mode activated.

Backgammon turned out to be surprisingly compatible with the solstice theme. The board contains 24 points, naturally suggesting the 24 hours of a day. Its two players move in opposite directions, much like light and darkness following each other through a continuous cycle. Pieces can be sent backward, return from the bar, travel toward their home board, and eventually leave the board altogether.

The game already felt like a struggle involving cycles, balance, setbacks, returns, and the passage of time. I only needed to bring that interpretation to the surface.

So I transformed it into Darkgammon—because, personally, I prefer the dark side 👹.

In Darkgammon, each player chooses either the Light Side or the Dark Side before entering battle. The host chooses a side, the invited player joins the opposing faction, and the backgammon match becomes one battle in the larger war between Light and Dark.

The dice introduce uncertainty, but the game is not based entirely on luck. Positioning, risk management, timing, blocking, and probability still matter. Light and Dark may be cosmic forces, but they still need a good strategy.

I also added an hourly Dark vs. Light Challenge to the home page. It shows:

• how many players have joined each side;
• how many matches each side has played;
• how many victories Light and Dark have claimed during the current cycle.

The faction challenge is connected to actual game results rather than being a separate poll. A player's selected side becomes part of the match identity, and completed games contribute to the corresponding Light or Dark totals.

The statistics are grouped into hourly cycles so the balance can repeatedly reset and form a new short-lived battle. This keeps the home page active even when a player is not currently inside a match: every completed game shifts the wider conflict between the two factions.

The result is not only a single backgammon match. Every game contributes to a larger, ongoing conflict between the two sides.

Since the entire transformation happened during the final day, some of the design ideas, mechanics, and visual experiments inevitably collided with one another. I consider this submission the first playable version of the concept rather than its final form.

Should people enjoy it, the war will continue.

Video Demo

The demo shows:

• selecting the Light or Dark Side;
• creating and sharing an invitation;
• joining a real-time match;
• playing the backgammon game;
• tracking the wider Light vs. Dark challenge;
• replaying the completed match;
• exporting the replay as a video.

Code

gokerDEV / darkgammon

Darkgammon is a solstice-inspired reinterpretation of backgammon, where two players represent Light and Dark and fight to shift the horizon in their favor.

Darkgammon 🌗🎲

Choose your side. Shift the horizon.

Darkgammon is a solstice-inspired reinterpretation of backgammon, where two players represent Light and Dark and battle for control of the board.

Built for the June Solstice Game Jam.

Play

Live game: darkgammon.tavla.be

Choose the Light Side or the Dark Side, invite an opponent, and fight through strategy, probability, timing, and a little help—or betrayal—from the dice.

Video Demo

GitHub README files do not support playable YouTube iframes. The thumbnail above opens the video on YouTube.

About the Game

Darkgammon began as a themed version of tavla.be, a browser-based real-time backgammon platform.

The project was adapted for the June Solstice Game Jam by transforming the existing game into a conflict between Light and Dark.

Backgammon already fits the theme surprisingly well:

• The board has 24 points, echoing the 24 hours of a day.
• The two players travel in opposite directions…

View on GitHub

How I Built It

Darkgammon builds upon tavla.be, the browser-based backgammon project I completed the previous week.

I used that project as the technical foundation, cloned it as a new application, and built the solstice submission around it. The original foundation provided the backgammon engine, invitation flow, real-time matches, replay system, and client-side video export.

For this challenge, I added the new Darkgammon identity and the Light vs. Dark metagame, including:

• side selection;
• Light and Dark player identities;
• a solstice-inspired visual direction;
• thematic game language;
• hourly faction statistics;
• side-based match and victory tracking;
• a new home-page experience built around the ongoing conflict.

Replay and Client-Side Video Export

One of the main features inherited from tavla.be—and the feature I find most interesting technically—is the replay and video-export pipeline.

The game stores a sequence of match states rather than recording the player's screen. After the match ends, those states can be replayed deterministically inside the browser.

For video export, the application renders the replay frames on the client, converts the visual game states into image frames, and packages them into an MP4 file using mp4-muxer.

This means the exported video is generated directly in the player's browser:

• no server-side video rendering;
• no uploaded screen recording;
• no external video-processing service;
• no waiting for a background rendering job.

The same replay data can therefore power both the interactive replay view and the shareable video output.

For Darkgammon, this also provides room for thematic exports: the replay can eventually include Light and Dark transitions, faction-specific victory messages, eclipse effects, and a final result screen showing which side claimed the match.

The application uses:

• Next.js
• TypeScript
• Tailwind CSS
• shadcn/ui
• MongoDB
• Pusher for real-time game communication
• Firebase for notifications

Every player profile also has a unique QR code. Players can share or display these codes in physical or digital spaces and receive game invitations—even from people they have never met.

For QR-code generation, I used my own library, @goker/qr-code.

The longer-term idea is to turn Light and Dark into two playful factions. Players could place their QR codes in cafés, university spaces, events, social profiles, or anywhere else they want to defend their side and challenge new opponents.

A physical QR code can begin a digital battle.

Building with Google AI

I leaned heavily on Google Antigravity while developing the challenge version. Somehow, despite the final-day rush, I still did not manage to exhaust the quota. :)

My usual AI-assisted development workflow has two stages.

First, I discuss the idea with Gemini: I clarify the concept, question weak assumptions, define the feature boundaries, and decide what should actually be built.

Then I move to Antigravity for implementation, using Gemini 3.1 Pro in Low mode to iterate across the application.

For Darkgammon, I used this workflow to:

• shape the Light vs. Dark interpretation;
• translate the solstice theme into the existing backgammon mechanics;
• plan the faction-selection experience;
• implement and refine the hourly challenge system;
• iterate on UI states and game copy;
• debug the final integration under a very limited deadline.

I still prefer creating foundational project structures myself, especially for systems such as Next.js applications. AI works best for me after I understand and control the architecture. I use it as an implementation partner rather than asking it to make every technical decision from scratch.

This project was an especially intense example of that workflow: discuss, define, implement, inspect, reject, refine, and repeat—until the final day was over.

Prize Category

Best Google AI Usage

I am submitting Darkgammon for the Best Google AI Usage category.

Google Antigravity and Gemini were central to converting an existing browser-based backgammon foundation into a distinct solstice-themed game within the final day of the challenge.

Gemini helped me explore the relationship between backgammon and the solstice, narrow the concept into a Light vs. Dark conflict, define the new features, generate and revise implementation approaches, and rapidly iterate through the finished application.

The AI is not embedded as a runtime feature inside the game. Its role was in the development process: helping turn a rough last-minute concept into a functional and playable submission.

Team

This was a solo submission.

DEV: @gokerdev

May the better side win.

Or at least roll doubles.