CHICKENS MUST DIE / SOURCE CODE
You bring the game ideas. I'll bring the server.
A complete starting point for your next multiplayer project. Get the Godot 4 client, authoritative Colyseus server, and backend infrastructure. Built to work together, ready for you to explore and extend.
$39 launch price All future updates included
Source code. Real development required. Poultry optional.
Godot 4 / GDScript
Input, connection, presentation.Colyseus / TypeScript
Intent in. Validated state out.Docker / PostgreSQL / Redis / RabbitMQ
The machinery keeping everything connected.v1.0 · Preparing for release
02 / LIVE DEMO
The code is real. The chickens are real-ish. Try the browser demo and see the multiplayer foundation in action.
This demo is designed for desktop play. Touch controls aren't supported yet, so grab a keyboard for the full chicken experience.
Starting the demo connects to the game host and may cache game files in your browser. It does not change your optional cookie preferences. You can stop the demo at any time. If it does not start, try a new tab.
03 / WHAT'S IN THE PACKAGE?
A working multiplayer foundation, from the game on your screen to the services running behind it. Pick a layer and take a closer look.
An authoritative Colyseus server that handles player connections, movement, collisions, game state, and more. Built with clear module boundaries, so you can extend the game without turning everything into spaghetti.
Explore the backendThe behind-the-scenes machinery: databases, caching, message queues, Docker deployment, and developer tools. Everything wired together, with room to add your own services as the project grows.
Inspect the infrastructureThe playable side of the project. A Godot 4 client with multiplayer networking, player movement, state synchronization, animations, and game UI. Explore the code, swap the chickens, and make it your own.
Meet the client04 / ARCHITECTURE OVERVIEW
Transport gets messages to the right place. Gameplay systems decide whether those messages make sense.
WebSocket messages ↓ / ↑ state patches
SERVER PROCESS / dependencies wired before listening
↳ State patches + server messages → Godot Client
05 / MULTIPLAYER BACKEND
Follow a message from the socket to the simulation. Add your rules where they belong.
01 / app / core / features
One composition root. Ordinary constructors. No DI container to negotiate with.
GameApplication constructs configuration, infrastructure, game, rate limiting, health, Colyseus, and HTTP modules.
Features depend on small interfaces. SqlQueryExecutor, RedisCommandExecutor, and EventPublisher keep concrete libraries outside domain logic.
The map loads before the first room. Failed infrastructure startup closes opened resources rather than accepting connections.
Register IGameFeature / ISystem implementations in the room runtime. InventoryModule in the developer guide is an example to implement, not a shipped inventory system.
02 / features / simulation
Position, collisions, growth, and respawn belong to the server.
Free movement normalizes diagonals and slides along walls. Grid movement validates each route and prevents diagonal corner cutting.
Map bounds, spatial buckets, and mass-aware colliders constrain movement. The position guard restores the last legal position; spawn fails explicitly if no safe point exists.
Seeds are collected once and replaced. Growth is rejected if the larger collider would overlap a wall.
The server checks mass difference, collision, room for growth, and safe respawn before committing the result. No safe respawn means no eating transaction.
03 / rooms / schema / messages
A defined contract between Godot and the room named my_room.
Create, auth, join, leave, and dispose handlers manage connections. Colyseus synchronizes players and seeds; lastProcessedSeq acknowledges processed input.
Joining sends game_config and an initial tick. Subsequent tick_sync messages carry the server tick and time.
chat_send is normalized, limited, and broadcast as chat_message. player_eaten is sent to the two affected players.
04 / Zod / rate limits
Treat input as a request, not a fact. Especially when it comes from a chicken.
A move includes seq, clientTime, and all four direction flags. Extra fields, including a client-supplied position, cause rejection.
HTTP and room auth use shared Redis limits. Movement and chat use per-client, in-memory limits, without a Redis round trip in the hot path.
Nickname validation and uniqueness operate within a room. User accounts, token authentication, and account persistence will be included in the future release.
A SMALL MESSAGE. A CLEAR BOUNDARY.
The wire format is documented. Your client and server evolve together.
Read the protocol ↗
{
"seq": 42,
"clientTime": 1789051200123,
"input": {
"left": false, "right": true,
"up": false, "down": false
}
}06 / INFRASTRUCTURE & DEPLOYMENT
The infrastructure is connected. Its boundaries are explicit. A connected database is not the same thing as a finished persistence layer.
DATABASE ADAPTER
A process-wide pg pool, generic queries, transactions, reconnect with backoff, and health checks. Ambiguous failed writes are not automatically retried.
Extension: player/domain repositories, versioned migrations, and player persistence are not implemented.
DATA + COORDINATION
An application connection for commands and shared rate limits, plus separate Colyseus Presence and Driver connections for room discovery across instances.
Boundary: multi-instance foundations, not a measured capacity guarantee. Realtime limits remain local.
EVENT PUBLISHER
A durable topic exchange and queue, persistent messages, reconnect, and publisher confirms. The EventPublisher port validates versioned JSON envelopes.
Extension: consumers, dead-letter topology, and a transactional outbox are not implemented.
LOCAL ORCHESTRATION
Compose connects the server, map compiler, PostgreSQL, Redis, RabbitMQ, and Nginx. The Dockerfile separates build, development, and production stages.
Configuration: set service credentials and environment values before running your own deployment.
HTTP + WEBSOCKET
A reverse proxy with WebSocket upgrade, forwarded headers, buffering disabled, and long-lived connection timeouts.
Configuration: proxy trust must match your deployment. HTTP and WebSocket share the application server.
OBSERVABILITY + VALIDATION
Structured JSON logs, component loggers, HTTP request IDs, and typed environment configuration. Invalid required settings stop startup.
Scope: logging and validation primitives. No hosted monitoring service is bundled.
GET /api/health checks map readiness, PostgreSQL, Redis, and RabbitMQ. It returns 200 only when all are ready; otherwise 503.
The infrastructure lifecycle closes its RabbitMQ, application Redis, and SQL resources. Colyseus owns the lifecycle of its Presence and Driver connections.
Tiled collision rectangles become validated server JSON. MOVEMENT_MODE and GRID_SIZE must match between compiler and server.
07 / GODOT CLIENT
A playable Godot 4 client built around the multiplayer server.
The structure behind the playable client: Godot scenes, GDScript components, shared managers, and the systems connecting them. Understand where things belong before adding something of your own.
Explore architectureConnection to the game server, send player input, and receive synchronized game state. There is the client-server contract, local and remote players, and the logic that keeps movement responsive while the server stays in charge.
Explore networkingThe part where the game comes alive. Player movement, character animations, interface, audio, and visual feedback turn synchronized server data into something you can actually play.
Explore gameplayReplace the chickens, redesign the interface, or extend the gameplay. Use the developer guide and code reference to navigate the project, add new features, and keep client-server changes in sync.
Start buildingDid you know? Chickens can't read.
08 / DEVELOPER EXPERIENCE
A short route from the repository to your first custom feature.
Purchase the kit and receive GitHub repository access. The exact invitation and delivery steps will be published before checkout opens.
Copy the environment template, set your own credentials, and start Compose. For a standalone server, provide all three infrastructure URLs.
Follow GameApplication to RoomRuntimeBuilder. Add a system, inject its dependencies, choose its tick order, and test the behavior.
# In the game source repository
cp .env.example .env
# Edit .env: replace service credentials first
docker compose up --build09 / RELEASES & ROADMAP
One purchase. Every future update included. The kit starts with a multiplayer foundation and grows with each release.
The first release brings together a working multiplayer game, an authoritative server, and the infrastructure behind them.
Expanding the world-building pipeline and improving the overall game experience.
More gameplay possibilities, new application systems, and further multiplayer improvements.
Expanding the architecture toward larger multiplayer worlds with more entities and more efficient state distribution.
Investigating alternative transport technologies for realtime multiplayer communication.
ROADMAP, NOT PROPHECY
This is the current development plan, not a fixed release schedule. Features may move between versions as the project evolves. Experimental technologies depend on compatibility and testing.
Buy once, get every future release for free. No upgrade fees, even if the price increases for new buyers.
10 / TECHNICAL FAQ
Specific questions. Scope-aware answers.
No. A move sends direction flags and an input sequence. The server computes position and checks collisions. Extra position fields are rejected by the strict message schema.
Yes. Compile Tiled collision data into the server map format. The current configuration uses one map ID, default. Additional maps require extending MapId, path configuration, world initialization, and room selection.
Redis Presence and Driver provide the foundations for Colyseus room discovery across instances. HTTP/auth limits are shared; movement/chat limits are local to a connection. Deployment, capacity, and load testing remain your responsibility. No player-count benchmark is promised.
It provides a pool, generic queries, transactions, reconnect, and health checks. Gameplay does not yet persist players or rooms. Domain repositories and a versioned migration runner are extension work.
It provides a durable publishing path with confirms and reconnect. It does not include a consumer, dead-letter topology, or transactional outbox. A publish example is not a complete event-processing system.
Expect to work with Godot/GDScript, TypeScript, and backend services. You'll configure infrastructure and adapt source code. This is neither a finished game nor a no-code product.
Through access to the GitHub repository. The exact invitation and delivery process will be confirmed before sales open. No account system is created on this site.
Yes. Your purchase includes all future updates at no extra cost. The launch price is shown in the offer below; the price for new buyers may increase with later releases. No release dates are promised.
Commercial use in your own games is included. The full license, including redistribution limits and any third-party asset terms, still needs to be published before purchase.
11 / GET THE SOURCE
One kit. One purchase. Build something the original chicken never saw coming.
$39launch price / one purchase
Coming soon — v1.0 is preparing to hatch.
All future updates included. Prices for new buyers may rise.