This is a submission for the June Solstice Game Jam.
Governance Drift: Solstice Protocol
What I Built
I built a small terminal game called Governance Drift: Solstice Protocol.
The idea started with a question that kept bothering me:
What happens when governance isn't a document anymore?
Most systems have policies, rules, standards, and oversight mechanisms, but they usually exist outside the thing they're governing. They sit in PDFs, compliance decks, audit reports, and meeting notes.
I wanted to see what governance would look like if it lived inside the runtime itself.
So I built a game where governance becomes part of the gameplay.
You are responsible for keeping a system stable as behavioral drift increases over time. Random system events create pressure, continuity begins to erode, escalation levels rise, and eventually you're forced to decide whether to keep operating or activate Stop Authority and shut everything down.
The goal is simple:
Survive until the Solstice without losing control of the system.
Every choice changes the governance state, and every governance state becomes evidence that can later be replayed and audited.
Video Demo
2484.mp4 - Google Drive
drive.google.com
Short gameplay demonstration recorded directly in Termux on Android, showing runtime governance events, player interventions, telemetry generation, and replay-based audit reporting.
The game runs entirely in a terminal.
Every turn the system generates new governance conditions. Sometimes it's manageable. Sometimes the system throws events like:
- TELEMETRY_LOSS
- DRIFT_SPIKE
- AUTHORITY_CONFLICT
- AUDIT_FAILURE
You respond by monitoring, intervening, or shutting the system down.
What makes the game interesting to me is that every decision leaves evidence behind.
The session isn't just played.
It's recorded.
Every decision is written to a JSONL telemetry stream and can later be replayed to reconstruct the governance history of the session.
What makes the game interesting to me is that every decision leaves evidence behind.
The session isn't just played.
It's recorded.
Code
Repository:
https://github.com/Hollow-house-institute/Governance_Drift
The entire project was built in Termux on Android using Python.
No game engine.
No graphics framework.
Just gameplay, telemetry, replay, and governance logic.
How I Built It
The game started as a very small experiment.
Originally it only tracked drift and continuity.
Then I started asking:
What if governance events were recorded?
What if those events could be replayed?
What if the game could generate its own governance report after the session ended?
That eventually led to three pieces:
The game itself.
A telemetry layer that records every governance decision as JSON events.
A replay engine that reconstructs what happened after the game ends.
During a session the player might encounter something like an authority conflict or audit failure. The game records the event, records the response, and records the resulting governance state.
Afterward I can replay the entire session and produce a report showing:
- how many governance events occurred
- highest observed drift
- continuity degradation
- escalation state
- whether Stop Authority was triggered
- final outcome
That replay capability ended up becoming my favorite part of the project because it turns gameplay into evidence.
Screenshots
Runtime Governance Event
A system-generated authority conflict pushing escalation into a high-risk state.
Governance Replay Report
The replay engine reconstructing the session from telemetry.
Governance Telemetry
The raw governance events generated during play.
Prize Category
Best Google AI Usage
AI helped me iterate on mechanics, telemetry design, replay logic, and governance event structures while building the project.
The final implementation and testing happened directly in Termux.
Why the Solstice?
The solstice marks a boundary condition. A transition point.
I liked the idea of treating governance the same way. Systems often look stable until they reach a threshold where accumulated drift, unresolved conflicts, telemetry failures, or audit gaps suddenly become visible.
In Governance Drift: Solstice Protocol, the Solstice acts as a survival horizon. The challenge isn't maximizing points. The challenge is maintaining governance continuity long enough to reach a critical transition without losing control of the system.
Every session becomes a small experiment in operational governance under pressure.
Final Thoughts
Most games track health.
This one tracks governance.
I wasn't trying to build a realistic governance simulator. I was trying to explore a different idea:
What if governance wasn't something you checked after a system failed?
What if it was something you could see happening while the system was running?
That's what Governance Drift became.
A tiny experiment about drift, accountability, intervention, and knowing when it's time to hit the stop button.
Time turns behavior into infrastructure.
Top comments (0)