TwitchCon Odyssey

An interactive cyber-runner where Twitch chat votes live to clear hazards and reach the TwitchCon Main Stage, built end-to-end with OpenAI Codex.

Comment

TwitchCon Odyssey

Inspiration

TwitchCon celebrates the connection between streamers and their communities, yet many livestream games still treat Twitch chat as a passive side panel. I wanted to challenge that convention by asking a simple question: What if the audience became the co-pilot?

What if reaching the TwitchCon Main Stage required both the streamer's reflexes and the audience's collective decisions?

That idea inspired me to build TwitchCon Odyssey, a retro-cyberpunk cooperative runner that transforms audience participation into an active gameplay mechanic. I wanted to create more than a game that displays chat messages on screen. I wanted to demonstrate how real-time audience input could influence an authoritative game simulation, help the streamer overcome obstacles, and contribute to a shared in-game reward system.

The project also gave me an opportunity to explore a broader engineering challenge: building a reusable, deterministic, contract-driven technology foundation that could support interactive livestream experiences beyond a single game.

I used TwitchCon Odyssey as the first demonstration of that approach, bringing together community participation, game mechanics, visual storytelling, and AI-assisted development with OpenAI Codex.

What It Does

In TwitchCon Odyssey, the streamer pilots an authoritative cyber-runner along a neon highway toward the TwitchCon Main Stage. The journey passes through four sponsor-inspired landmarks that mark progress toward the final destination.

  1. Twitch Community Hub — 35%: Animated 10-bar LED visualizers, a glitch-themed stage, and a community rally point.
  2. OpenAI Codex Arena — 60%: A cascading green code-matrix waterfall and a rotating Neural Nexus core.
  3. AWS Cloud Waypoint — 80%: Server-blade monoliths with blinking network-status lights.
  4. TwitchCon Main Stage — 100%: A golden stage arch, celebratory fireworks, and a confetti-filled finish.

The environment is designed to make progress feel like a journey through a futuristic convention rather than a sequence of disconnected game levels.

Live Audience Cooperative Gameplay

I designed the core gameplay around cooperation between the streamer and the audience.

  • Real-Time Audience Voting: During 20-second planning windows, viewers can coordinate by typing clear_lane to help remove an upcoming road hazard.
  • Authoritative Quorum: The game evaluates participation against a 60% quorum threshold. When the threshold is satisfied, the hazard is dismantled before the runner arrives.
  • Shared In-Game Reward Pool: Every successfully countered obstacle contributes to a fictional reward pool.
  • 50/50 Reward Settlement: Reaching the Main Stage triggers the game's configured 50/50 reward split between the streamer and participating viewers.

These mechanics make audience participation consequential. Viewers are not merely reacting to the gameplay; their collective decisions can directly influence the outcome.

The reward system is a simulated in-game mechanic, not a real-money payment or gambling system.

How I Built It

I built TwitchCon Odyssey around a contract-driven, deterministic, and zero-dependency architecture, using OpenAI Codex to accelerate implementation and verification.

My focus was not simply to assemble a visually engaging game. I wanted to establish a reusable engineering foundation that could make interactive game behavior predictable, testable, and easier to extend.

1. Deterministic Game Kernel

I implemented a pure Python simulation engine that serves as the authoritative source of gameplay state.

The kernel manages:

  • 20 Hz physics ticks.
  • Obstacle placement and collision detection.
  • Lane boundaries and movement rules.
  • Audience voting and quorum evaluation.
  • Time-based gameplay phases.
  • Deterministic reward-pool calculations and settlement.

By keeping authoritative game logic separate from rendering and input ingestion, I created a clearer boundary between the simulation's rules and the interfaces through which players interact with it.

This separation also makes the kernel a potential foundation for other interactive experiences that require reproducible state transitions, rule enforcement, and predictable outcomes.

2. Reusable Contract-Driven Architecture

One of my primary engineering goals was to make the underlying technology reusable rather than tightly coupling every mechanic to the presentation layer.

I organized the implementation around explicit contracts and validation, allowing the game's core behavior to be developed and tested independently of its visual representation.

This approach provides a foundation for extending or replacing individual components without having to redesign the entire game.

The reusable aspects include deterministic simulation, structured audience inputs, quorum-based decisions, controlled state transitions, and automated verification.

TwitchCon Odyssey is the first application of this engineering approach, not the limit of its potential use. The same principles can support other livestream games and interactive applications in which external inputs must be evaluated against deterministic rules.

3. AI-Assisted Engineering with OpenAI Codex

I used OpenAI Codex to accelerate implementation across several technically demanding areas.

Codex assisted with:

  • Pseudo-3D road-curvature mathematics.
  • Audience-voting and quorum algorithms.
  • Contract-validation pipelines.
  • Automated test development.

Development session ID: 01a1955f-ecad-7053-a225-82baa06d86bd

My approach combined AI-assisted implementation with contract-driven design and automated verification. Rather than treating generated code as inherently correct, I used the project's test harness to verify the behavior of the implemented system.

4. Diegetic Stream Canvas Overlay

I built the visual overlay using HTML5 Canvas and vanilla JavaScript.

The presentation includes:

  • Pseudo-3D road rendering.
  • Neon glow effects and scanline shaders.
  • Twitch-inspired role badges such as [MOD], [SUB], and [VIP].
  • A dynamic 1.28× camera zoom during audience-voting phases.
  • Visual feedback designed to make audience participation noticeable without unnecessarily obstructing the gameplay.

The overlay is designed around the needs of a livestream: viewers should be able to understand when a vote is active, recognize its outcome, and see how their participation affects the game.

5. Automated Verification

I developed an automated test harness containing 140 unit and integration tests.

The tests cover critical behaviors, including voting rules, quorum calculations, collision detection, and time-dependent game mechanics.

This verification layer is an important part of the reusable technology I built. It helps turn gameplay requirements into executable checks, making regressions easier to detect as the system evolves.

The goal was to validate the behavior of the implementation rather than rely exclusively on visual demonstrations or manual playtesting.

The Reusable Technology I Built

The game is the experience people see; the deterministic, contract-driven foundation is the engineering solution I wanted to demonstrate.

I approached the project as an opportunity to build a reusable foundation for interactive applications in which multiple participants influence a shared system in real time.

The underlying engineering approach brings together five capabilities:

  1. Authoritative state management: A central simulation determines valid game outcomes instead of allowing independent presentation components to make conflicting decisions.
  2. Deterministic rule execution: Gameplay logic is separated from rendering and input ingestion, making important behaviors easier to reproduce and verify.
  3. Contract-driven development: Explicit contracts and validation help define the expected behavior of system components.
  4. Collective decision processing: Audience inputs are evaluated through defined voting windows, quorum thresholds, and resolution rules.
  5. Automated behavioral verification: A dedicated test harness checks critical invariants and helps protect the system against regressions.

These capabilities are useful beyond a cyberpunk runner. They provide a starting point for cooperative livestream games, audience-controlled experiences, interactive creator tools, and other applications that need to process shared inputs under consistent rules.

I designed TwitchCon Odyssey to demonstrate how these principles can work together in a tangible product.

The current implementation establishes that foundation within the game. Broader reuse, additional integrations, and support for other interactive applications remain opportunities for future development rather than claims about features already delivered.

Challenges I Ran Into

Stream Delay and Clock Synchronization

Livestream latency can make coordinated audience participation difficult. Viewers may see the game at different times, while their chat messages arrive at different points in the simulation.

I addressed this challenge by implementing an authoritative, phase-based interval clock with a 20-second planning phase, a 5-second resolution phase, and a 5-second reward phase.

Monotonic time anchoring helps the simulation maintain consistent timing independently of changes to the system clock.

This approach provides a predictable voting window and separates the collection of audience inputs from the resolution of gameplay decisions.

Overlay Legibility on Video

A conventional chat embed can be difficult to read on mobile devices and can obscure important parts of the game.

I addressed this through a custom canvas overlay with magnified visual elements, dynamic focus zoom, and colored role badges.

The camera zoom increases during active voting phases, emphasizing audience participation while preserving visibility of the road and the runner.

State Determinism

Rapid chat inputs can arrive close to physics updates, creating opportunities for inconsistent outcomes if input handling and simulation updates are tightly coupled.

I addressed this by separating input ingestion from physics ticks and enforcing controlled, atomic resolution of gameplay decisions.

This design helps ensure that audience participation is evaluated according to the same rules rather than allowing the order of rendering or input arrival to dictate the outcome unpredictably.

Accomplishments I'm Proud Of

  • A deterministic simulation foundation: I built an authoritative game kernel that centralizes gameplay decisions and reward calculations.
  • 140 passing tests: My automated test suite passed all 140 unit and integration tests, covering critical behaviors across the implementation.
  • A distinctive visual experience: I created a retro-cyberpunk presentation with pseudo-3D perspective, neon effects, sponsor-inspired landmarks, and synthwave-style audio.
  • Meaningful audience participation: I made chat commands part of the actual gameplay mechanics, allowing viewers to influence the streamer's progress.
  • A reusable engineering approach: I established a separation between simulation logic, audience interaction, rendering, and verification that can support future extensions.
  • AI-assisted development with verification: I used OpenAI Codex to accelerate implementation while relying on automated tests to check the resulting behavior.

The most rewarding part was connecting the visible experience to the underlying engineering. The audience sees a cooperative game, but making that experience work requires carefully defined rules, synchronized timing, controlled state transitions, and reliable verification.

What I Learned

Building TwitchCon Odyssey reinforced that cooperative livestream experiences need more than chat integration. They need clear feedback loops that connect audience actions to visible, understandable consequences.

When viewers successfully clear an obstacle, the result must be reflected in the game quickly and unmistakably. The interaction should feel like a genuine contribution to the experience rather than a message that happens to appear on screen.

I also learned the value of separating deterministic game logic from presentation and input handling. This separation makes the system easier to reason about, test, and extend.

Finally, using OpenAI Codex alongside contract-driven development and automated testing showed me how AI-assisted implementation can accelerate delivery without eliminating the need for engineering discipline. Explicit requirements and executable tests remain essential for determining whether an implementation behaves as intended.

What's Next for TwitchCon Odyssey

I see several opportunities to evolve the game and expand the reusable technology behind it.

Official Twitch Extension and Channel Points

I plan to explore native Twitch integration, including EventSub and an Extension Backend Service (EBS), to support authenticated audience events and potential Channel Points or Bits-based interactions.

These integrations would require additional implementation, platform compatibility work, and compliance with applicable Twitch policies.

Multi-Streamer Relay

I want to explore a multiplayer relay mode in which multiple creators compete or cooperate on the same highway, creating opportunities for squad-based races and tournament-style events.

Procedural Venue Tracks

I plan to investigate procedural track generation with community-voted convention themes, creator-specific obstacles, and seasonal expo events.

Reusable Interactive Game Foundation

Beyond these gameplay extensions, I want to evolve the underlying architecture into a more reusable foundation for livestream applications.

Potential areas of development include configurable gameplay rules, reusable audience-interaction contracts, additional input adapters, and standardized verification suites.

The long-term goal is to make it easier to build interactive experiences in which communities do more than watch: they participate, make decisions, and help shape what happens next.

Built With

Share this project:

Updates

Submission history