How does it work?

The board is a plain PHP data structure on the server: an array of 2500 strings ('dead' or a colour name like 'red', 'blue', …). An OpenSwoole timer fires every 200 ms, computes the next generation using Conway's rules, and pushes the new HTML fragment to all connected browsers via Server-Sent Events (SSE). Datastar handles DOM morphing: the browser receives ready-made HTML and surgically replaces only what changed.

No application JavaScript, no WebSocket protocol, no client-side game logic. The only JS dependency is the 12 KB Datastar shim that receives SSE updates and applies DOM patches; everything else runs in PHP.

A look at the code

The full example is ~215 lines of PHP. Here are the most interesting parts:

1. Global state inside the OpenSwoole worker

OpenSwoole keeps the PHP process alive between requests. That makes the static properties of the example class itself viable as shared in-memory state for all connected clients:

final class GameOfLifeExample {
    /** @var array<int, string> */
    private static array $board = [];
    private static bool  $running        = true;
    private static int   $generation     = 0;
    private static int   $sessionCounter = 0;

    /** @var array<string, int> context-id → session number (determines colour) */
    private static array $sessionIds = [];
}

No Redis, no database: process memory is the state. No separate state object needed: the class’s own static properties are the state. Works perfectly as long as all clients hit the same worker (which is always true on a single server).

2. Conway's rules in pure PHP

The logic class is completely independent of php-via and trivially testable:

private static function nextGeneration(): void {
    $size = self::BOARD_SIZE; // 50
    $next = [];

    for ($idx = 0; $idx < $size * $size; ++$idx) {
        $row = intdiv($idx, $size);
        $col = $idx % $size;
        $cell = self::$board[$idx];

        $living = [];
        foreach (self::NEIGHBORS as [$dr, $dc]) {
            $r = $row + $dr; $c = $col + $dc;
            if ($r >= 0 && $c >= 0 && $r < $size && $c < $size) {
                $n = self::$board[$c + $r * $size];
                if ($n !== 'dead') $living[] = $n;
            }
        }
        $count = count($living);
        $alive = $cell !== 'dead';

        // Survive: 2–3 neighbours / Born: exactly 3 neighbours
        $next[$idx] = (($alive && ($count === 2 || $count === 3))
                    || (!$alive && $count === 3))
            ? $living[array_rand($living)]
            : 'dead';
    }

    self::$board = $next;
    ++self::$generation;
}

When a new cell is born it inherits its colour randomly from one of its living neighbours. Player colours blend organically as generations pass.

3. Multiplayer broadcast via Route Scope

php-via distinguishes several scopes that determine who receives an update:

Game of Life uses Scope::ROUTE: the timer calls $app->broadcast(Scope::routeScope(...)) and every 200 ms all players see the same new generation. New: the timer pauses itself when no clients are connected:

self::$timerId = Timer::tick(200, function () use ($app): void {
    // pause when no clients are connected
    if (!self::$running
        || $app->getContextsByScope(Scope::routeScope('/examples/game-of-life')) === []) {
        return;
    }

    self::nextGeneration();

    if (self::isAllDead()) self::$running = false;

    $app->broadcast(Scope::routeScope('/examples/game-of-life')); // → all clients
});

4. Interaction: drawing cells

A click on the board triggers a plain GET request; no hand-written JavaScript needed:

<!-- data-on:pointerdown is a Datastar attribute -->
<div class="gol-board"
     data-on:pointerdown="@get('{{ tapUrl }}?id=' + event.target.dataset.id)">
    <div class="tile red" data-id="42"></div>
    <!-- … 2499 more tiles … -->
</div>

The server receives the clicked cell ID, draws a cross pattern (5 cells) in the player’s colour, then broadcasts to everyone. The colour is determined deterministically from the session number: COLORS[$sessionId % count(COLORS)].