home
Live voting
OBS output
Add the overlay in OBS
flowchart

About the project

Inspiration

Everyone has had those five minutes where nothing is going on and nothing sounds fun. You scroll, you put the phone down, you pick it up again. DareLoop started from that feeling. Boredom is really just unused energy, and Twitch chat is a crowd of people with plenty of energy and no good outlet for it.

The idea: turn "I'm bored" into "I dare you." Dare your favorite streamer to do something fun and silly. Dare your friends. Dare yourself. Let a group vote on what happens next, so the choice is shared and the result is a surprise to everyone, including the person doing the dare. Whether or not you're streaming, a dare gives a dull five minutes a shape: a choice, a countdown, a bit of suspense and a story to tell afterward.

Chat voting on a streamer's next move is a familiar and loved part of stream culture, but the tools for it are often chaotic. We wanted a version where the person on camera feels safe enough to say yes to the fun. So one design principle came before everything else: the streamer stays in control. Chat votes, but the streamer writes/or AI agent can write it using different scenarios and location(prototype) the dares, approves every option and decides when (or whether) to start. Nothing starts automatically, and any dare can be skipped. That is what keeps it playful instead of pushy.

What it does

DareLoop is a local streamer dashboard with Twitch chat voting and a transparent OBS overlay. It is a companion web app and OBS Browser source, not a Twitch Extension and not a replacement for OBS. Viewers install nothing; they just use normal Twitch chat.

A round works like this:

The streamer signs in with Twitch and creates a DareLoop session.
They write their own dares (title, instructions, category and a duration from 30 to 1800 seconds), save each draft and explicitly approve it.
They pick two or three approved dares as the next vote choices and open voting.
Viewers type !vote 1, !vote 2 or !vote 3 in the streamer's chat.
The server closes voting after 60 seconds, or the streamer closes it early.
The winning dare appears on the overlay and waits for the streamer to press Start challenge.
The dare runs on a countdown. The streamer marks it complete or skips it, then opens the next round.

Along the way:

Participation points and a leaderboard. Each viewer who takes part earns one point per round, and a per-session leaderboard shows the top participants by their Twitch display names. Changing or repeating a vote doesn't earn extra points.
A transparent 1920×1080 OBS overlay showing the choices, live totals, the winner, the dare instructions and the remaining time, laid over the streamer's own camera or gameplay.
Secure overlay links. OBS can't log in to Twitch, so the overlay uses read-only, session-scoped links that expire after 12 hours and can be rotated or revoked.
A no-account demo mode. Anyone can clone the repo and try the full loop with simulated chat. No Twitch account, database or credentials are needed.

How we built it

Backend. A Python API organized into focused services: sessions, challenges, voting, scores, accounts and overlays. The demo mode runs on the standard library alone, so there's no package manager or build step to get in the way of trying it.

Twitch integration. Sign-in uses Twitch OAuth with the creator's user:read:chat permission, so no separate bot account is needed. Chat arrives through server-side EventSub WebSocket ingestion from the creator's own channel. Twitch tokens are encrypted at rest with Fernet, validated on use and refreshed automatically. The app reads chat and never posts to it.

Persistence. PostgreSQL stores challenges, approvals, votes, rounds, scores, timers and the encrypted Twitch connection. A restart in the middle of a session doesn't lose anything, and migrations keep the schema reproducible. A memory-backed repository powers the demo, so both modes share the same domain logic.

Frontend. A static dashboard and a separate overlay page, both served by the same server on one port. Both poll the server for snapshots about once per second, which kept the front end simple and the dashboard and overlay always consistent with each other.

Testing. A suite of 179 tests covers domain rules, HTTP behavior, persistence (against a disposable PostgreSQL database), Twitch fixtures and the overlay's front-end logic. We also checked the real thing by hand: real Twitch sign-in, real chat votes, custom dares and the overlay running in OBS. It's a local prototype and we don't claim production load testing.

AI-assisted development. We used Codex throughout to build and iterate on the front end, server lifecycle, persistence, Twitch integration, custom challenges, OBS access, tests and documentation. AI generation of dares is not part of the product itself yet; Codex helped us build the project, not write the dares.

Challenges we ran into

Fair voting from live chat. Chat is noisy. Twitch can deliver the same event more than once, people change their minds mid-vote, and some will spam. We settled on one current vote per Twitch identity per round, let a changed vote replace the earlier one, and deduplicated deliveries. Points go out once per participant per round, so spamming gains nothing and the totals can be trusted.

Making time trustworthy. Browser timers drift, tabs sleep and pages refresh. We made the server the authority for every deadline: the 60-second vote, the dare countdown, pause and resume, and early close all run from server-side deadlines that survive restarts. The dashboard and overlay just display what the server says, so they can't disagree.

Staying connected to Twitch. Real connections drop. We had to handle EventSub reconnects, expired and refreshed tokens, and show clear connection states so a streamer knows whether chat is actually being heard (the dashboard waits for "Twitch chat connected" before you start). Twitch doesn't replay messages missed during a hard outage, so we documented that limit plainly instead of hiding it.

Keeping unapproved content off stream. A half-written or rejected dare must never reach the broadcast. The overlay only ever receives approved, session-scoped data, and unapproved text is excluded at the server. Saving a new draft also can't change a round that is already open.

Securing a link that can't log in. The overlay is a capability URL, so we treated it like a secret: read-only, time-limited, replaceable, revocable, and automatically invalidated when the session ends or Twitch disconnects. The repo is set up so credentials, databases and live overlay links never get committed.

Scoping honestly. There's a lot we wanted to include and chose not to ship half-built: AI dare generation, automated moderation, viewer-submitted dares, a WebSocket browser feed. Instead we shipped a smaller core that works, and listed the rest as known limits in the docs.

What we learned

Real-time features are mostly about edge cases: duplicates, reconnects, restarts, expired credentials and clock drift. The happy path is the easy 20%.
A human approval step in front of crowd-driven content makes the whole experience safer and more fun. Streamers say yes more readily when they know nothing surprising can happen.
Server-authoritative state simplifies everything downstream. When the server owns the truth, the dashboard, overlay and tests all become easier to reason about.
A demo mode built early pays off. It made the project easy to test, easy to share and easy to show without anyone needing accounts or credentials.
Working with an AI coding assistant went best when we gave it clear boundaries and tests to satisfy, and verified the real integrations ourselves.

What's next

Browser WebSocket updates instead of once-per-second polling.
Dares beyond streaming: group dares with friends, dares you set for yourself, and shared voting for any group, whether or not a stream is running.
Viewer-submitted dares, with moderation so the streamer's approval step stays the final gate.
AI-assisted dare ideas and automated moderation, always with the streamer in control.
Edit and delete for saved dares, and richer leaderboards across sessions.
Multi-creator hosting with public HTTPS deployment, rate limiting and broader load testing.