Offscript

Your chat. Your culture. Your game. Turn community inside jokes into cooperative Twitch boss battles.

Comment

Inspiration

OFFSCRIPT transforms the recurring jokes, memes, and shared language of Twitch communities into interactive, streamer-approved cooperative boss battles. By turning ordinary chat interactions into community-driven gameplay, OFFSCRIPT makes viewers active participants in the culture they help create.

Project Description

OFFSCRIPT

Your chat. Your culture. Your game.

Every Twitch community has its own language. What if that language could become a game?

Every livestream develops a culture of its own.

There are recurring jokes, legendary chat moments, running memes, phrases that appear in every stream, and references that only regular viewers understand. These interactions are what make a Twitch community feel like a community.

But most of that culture disappears into the chat feed.

OFFSCRIPT asks a simple question:

What if your community could actually play with its own culture?

OFFSCRIPT transforms recurring Twitch chat phrases and inside jokes into interactive, streamer-approved cooperative boss battles.

Instead of imposing generic gameplay mechanics on a livestream, OFFSCRIPT builds encounters around the community's existing identity. The audience doesn't just watch the stream. It helps create the experience.

How OFFSCRIPT works

1. Discover the community's inside jokes

OFFSCRIPT listens to Twitch chat through Twitch EventSub and identifies recurring phrases and patterns.

When a phrase appears repeatedly across recent messages, OFFSCRIPT can generate a community encounter proposal.

The proposal includes evidence such as the number of matching messages, sample size, and the observed time window.

The goal is to identify the moments that make a particular community unique.

2. Let the streamer decide

Community-generated content should not automatically take over a stream.

Every proposed encounter goes through streamer review.

The streamer can review the community signal and decide whether it deserves to become a boss encounter.

Approval prepares the encounter without automatically starting the fight.

The streamer remains in control.

3. Turn community culture into boss battles

Once approved, a community phrase becomes the foundation for a themed boss encounter with its own identity, personality, dialogue, phases, and lore.

As the encounter progresses, the boss transitions through different phases based on its remaining health.

The encounter engine manages the authoritative game state, including health, participants, attacks, defensive actions, cooldowns, encounter transitions, and rewards.

4. Let viewers play through Twitch chat

Viewers participate directly through familiar Twitch chat commands:

  • !join — Join the cooperative encounter.
  • !attack — Attack the active boss.
  • !shield — Contribute to the team's defensive strategy.
  • !inspect — Inspect the encounter.
  • !lore — Discover encounter lore.

Every valid interaction updates the shared encounter state.

The dashboard and OBS overlay synchronize in real time, allowing the streamer and viewers to experience the same evolving battle.

5. Turn battles into community memories

OFFSCRIPT goes beyond a one-time chat game.

Encounter outcomes contribute to community lore and history. Victories can unlock unique rewards, while the system protects against repeatedly farming the same boss/theme reward.

The result is a growing record of the community's shared experiences.

A joke becomes a boss. A boss becomes an encounter. An encounter becomes part of the community's history.

What makes OFFSCRIPT different?

Traditional chat-controlled games generally give viewers a predefined set of actions inside an existing game.

OFFSCRIPT starts somewhere different.

The community itself helps define what the game is about.

The content is not simply controlled by chat. It originates from the language, humor, and shared experiences of the people watching the stream.

This creates a feedback loop:

Community culture → Recurring chat signals → Streamer-approved encounters → Cooperative gameplay → Shared community memories.

The result is a gameplay experience that can evolve organically with every community.

Technology and architecture

OFFSCRIPT combines Twitch integration, an authoritative game engine, and real-time communication.

  • React + Vite: Interactive streamer dashboard and OBS overlay.
  • TypeScript + Node.js: Backend application and encounter logic.
  • Express: API routes and application server.
  • Twitch OAuth: Secure authorization for Twitch integration.
  • Twitch EventSub: Receives live chat events.
  • WebSockets: Broadcasts real-time encounter updates to connected clients.
  • Encounter engine: Manages game state, player participation, boss phases, cooldowns, rewards, and encounter transitions.
  • Persistence: Stores encounter outcomes, lore, and reward history.

The backend remains authoritative over gameplay. Chat commands are validated and processed through the existing encounter engine before the resulting state is broadcast to the dashboard and overlay.

OFFSCRIPT also includes a clearly identified simulated demo mode for rehearsing encounters without depending on a live Twitch session.

Built with OpenAI Codex

OpenAI Codex was used throughout the development of OFFSCRIPT as an engineering collaborator.

We used Codex to help build and refine the full-stack architecture, implement the encounter engine, integrate Twitch OAuth and EventSub, develop the community signal detection workflow, and create the synchronized dashboard and OBS overlay.

Codex also assisted with test development, debugging, TypeScript issues, persistence, EventSub reconnection behavior, duplicate-event handling, and the staged demo experience.

Rather than using Codex only to generate isolated snippets, we used it iteratively across the product lifecycle: exploring the architecture, implementing features, reviewing behavior, debugging integration issues, and improving reliability.

The bigger idea

A Twitch community is more than a collection of viewers.

It has its own vocabulary, traditions, recurring jokes, and shared memories.

OFFSCRIPT turns those intangible elements into something people can actually interact with.

We believe the most interesting livestream experiences are not always created by adding more content to a stream.

Sometimes, the content is already there.

It is sitting in chat.

OFFSCRIPT gives it a game.

Your chat. Your culture. Your game.

Features

Core Features

Community Signal Detection

  • Identifies recurring phrases and patterns in Twitch chat.
  • Generates encounter proposals from repeated community language.
  • Displays evidence including occurrence counts, sample size, and time-window information.

Streamer-Controlled Encounter Creation

  • Streamers review proposed encounters before they become part of gameplay.
  • Approval prepares an encounter without automatically starting it.
  • Streamers retain control over encounter initiation.

Cooperative Boss Battles

  • Viewers join through Twitch chat using !join.
  • Players attack using !attack.
  • Teams coordinate defensive actions through !shield.
  • Viewers can inspect encounters and explore lore using !inspect and !lore.
  • Boss phases and dialogue evolve according to authoritative encounter health.

Real-Time Stream Synchronization

  • WebSocket-based state broadcasting.
  • Live dashboard updates.
  • OBS-compatible stream overlay.
  • Synchronized encounter health, participant activity, and battle status.

Community Memory and Rewards

  • Encounter outcomes contribute to persistent lore and history.
  • Victory rewards are protected against duplicate farming.
  • Community jokes become part of a growing shared history.

Rehearsal and Demo Mode

  • Simulated encounters allow streamers to rehearse gameplay.
  • Staged battles demonstrate multiple boss phases.
  • Simulated activity is distinguished from real Twitch activity.

Reliability and Safety

  • Twitch OAuth state validation.
  • EventSub reconnection handling.
  • Duplicate event filtering.
  • Command validation and cooldown enforcement.
  • Safe diagnostic logging.
  • Authoritative server-side encounter state.

How we built it

OFFSCRIPT was developed as a full-stack TypeScript application.

We began by designing the central interaction model: recurring community language should be able to become a streamer-approved encounter, and that encounter should be playable directly through Twitch chat.

The backend was structured around an authoritative encounter engine. Rather than allowing the frontend to independently modify game state, incoming viewer commands are validated and processed by the server.

Twitch OAuth provides authorization, while EventSub delivers incoming chat events. Recognized commands are routed into the encounter engine, which manages player participation, attacks, defensive actions, boss health, phases, cooldowns, and outcomes.

WebSockets distribute updated encounter state to the dashboard and OBS overlay so that viewers and streamers see the same battle in real time.

A separate community signal system identifies repeated phrases and generates proposals for streamer review. The persistence layer records encounter outcomes, lore, and reward history.

We also developed a simulated encounter workflow to demonstrate the complete phased battle experience independently of a live Twitch session.

Throughout development, OpenAI Codex assisted with architecture, implementation, debugging, test creation, integration refinement, and documentation. We used an iterative development process, validating individual systems with automated tests and manually testing real Twitch chat commands.

Challenges we ran into

One of the biggest challenges was coordinating multiple asynchronous systems while keeping the encounter state consistent.

Twitch chat events, game actions, WebSocket broadcasts, and encounter transitions all happen independently. We needed to ensure that every valid command updated one authoritative game state rather than producing conflicting frontend states.

Another challenge was handling the lifecycle of Twitch EventSub connections. Reconnection, duplicate messages, authorization failures, and subscription confirmation all needed to be handled carefully. We implemented event deduplication and ensured the application only reports a successful chat subscription after confirmation.

We also had to distinguish simulated gameplay from real Twitch activity. The demo experience needed to showcase boss phases without mixing simulated events into actual Twitch gameplay.

Finally, persistence required special attention. An encounter victory should not exist only as a temporary dashboard update. Its outcome, lore, and reward must be saved so that the community's history can survive an application restart.

These challenges shaped OFFSCRIPT into a more reliable system rather than simply a collection of chat commands.

Accomplishments that we're proud of

We are particularly proud of bringing together several systems into one cohesive Twitch experience:

  • Built an authoritative cooperative boss battle engine.
  • Integrated Twitch OAuth and EventSub for real chat interaction.
  • Implemented real-time synchronization between the dashboard and OBS overlay.
  • Developed community phrase detection and streamer-reviewed encounter proposals.
  • Created distinct boss phases with health-driven dialogue.
  • Implemented encounter persistence and duplicate reward protections.
  • Built a staged demo experience that can demonstrate the complete battle progression.
  • Developed automated tests covering encounter mechanics, Twitch integration, EventSub behavior, community signals, persistence, and disconnect handling.

Most importantly, we built OFFSCRIPT around a different premise: the community's culture should shape the experience itself.

What we learned

Building OFFSCRIPT taught us that creating a compelling Twitch experience involves much more than receiving chat messages and responding to commands.

Real-time applications require careful state management, reliable event processing, reconnection handling, and a clear separation between authoritative backend logic and frontend presentation.

We also learned the importance of designing for the streamer as well as the viewer. Community participation is valuable, but streamers need moderation, control, visibility, and predictable behavior.

Finally, we explored how OpenAI Codex can support an iterative engineering workflow across architecture, implementation, testing, and debugging. It helped us move from a product concept to an integrated application while allowing us to focus on the overall experience.

What's next for Offscript

We envision OFFSCRIPT evolving into a persistent community gameplay platform.

Future directions include:

  • More sophisticated community signal detection that understands context rather than relying only on phrase repetition.
  • Richer boss generation with community-specific personalities, mechanics, and lore.
  • Persistent community progression, achievements, and collectible rewards.
  • Customizable encounter difficulty and streamer-controlled game settings.
  • More cooperative mechanics and viewer roles.
  • Improved historical analytics that reveal how a community's culture evolves over time.
  • Support for more types of community-generated livestream experiences.

Our long-term vision is to make every Twitch community feel like it has its own evolving game world, shaped by the people who make that community special.

Built With

Share this project:

Updates

Submission history