Symbiont: Emergent Strategy from Six Neighbours

One mechanic, deep enough to carry a game

Symbiont is built on a single idea: cells you place on a hex grid are reshaped by their neighbours. A gene that generates energy might amplify the cell beside it, conflict with a duplicate two tiles away, or chain-multiply through a line of the right partners. Every placement is a small combinatorial puzzle; every run grows into a unique organism.

That mechanic lives in one place: the SynergyEngine, the game's single source of truth. It evaluates the grid in passes — base values, self-rules, amplifiers, totals — using a small declarative rule vocabulary: conflict-if-count, per-adjacent bonuses, chain multipliers, amplification. Adding a new cell type is usually just a data entry. A genuinely new mechanic is one new match arm. That's the whole extensibility story, and it's why the game could grow to eight cell types, stacking environment mutations, and a daily challenge without collapsing under its own rules.

Balanced by simulation, not by feel

Because the model layer — grid, synergy engine, threat resolver — has zero UI dependencies, the entire game can run headless. We use that for unit tests, and for something better: a balance simulator that plays thousands of runs and reports the outcome distribution. Current tuning lands the median death around generation 13 with mutations active — a number we verified, not guessed.

The same purity enables the online layer: a Django backend with global and daily leaderboards, seeded daily challenges where every player faces the identical run, and asynchronous 'ghost' multiplayer — all fully offline-safe, because the client never needs the server to play.

Zero assets, on purpose

Symbiont ships with no art files and no audio files. Every visual is drawn in code; every sound is synthesized at runtime. Only one scene file exists in the whole project — every screen builds its own tree from script.

This is partly an aesthetic (the game looks like a living diagram), but mostly an engineering position: no asset pipeline, no binary merge conflicts, no scene-file fragility, and a tiny download that runs on low-end devices. The readability layer is deliberate too — a colorblind-safe visual language where green means synergy, red-with-a-marker means conflict, and cyan means power, so the whole game state is legible at a glance.

• ● Full roguelike meta-loop — discovery codex, achievements, cosmetics, meta-progression, and teach-by-doing onboarding — all on top of the one core mechanic.
• ● Strict layering — the view never computes synergies; the model never touches the UI. Testability was a design requirement, not an afterthought.