Inspiration
I grew up on creature-collectors and always wanted to build one, but every idea I had for putting a game on Reddit felt like fighting the platform. What finally clicked was noticing that a subreddit already behaves like a game world if you squint: posts are places, comment threads are conversations, and everyone shows up on their own schedule anyway. So rather than bolting a game on top of Reddit, I tried to make the subreddit itself the game. When you publish a creature, it becomes a post. When someone fights it, the fight lands in the comments. Nobody ever has to be online at the same time as anyone else.
There was also a more personal reason. I've been a full stack web dev for years and I had never finished a game. I have a folder of prototypes to prove it. I wanted to stop being that guy.
What it does
You get Bloopies, which are clumsy little blobs you breed, raise, and battle.
Breed them. This is the actual spine of the game rather than a skin generator. Every Bloopie carries a real diploid genome: two alleles per trait, dominant and recessive expression, mutation. When you breed two of them, the child genuinely inherits one allele from each parent, which means recessive traits can hide for generations and then pop back up out of nowhere. Your best creature is one you bred yourself, not something the game handed you.
Raise them. Eggs hatch into Blooplings. If you care for one during its 24 hour imprint window (feed it, play with it, love it, clean up after it), the adult it grows into is permanently stronger. Care is always free and always works, so the daily loop never sits behind a currency grind.
Battle them. Publishing a Bloopie turns it into a challenge post that anyone can fight whenever they feel like it. Moves have types (Drippy beats Sticky beats Bouncy beats Drippy, 1.5x when you have the advantage, 0.75x when you're countered), there's an energy economy, a house gauntlet ladder, and an Elo rating underneath it all. One rule I refused to bend on: losing costs you nothing. You never lose a creature, you never lose coins. Stakes only exist for the winner.
How I built it
It runs on Devvit Web, Reddit's app platform: a Phaser 4 + TypeScript client inside a webview, a Node server, and Redis as the only durable store. Vite for bundling, Vitest for tests.
The architecture decision I'm happiest about is a seam I drew on day one: only the renderer knows what a Bloopie looks like. The genetics, the battle engine, and storage all deal purely in gene IDs. The renderer takes those IDs and composites a creature out of anchored SVG shapes at runtime. Offspring get assembled instead of picked off a sprite sheet, no two Bloopies are the same drawing, and when I decided to redo the whole art pass two days before the deadline, I didn't have to touch a single line of game logic.
The other decision the whole thing rests on is determinism. There is no Math.random() anywhere near breeding or battle. Everything goes through a seeded PRNG (mulberry32) with seeds the server derives, so the same inputs and the same seed always produce the same creature and the same fight. That property is what makes async battles fair and verifiable instead of something a client could lie about. The server is the only authority on outcomes, currency, and rating; the client renders things and asks questions, and that's it.
I built the core modules pure and test-first, with zero Devvit imports, before any of the platform wiring existed. That's honestly the only reason the genetics and battle engine were trustworthy enough to hang a whole game on. The suite ended up somewhere around 3,600 tests.
And I'll say it plainly: I built this with Claude Code as my pair. The architecture calls were mine (the renderer seam, determinism, server authority, account-scoped pets) and so was the constant fight to keep scope under control, but Claude did a huge amount of the execution: writing tests, grinding through Phaser and Devvit APIs I'd never seen before, doing review passes I wouldn't have had time for alone. Funny enough, the renderer-only-knows-shapes seam helped there too. A clean boundary turns out to be just as useful to an AI agent as it is to a human contributor. It's genuinely how one person got a game this size out the door in the time I had.
Challenges I ran into
Devvit Redis has no list operations. My unit tests were gloriously green because my fake Redis implemented lRange and friends. The real one doesn't. On the first real deploy, every single /api/me call 500'd, because an unread-count check was doing a list read on every request for every user. So the tests passed and the app was dead. There's now a rule written into the project docs: anything the fake implements that the platform doesn't is a lie waiting to happen. All list-ish behavior goes through an adapter that emulates it on storage types Devvit actually has.
A cosmetic change silently broke battle balance. I added two purely visual gene slots and, without thinking about it, put their random draws in the middle of the genome builder, above the stat roll. That shifted the whole PRNG stream. Every founder creature in the game quietly ended up with different stats, and the only thing that caught it was a fixture test I'd written months earlier. The fix was one line (draw the new genes last), but the lesson stuck with me: in a deterministic system, where you consume randomness is part of your API. There's now a comment in that file yelling at whoever adds the next gene.
The bugs a type checker can't see. My worst category of bug the whole time was wiring that compiles fine and does nothing at all. A CSS selector animating limbs that had since been renamed, so the arms just froze. An endpoint that was implemented, routed, and tested, with no code anywhere actually calling it. And my personal favorite: the onboarding tour's spotlight pointed at the creature's container element, except the container sits pinned at the edge of the world while the creature wanders around inside it, so the follow camera would drift off and the tour would proudly spotlight an empty patch of grass. Tests were green for all of these.
Shipping solo against a hard deadline. Something like twenty features landed in the final 48 hours. The urge to keep adding never went away, and the discipline I'd set early (never cut the breeding or battle cores, cut depth everywhere else) is the only reason the result is coherent instead of a pile of half-finished ideas.
Accomplishments that I'm proud of
I shipped a game. My first. Strangers on the internet can play it right now, and I've never been able to say that before.
Beyond that, the genetics are real and not just decoration. You can breed a line over generations, watch a recessive trait disappear and come back three generations later, and the game will be honest with you about why it happened. Every creature is drawn from its genes at runtime, so the thing you bred is genuinely yours and genuinely one of a kind.
And the async design works the way I hoped it would. You publish a Bloopie, walk away, come back tomorrow, and find out who fought it while you were gone.
What I learned
Devvit and Phaser were both completely new to me when this started. Coming from a CRUD and REST background, I was worst at exactly the things that make a game feel good: animation timing, camera behavior, the little squash and stretch that makes a blob feel alive. I leaned hard on what I did know (data modeling, deterministic server logic, API design) to buy myself room to be bad at the rest for a while.
The lesson I'll carry furthest is about testing. My suite was very green and very confident, and it still missed nearly every bug that actually mattered, because all of them lived in the seams: renderer to CSS, client to server, fake to real. Tests prove the thing you thought of. They can't tell you about the thing you forgot to wire up.
And the boring one: decide the hard stuff early and write down why. Every time I got tempted to break determinism, or let the client decide an outcome just this once, past me had already left a note explaining exactly why that was a bad idea. That note saved this project more than once.
Working with an AI agent taught me the same thing from another angle. It's fast, it's tireless, and it still only checks what you point it at. The bugs that survived to the last day were the ones nobody, human or machine, thought to go looking for. Good boundaries and honest tests aren't just for people anymore.
What's next for Bloopies: Breed, Raise & Battle
A real pedigree view and a breeding planner, so line-breeding toward a trait feels like a plan instead of a hunch. More world, too: the Meadow is the only location right now, and the engine already supports swapping in destination packs, so mostly I just want somewhere else to go. On the competitive side, seasons, tournaments, and a proper Featured Foe rotation would give people a reason to keep coming back. The art can keep growing as well, since the runtime compositing renderer makes new bodies, features, and patterns pure content with no engine work behind them.
And honestly, whatever players ask for. This is the first time anyone besides me will have touched it, and I'd rather build what they want than what I guessed at.
Log in or sign up for Devpost to join the conversation.