Inspiration

Most Reddit games are played inside a post, but the community often remains outside the actual gameplay loop. Comments may discuss the game, but they rarely change what players experience.

We wanted to make Reddit participation part of the game itself.

ThreadRunner is a fast three-lane runner where yesterday's community decisions become today's danger. Redditors vote through comment commands, the winning theme influences the next Daily Run, and every failed attempt permanently changes the player's character.

The community shapes the run

Every failure shapes the runner

What it does

Players control a cybernetic Thread Cat running through a collapsing digital thread filled with hazards, pickups, changing environments, and a final encounter with the Watching Thread.

Three stages of the run

Thread Archive - a calm and open introduction
Comment Canyon - a denser section shaped by Reddit discussions
Open Weave - a collapsing final area leading to the boss

The Watching Thread boss

During the final encounter, players survive three readable stages:

Gaze
Grab
Collapse

After surviving the final stage, the player reaches the exposed core and defeats the Watching Thread.

Reddit community voting

Redditors influence future runs using comment commands such as:

!curse cats
!trap drama
!bless wholesome
!mutate alien

Eligible commands are processed through Reddit comment triggers. Each person's latest valid vote per category is counted, and the community result contributes to the next deterministic Daily Run.

Failure becomes progression

When a player dies, the Thread Cat fractures, reconstructs, and receives persistent mutations.

Over multiple attempts, each player develops a different runner shaped by their previous failures.

Main features

Authenticated Reddit players
Persistent profiles and mutations
Daily community voting
Deterministic Daily Runs
Run history
Leaderboard results
Desktop and mobile controls
Interactive 3D gameplay inside Reddit
Multi-stage boss encounter
Character fracture and reconstruction
Community-shaped hazard themes

How we built it

ThreadRunner was built as a Reddit Interactive Post using Devvit Web.

Frontend

The game frontend uses:

React
TypeScript
Three.js
React Three Fiber
WebGL

Backend

The server uses:

Hono
Devvit APIs
Reddit authentication
Reddit CommentCreate triggers
Redis persistence

Redis data

Redis stores:

Community voting data
Daily Run configuration
Player profiles
Persistent mutations
Completed runs
Run history
Leaderboard results

Reddit CommentCreate triggers parse supported commands, validate vote eligibility, prevent duplicate voting, and connect community participation to the Daily Run system.

The runner uses deterministic seeds so players receive the same community-shaped challenge for a given Daily Run while keeping their personal mutation history.

Challenges we ran into

The largest challenge was combining a real 3D runner with Reddit authentication, comment triggers, Redis persistence, and Devvit deployment inside one reliable interactive post.

Gameplay readability

We had to keep hazards understandable while the player was moving quickly through a visually complex 3D environment.

Reddit WebView performance

The game needed to run smoothly inside Reddit while rendering:

A procedural 3D character
Animated hazards
Environmental transitions
Particle effects
Fracture effects
A multi-stage boss

Desktop and mobile controls

The runner needed to remain playable with both keyboard and touch controls without covering important gameplay information.

Community integration

We wanted Reddit comments to be part of the real game loop rather than a decorative feature.

The final loop became:

Comments - Community Result - Daily Run - Failure - Mutation - Next Attempt

Persistent progression

Mutations needed to feel meaningful while preserving the fast restart loop expected from a runner game.

Deterministic gameplay

Community voting had to influence future runs without making the challenge unfair or inconsistent between players.

Accomplishments that we're proud of

We are proud that ThreadRunner is not only a visual prototype.

It combines the game and Reddit systems into one complete experience.

Complete gameplay loop

Redditors vote through comments
Community results influence the Daily Run
Players enter the same deterministic challenge
Failed runs create persistent mutations
The mutated character returns for the next attempt

Game systems

We built:

A playable three-lane 3D runner
A procedural cybernetic Thread Cat
Persistent character mutations
A fracture and reconstruction sequence
Multiple hazard families
Three visually distinct run phases
A multi-stage Watching Thread boss
Community voting through Reddit comments
Authenticated player profiles
Redis persistence
Deterministic Daily Runs
Mobile and desktop gameplay
Community results
Leaderboard systems

The game can be played directly as a Reddit Interactive Post without requiring a separate website.

What we learned

We learned how to build a complete Devvit Web application combining:

Authenticated Reddit users
Interactive posts
Comment triggers
Redis persistence
Daily community systems
WebGL gameplay

We also learned that building a game for Reddit requires a different approach from building a traditional standalone game.

Reddit-native design requires

Short and repeatable play sessions
Immediate restarts
Clear mobile presentation
Community participation
Persistent social progression
Gameplay that is understandable inside a post

Most importantly, we learned how to turn Reddit comments from passive discussion into an input for the game world.

What's next for ThreadRunner

The next version of ThreadRunner could include:

More community-controlled themes
Additional bosses and attack patterns
Deeper mutation combinations
Seasonal Daily Runs
Stronger mobile optimization
Social comparisons between mutated runners
Expanded leaderboards
More detailed community statistics
An endless post-boss mode
A damaged Watching Thread that continues to pursue the player
Different subreddit-specific game worlds

Our long-term goal is to let every subreddit develop its own evolving version of ThreadRunner, shaped by its comments, failures, and community history.