RAIDVERSE — Aurora Edition

Twitch chat forges a living 3D artifact in real time. Every verified contribution shapes a persistent creation designed to travel between streamer communities.

Comment

RAIDVERSE — Aurora Edition

Made together. Carried forward.

Inspiration

A Twitch raid brings viewers from one channel to another. But what if communities could carry something they created together?

That question inspired RAIDVERSE.

Most audience interactions end when a stream ends. We wanted to explore a different idea: a shared digital creation that remembers the people who shaped it and is designed to continue its journey across streamer communities.

RAIDVERSE turns chat participation into a beautiful, persistent visual experience.

What it does

RAIDVERSE allows a Twitch streamer to create a living 3D artifact that their community can evolve together.

Viewers contribute directly through Twitch chat using four elemental commands:

  • !forge light — adds radiance.
  • !forge fire — adds fiery energy.
  • !forge storm — adds electric movement.
  • !forge crystal — influences the crystalline structure.

Every accepted contribution updates the artifact's persistent state and becomes part of its history.

The streamer controls when participation begins and ends, with safeguards against duplicate events, excessive contributions and unwanted interactions.

The long-term vision is to let streamers carry the same artifact between channels through Twitch raids. Rather than starting over, the next community would inherit an evolving creation and add its own chapter.

One artifact. Many communities. A shared story.

How we built it

RAIDVERSE was developed using OpenAI Codex as a central coding assistant.

We used Codex to help plan the architecture, implement the application, connect Twitch services, develop the persistent state system, build interactive interfaces and create automated tests.

The application integrates Twitch OAuth for account authorization and EventSub for real-time chat and raid notifications.

A TypeScript-based backend processes incoming events, validates commands, protects against duplicates and stores accepted contributions.

The frontend features an interactive 3D artifact rendered with Three.js, synchronized with the application state through WebSockets.

Aurora Edition introduces a streamlined interface with clear steps: Create, Evolve and Send.

Challenges we faced

One of our biggest challenges was ensuring that real Twitch activity reliably appeared in the application.

During live testing, we discovered a synchronization issue where an older HTTP response could overwrite a newer WebSocket update, displaying an incorrect contribution count.

We investigated the event history, reproduced the issue, fixed the state synchronization logic and added regression tests.

We also worked on OAuth authorization, EventSub connectivity, secure credential management, persistent state and streamer-controlled participation.

These challenges helped us turn a visual prototype into an application with genuine Twitch integration.

Accomplishments we're proud of

  • Successfully authenticated a real Twitch channel.
  • Received and persisted genuine Twitch chat contributions.
  • Demonstrated the artifact updating its contribution count from one to two.
  • Preserved the artifact's identity and contribution history.
  • Built an original interactive 3D experience.
  • Created a streamer-friendly visual interface.
  • Passed 66 automated tests in the final reported build.
  • Documented the system and prepared a reproducible installation process.

Our live demonstration includes authenticated Twitch chat activity, not fabricated chat events.

Current limitations

The Twitch chat contribution flow has been verified with one authenticated broadcaster account.

The cross-channel raid transfer workflow has been implemented and tested in controlled scenarios, but a complete raid between two real Twitch channels has not yet been verified.

The OBS overlay is implemented, but native OBS operation has not yet been validated in a complete live demonstration.

We are explicitly documenting these limitations rather than presenting simulated behavior as verified live functionality.

What we learned

We learned that building for live communities requires more than visual effects.

Reliable events, persistence, safety controls and intuitive design are essential when real people interact with software during a stream.

Codex helped accelerate implementation, debugging and testing, while real Twitch integration exposed issues that automated tests alone could not fully reveal.

What's next

Our next milestones are completing a verified two-channel raid transfer, validating the overlay inside OBS Studio and making the experience easier for more streamers to adopt.

We envision RAIDVERSE as a new kind of shared Twitch tradition: communities creating something meaningful together and passing it forward.

RAIDVERSE is not just something viewers watch. It's something they help create.

Built With

Share this project:

Updates

Submission history