Introducing Droprunner

The idea for this game started with Triple Triad–the card game buried inside Final Fantasy, back when that meant a PlayStation and a CRT television. The core mechanic always struck me as quietly brilliant: play a card, compare edges, flip what you beat. Simple enough to learn in thirty seconds, but meaningful enough to anchor a much bigger game around it. I was always shocked that nobody ever built a larger game around it (or maybe they did, but it never surfaced to me–did this happen? Should I stop?! Tell me now!!)

Decades later, here we are. Droprunner is a cyberpunk tile-laying strategy game where two hackers–runners–compete to take control of a server node, one drop at a time.

The DNA

Three things fed into Droprunner’s design, and they’re probably not surprising if you’re the kind of person who reads indie game dev blogs.

First: Triple Triad’s edge-comparison mechanic. Solid foundation, but in its original form it’s a bit too deterministic. Once you know the optimal placements, the puzzle is solved. We wanted that core but with more room to improvise–and a board bigger than 3x3.

Second: cyberpunk RPGs. I played a lot of Shadowrun and Cyberpunk 2020 back in the day, and I was always drawn to the decker/netrunner fantasy–jacking into a system and fighting for control in a digital space. The aesthetic, the vocabulary, the tension of being somewhere you shouldn’t be. Sadly, playing the decker kinda sucked for the rest of the group, because you ended up having your own sub-game while everyone else just twiddled their thumbs.

Third: Android Netrunner. To this day one of the best card games ever made, and arguably the closest anyone’s come to capturing what it feels like to be a hacker in a cyberpunk world. But it got retired, which is a tragedy for a different blog post. And the more I thought about it, the more I realised that Netrunner was really about roleplaying a hacker–the bluffing, the economy, the cat-and-mouse, meatspace. It didn’t capture the actual doing of it. The hands-on-keyboard, I’m-modifying-code-on-the-fly part. Also, you had to play as the Corporation half the time, which–look, I get it mechanically, but I want to be the cool hacker, not the suit.

Droprunner sits in the gap between these. Triple Triad’s elegance, Netrunner’s fantasy, and an answer to the question: how do you make a video game that makes you feel like you’re hacking?

The Basics

A run (match) plays out on a server node–a grid of cells. Each runner has a rig loaded with drops (programs), mods (behaviour modifiers), and sideloads (one-shot special programs). You take turns rezzing drops onto the node. Each drop has four edge values, 0 to 9. When your drop lands next to an opponent’s, the touching edges go head to head. Yours stronger? You jack it–flip it to your side. When both runners are out of RAM (the resource budget, measured in Teracubes), the run ends. Most drops on the board wins.

If that sounds like Triple Triad with a cyberpunk skin, it is–for about the first five minutes of your first game. Then the mods kick in.

Mods: the Bit That Makes It Droprunner

Here’s the design question that kept us up at night: in a cyberpunk world, what separates a script kiddie from a real hacker? The hacker modifies their tools. They don’t just deploy code–they reshape it to fit the situation in front of them.

That’s what mods are. When you rez a drop, you can attach up to two mods that fundamentally change what that drop does. A Daemon drains your drop’s other edges to supercharge one direction–you’re punching through a specific wall. A Worm triggers chain captures that ripple across the board. A Rabbit spawns smaller programs (Kittens–because yes, baby rabbits are called kittens) around the parent tile. A Killer doesn’t just capture enemy programs, it deletes them from the server entirely.

The critical thing is that mods aren’t pre-baked. You’re not playing a card that happens to have an ability printed on it. You’re choosing, in the moment, how to modify your program before you deploy it. This is the closest I’ve come to the feeling of actually being a decker in a cyberpunk world–adapting your code on the fly, reading the server state, and making a judgment call about what this particular program needs to do right now.

The Tetris Lesson

Early in development, we had a different idea for how to differentiate Droprunner from its Triple Triad roots. Bigger tiles. 2x1s, 2x2s, L-shapes–programs that took up real estate on the board and created spatial puzzles about where things could fit. It seemed like a natural way to add depth and we were excited about it.

It was terrible.

The moment we added rotation mechanics, the game stopped being about reading edges and hacking a server and started being about fitting shapes into gaps. We’d accidentally cross-bred our cyberpunk strategy game with Tetris, and it turns out the game really didn’t want that. The fun drained out of it almost immediately.

So we killed the big tiles and went back to the drawing board. And that’s actually how mods came into their own–we needed another axis of complexity that wasn’t spatial. Instead of making tiles bigger, we made them smarter. Rabbit solves the “I want board presence” problem by spawning extra tiles around it. Domino solves “I want reach” by chain-capturing in a straight line. The spatial depth we wanted was there, but expressed through behaviour rather than geometry.

Sometimes the best design decisions come from killing your darlings and asking “okay, but what problem was that actually solving?”

The Moment It Clicked

Given the way we build, pretty much all our games start as text and numbers. Droprunner is barely past that stage–edge values and mod abbreviations on a grid, with some free Lucide icons for the mods (so … art?). And honestly? It was pretty fun even as pure text. But the moment I knew we had something was the first time I saw multiple mods cascading on a single turn and the result surprised me.

I don’t even remember the exact board state. I just remember placing a drop with two mods attached, watching captures chain outward, triggering a reactive Hound that leapt across the board to intercept, which triggered another set of captures–and I laughed out loud. At a text-only prototype. With no art. Because the interactions were that satisfying.

That’s when the design philosophy crystallised: the mods aren’t just abilities bolted onto tiles. They’re a system. They talk to each other. And the emergent interactions between them are where the real depth lives. You don’t just learn what each mod does–you learn what they do together. Or you don’t, and you get your ass handed to you. I still have yet to beat Fintan at this game :-)

Terminology (or Is It A Deck Building Game?)

For Droprunner, the term “deck builder” is interesting–and a little misleading. This is not a deck building game like Netrunner, Magic or Hearthstone, because it’s not a deck of cards, or even a deck of tiles. What you build is your cyberdeck: you take a rig (hardware shell), and you choose which drops, mods, and sideloads you want to take in that rig based on its capacities and abilities. The sum total of all that is a deck. You’re a decker, of course you have a deck.

The thing that makes it different from a deck-of-cards kinda deck is that you won’t be drawing a hand from it. All your tools are available to you at all times. You’ll never get screwed because you drew the wrong type of card, or because your opponent top-decked into their unstoppable combo. Once you’ve built your deck, this is a game of skill on skill.

Also, the term ‘drop’ for program: we had to invent that. Turns out, despite all the slang the cyberpunk genre has generated for hackers, hardware, and the net itself, nobody ever coined a cool word for programs. So that’s our contribution to the genre, I guess. You’re welcome, William Gibson.

Where We Are Today

Droprunner has a single-player campaign, head-to-head multiplayer, a deck builder, and an AI opponent that ranges from “learning the ropes” to “genuinely threatening.” The single-player campaign functions as a way to really teach the ins and outs of the game, so that by the time you get to the main event–the head-to-head–you know what everything does. The game runs on Godot with a native C++ engine handling all the rules, and a TypeScript server wrapping the same native engine for online play.

We’re working toward a Steam release, but we’re not there yet–the game is playable and the mechanics are locked in, but there’s still polish, art, and UI work to do before we’re ready to invite the world in. If you want to follow along as we build it, come hang out on our Discord. We’re hoping to demo it for the first time at GamerFest in Dublin, May 23rd and 24th.