Commutchi — a Tamagotchi owned by an entire subreddit

Inspiration

Two things collided: the Tamagotchi — a genre built entirely on private responsibility — and Reddit, a place built entirely on collective behavior. What happens if you take a creature whose survival depends on constant, careful attention and hand it to a few hundred strangers who have to agree on everything?

We were also inspired by Reddit's own history of communal experiments (r/place, Twitch Plays Pokémon). The magic of those wasn't the mechanics — it was watching a crowd try to coordinate. So we designed a pet whose real game is played in the comment section.

What it does

A pet named Commutchi lives inside a Reddit post. Every 30 minutes, a voting window opens and the community decides its care: Feed, Play, or Rest. Majority wins — usually. A chaos system occasionally makes the pet ignore the community entirely, scaled by how many people are participating.

The twist: the pet's stats are completely hidden. No health bars, no numbers. Instead:

• Every player gets a vague, per-player caption — "Commutchi attempted a jump. The legs had other opinions." Could be tired. Could be underfed. Could be a lie: ~15% of captions are deliberate red herrings.
• Different players see different fragments, so no single person can diagnose the pet alone. You have to compare notes in the comments.
• A care graph — a deliberately dramatic, stock-ticker-style line — shows whether the community's decisions are trending up or down, without revealing why.

Feed it too much and it gets sick. Neglect it and it withers. Recovery demands sustained coordination: consecutive windows of rest while properly fed. The pet is simple; the community is the hard part.

How we built it

• Unity (WebGL) renders the pet, UI, and animations inside a Reddit interactive post via Devvit.
• A Hono server on Devvit owns all truth: stats, vote tallies, and window logic live in Redis, and only suggestive text and coarse visual states ever leave the server.
• Devvit Realtime pushes live vote tallies to every open client. Unity can't hold the socket itself, so the webview JS bridges messages into the game via unityInstance.SendMessage.
• Captions are generated by a seeded, deterministic system: hash of (window, username) drives pool selection, so you can't reroll by refreshing, but your neighbor sees a different line than you.
• Visual states cross the wire as salted hashes, so even DevTools snoopers get no plaintext ground truth.
• The pixel art pipeline is partly procedurally generated — tintable 9-slice buttons and a full set of comical eye-state sprite sheets (blinking, drooping, dizzy spirals, pleading puppy eyes) built from Python scripts.
• To iterate without deploying, we built a full mock server inside Unity — a test mode that simulates voting, chaos rolls, stat decay, sickness and recovery, and logs every parameter that went into each resolution.

Challenges we ran into

• Unity WebGL vs. Reddit's CSP. Newer Unity versions run their gzip decompression fallback through blob-created scripts, which Reddit's webview blocks. Diagnosing "Failed to download file" down to a Content Security Policy line was a journey; shipping uncompressed builds was the pragmatic fix.
• Hidden stats vs. playability. Our first playtests felt like voting into a void — was anything even happening? We learned to separate hiding the state from hiding the consequences: crises and recoveries are announced loudly, resolutions have visible outcomes, and the care graph gives direction without magnitude. The mystery lives in diagnosis, not in whether the game responded.
• Making captions vague but not useless. Early captions accidentally told players exactly what to do, which would have killed all discussion. Rewriting them as observable symptoms explainable by multiple causes — plus overlapping caption pools and red herrings — was as much writing craft as engineering.
• The two-clock problem. Countdown timers that trust the player's device clock drift; ours count down from two server timestamps only.

Accomplishments that we're proud of

• Real-time vote synchronization across every open client, with atomic per-window vote deduplication in Redis.
• A caption system that is deterministic, per-player, refresh-proof, and deliberately deceptive — and still funny.
• A care graph that exaggerates drama on purpose while making reverse-engineering the underlying math impractical.
• A complete in-editor mock of the entire backend, so game feel could be tuned in minutes instead of deploy cycles.

What we learned

• Server-authoritative design isn't just anti-cheat — in a game about information asymmetry, where computation happens is the game design.
• Feedback and secrecy aren't opposites. Players tolerate enormous ambiguity about "why" if you're crisp about "whether anything happened."
• Communities don't need much mechanical depth to generate drama; they need something shared, fragile, and slightly illegible.

What's next for Commutchi

• The full resolve cycle on the server — our in-editor mock is the reference implementation; porting it to the Devvit scheduler is the last load-bearing piece.
• LLM-generated captions (via Devvit's approved AI providers) — one batch of caption variants per window, woven from the pet's history and chaos events, with the deterministic system as fallback.
• Perspectives — extending per-player fragments from captions to the pet's visuals, so each caretaker sees a different side of Commutchi and diagnosis truly requires the crowd.
• Life stages — egg hatching with community naming votes, growth, aging, death, and revival. A pet that a subreddit raised, lost, and brought back.
• The medicine event — sickness as a proper community emergency with its own vote.

Built With

• claude
• unity