Forkline

One change. Two futures. A Twitch remix studio with synchronized replays and a shared author trail.

Comment

Forkline

One change. Two futures. A Twitch remix studio where one chat command changes one robot instruction, both futures replay on one clock, and every version keeps its parent and author.

Inspiration

A tiny fix can create a moment that an entire stream understands: one viewer spots it, the robot tries it, and everyone sees why it worked. Forkline makes that moment playable.

Each contribution is deliberately small—replace one instruction. The audience gets a fair side-by-side replay, an exact first changed beat, and a shared trail that the next viewer can continue. The resulting program belongs to the conversation: earlier contributions remain visible as the route improves.

What it does

Forkline is a browser-based robot remix studio connected to Twitch chat. Viewers send:

!fix 0 1 W

That command forks version 0 and replaces instruction 1 with W, a one-beat wait. F moves forward; L and R turn in place; W waits. Each command changes exactly one instruction in an existing version, creating an immutable child.

In the first challenge, the original robot reaches a closed gate on beat 3. Replacing its first move with a wait brings the remix to the same gate on beat 4, when it is open, and the remix delivers on beat 7. Both robots start in the same place and run against the same clock. A highlighted first split at beat 1, synchronized scrubbing and paired instruction strips make the cause visible.

The three original challenges cover timing, a wrong turn and a two-step cleanup. In Two cleanups, one contribution fixes the turn and a child of that version fixes the timing. The parent-and-author trail keeps both contributions; clicking any version replays it beside its immediate parent.

A replay URL or remix JSON preserves the programs, their relationships and display credits. Copy OBS URL creates a clean browser-source stage with the paired robots, instructions and credits. A live overlay can join the same Twitch channel and continue the saved round with fresh chat commands.

How it was built with Codex

Forkline was newly created on October 29, 2026, during the Codex × TwitchCon Hackathon window, with OpenAI Codex 0.163.0. The primary build thread handled the product plan, visual direction, static studio, Twitch connection and browser validation, with a parallel Codex task implementing the engine.

The implementation is intentionally compact:

  • JavaScript engine: deterministic simulation, shared gate timing, immutable forks and earliest observable difference across position, heading and status.
  • HTML, CSS and original SVG artwork: a tabletop stage with dashed blue parent routes, solid coral child routes, numbered instruction tiles and readable outcomes.
  • Native Twitch IRC over WebSocket: the page joins as an anonymous read-only guest. Viewers use their existing Twitch login to send commands in their channel. Explicit !fix messages create authored versions using Twitch user IDs; Twitch message IDs handle duplicate delivery.
  • Static deployment: GitHub Pages hosts the full studio. A static server runs the same source locally. The application requires no runtime packages, application keys, backend service or model calls.

Programs, parent relationships and display credits are saved in replay links and JSON. Raw chat and Twitch identity/message IDs stay in the running page. Fonts are bundled with their OFL licenses; the robot and map art are drawn in the source. The project is MIT licensed.

Primary Codex session ID: 01a184eb-4651-77f0-ae8f-d23ce627d44e

The public build notes identify the actual thread and implementation repair. The demonstration includes the original Codex patch and its output.

Challenges we ran into

A browser check exposed a subtle saved-replay bug. Pasting a replay URL into the same tab changed the URL hash while the old studio state stayed loaded. Codex moved replay loading into a shared function and added a hashchange listener. The same-tab replay check then passed.

Another important engineering boundary was separating an explicit viewer contribution from ordinary chat and repeated message delivery. Strict command parsing, identity-tag checks and message-ID deduplication keep a round's version IDs and author trail consistent. A rejected command leaves the existing versions intact.

Accomplishments we're proud of

  • A complete, publicly playable remix loop: one instruction, two synchronized futures, a visible cause and a shareable creation.
  • Three distinct short challenges, including a two-author chain where the final repair preserves the first contributor's work.
  • A real native Twitch read-only connection, an OBS-ready stage, same-tab replay restoration and a usable 390px mobile layout.
  • A free-to-run static project with full source, original maps and artwork, and a single runnable core check.

The core check covers all three repairs, a two-author chain, invalid commands, IRC identity tags, duplicate delivery, immutable records and the 128-version round limit. Browser validation records local repair/replay, mobile and overlay checks, a labelled synthetic IRC fixture, and a native Twitch sample receiving ordinary chat.

Evidence scope: The video shows a real Twitch connection and incoming-message counter. Its remix actions are local previews, and Rae/Sol are explicitly fictional example credits. Authored-command and duplicate-message coverage comes from the separately labelled protocol fixture and core check. Independent viewer-command playtesting is the next validation step; one reciprocal five-minute chat-test invitation is posted in the hackathon discussion.

What we learned

A replay becomes easier to understand when its two versions share a clock and its changed instruction shares the same numbered timeline. Showing the first changed beat gives the audience a place to begin their explanation; preserving the parent trail gives the next viewer a place to begin their contribution.

The build also benefited from testing one concrete interaction at a time. A saved-link check caught a real navigation defect, and a small deterministic engine made turn repairs, gate phases and multi-author continuations directly testable.

What's next

The next milestone is the invited community chat test: a logged-in viewer sends a real !fix command while Forkline listens, then we review the author credit, first-split reveal and replay together. Feedback from that round will guide refinements to the command explanation and stream pacing.

Try it

Playable: https://blucca.github.io/forkline/

Source and setup: https://github.com/blucca/forkline

For a local preview, keep version 0 and step 1 selected, then click Wait a beat and Replay together.

For Twitch, open the first challenge, enter your channel and press Listen. Listening starts a fresh round at version 0. A logged-in viewer can then send !fix 0 1 W in that channel's Twitch chat. Copy the OBS URL after choosing the challenge and round you want on stream.

To run the source locally:

python3 -m http.server 8000
# Open http://localhost:8000
node check-core.mjs

Built with: OpenAI Codex, JavaScript, HTML, CSS, SVG, Twitch IRC/WebSocket, GitHub Pages, Node.js for the core check.

Built With

Share this project:

Updates

Submission history