Grandma's Toolchain: Meet the Devs Shipping 2025 Games on Engines Older Than Their Nieces

There's a particular sound a twenty-year-old codebase makes when it compiles. It's not a chime. It's not a celebration. It's a low, grinding hum, like a window AC unit in a Missouri August, and when Marcus Idowu hears it, he smiles.

"That's the sound of nothing between me and the metal," he says.

Idowu is the sole developer behind Kettlewick, a cozy farming-adjacent roguelike that's been quietly pulling four figures a month on Steam. It looks like it could've shipped in 2003, and that's not an accident. The entire game runs on a custom C engine Idowu started writing in his dorm room at the University of Minnesota, back when MySpace was the social network and "content patch" meant something different. He has never updated the toolchain. He does not intend to.

He is not alone, and he is not joking.

The Church of the Old Build

Spend enough time in indie dev Discords and you'll start noticing a pattern: a small, fiercely opinionated subculture of developers who treat modern game engines the way some people treat gas station sushi — with deep, earned suspicion. They build on engines that predate Steam's greenlight era, or on hand-rolled codebases with names like "SPUD" and "GRONK" that exist in one Git repo and zero documentation.

Ask them why, and you'll get a sermon.

"Unity gave me a settings menu and took my sense of direction," says Dana Whitfield, who ships puzzle games from a converted garage in Asheville using a rendering library that was old when the Nintendo DS was new. "When you write it yourself, the game can't lie to you. When something breaks, you know exactly which of your own mistakes it is. That's comforting. That's home."

There's a real philosophy underneath the stubbornness. Modern engines are marvels, but they're also black boxes the size of a Costco. Every abstraction is a promise you didn't make and can't un-make. When the engine updates and your lighting changes, that's not your bug — but it's your problem. The old-toolchain crowd has simply decided that owning their mistakes outright beats renting someone else's.

What Stubbornness Costs

Let's not romanticize this entirely. Building on ancient tech is a tax, and it's paid in hours.

Porting to consoles is somewhere between difficult and mythical. Hiring collaborators means finding someone willing to learn a codebase with no tutorials, no Stack Overflow safety net, and error messages written by a younger, angrier version of you. One developer I spoke with — who asked to be identified only as "the guy who wrote GRONK" — estimates his custom engine cost him a full extra year of development on his first commercial title.

"Would I do it again?" he asked, then thought about it. "I did do it again. Twice. So draw your own conclusions."

There's also the bus factor, which for most of these studios is a bus factor of one. Idowu's engine is understood, in its entirety, by exactly one human being. If he gets hit by a delivery van in Saint Paul, Kettlewick 2 dies with him. He's fine with this. His wife is less fine with this.

What Stubbornness Saves

But here's where the math gets interesting.

A self-written engine has no licensing fees, no terms-of-service surprises, no runtime fees that make you the villain of a news cycle. It boots in under a second. The final build of Kettlewick is 34 megabytes — small enough to email, small enough to run on the thrift-store laptop your cousin abandoned at your apartment in 2019.

And then there's the games themselves. Limitation is a design material, and these developers are working with the good stuff. Old toolchains can't render infinite particle effects, so they compose scenes like animators instead of like weather systems. They can't rely on photorealistic spectacle, so they lean on silhouette, timing, and sound — the things that actually made people fall in love with games in the first place. Scroll through the catalogs of the custom-engine crowd and you'll find a hit rate of distinctive art direction that a thousand Unity defaults can't touch.

The Last Competitive Advantage

Here's the uncomfortable truth motivating all of this: the modern indie market is a knife fight in a crawlspace. Thousands of games launch every month. Any tool available to you is available to ten thousand other people, which means any workflow built on those tools produces work that rhymes with everybody else's.

Your engine, though — nobody else has that. A weird codebase with your fingerprints all over it produces games with your fingerprints all over them. The constraint isn't a handicap. It's a signature.

Is it for everyone? Obviously not. Most developers should absolutely keep using modern tools, shipping games, and sleeping reasonably. But the old-build crowd isn't asking for converts. They're asking for a little respect.

"People think we're Luddites," Whitfield says, gesturing at a monitor running a build of her next game, gorgeous and strange and entirely hers. "We're not against new things. We're just in love with the old ones. There's a difference."

Somewhere behind her, a compiler hums like a window unit, and nothing between her and the metal makes a sound at all.