Breaking on Purpose: Why Indie Devs Are Shipping Glitches as Features

There's a moment in a lot of older games — maybe you remember it — where something goes completely sideways. A character clips through a wall. Gravity forgets what it's supposed to do. An NPC starts vibrating at a frequency that feels deeply personal. And instead of quitting out in frustration, you laugh. You do it again. You start wondering how far it goes.

For decades, the industry treated those moments as failures. Patch notes existed to kill them. QA teams hunted them down. But somewhere along the way, a slice of the indie development scene started asking a different question: what if the glitch is the game?

The Accident That Became the Attraction

The conversation around intentional glitch design usually circles back to a handful of cult favorites that leaned into their own weirdness. Titles like Katamari Damacy — technically polished but built around physics behavior that felt alien and wrong in the best possible way — or Goat Simulator, which shipped with known physics bugs and sold it as comedy. These weren't accidents so much as developers recognizing that players were already having more fun with the broken version.

But the more interesting territory is what's happening now, in smaller studios and solo dev projects that are actively building glitch logic into their design documents from day one. We're talking about games where the error state isn't a bug report — it's a mechanic.

Take Katacomb Snatch, a lo-fi dungeon crawler that's developed a devoted following in part because its procedural generation occasionally produces rooms that are structurally impossible to navigate — and then rewards players who figure out how to break into them anyway. The dev, speaking to a small Discord community earlier this year, described the design philosophy simply: "I stopped fixing the weird stuff when I noticed people were speedrunning it."

That's the core of it, really. Players don't just tolerate glitches — they often prefer the emergent chaos to the intended path.

Procedural Errors as Creative Systems

One of the more technically fascinating expressions of this trend is the use of procedural generation that's intentionally under-constrained. Traditional proc-gen pipelines are built with guardrails — rules that prevent the system from producing something unplayable or incoherent. A growing number of indie devs are pulling those guardrails out and seeing what falls through.

The result is games that feel genuinely unpredictable in ways that polished titles can't replicate. When a system is allowed to fail, it produces combinations that no human designer would have approved — and sometimes those combinations are revelatory. A level that floods with the wrong enemy type. A boss encounter where the scripted behavior breaks and the AI starts doing something that feels almost sentient. A crafting system that allows you to build something the game clearly didn't intend.

This isn't laziness. Building a system that fails interestingly is actually harder than building one that fails safely. You need to understand your own code well enough to know which failure modes are fun and which ones are just frustrating. That's a design skill that doesn't get nearly enough credit.

The Player's Role in Defining 'Broken'

Here's where it gets philosophically interesting: who decides what counts as a glitch?

In traditional development, a bug is anything that deviates from intended behavior. But in glitch-forward design, the intended behavior is often to deviate. The line between exploit and feature becomes genuinely blurry. Speedrunning communities have understood this for years — entire categories of competitive play are built around physics exploits and out-of-bounds movement that developers technically never sanctioned. The community decided those things were features, and eventually, most developers agreed.

The indie scene is just formalizing what players already knew: broken systems create ownership. When you discover something weird in a game and figure out how to use it, that discovery feels like yours in a way that completing a designed puzzle never quite does. You didn't just play the game — you found something in it.

When It Doesn't Work

It's worth being honest that this approach has a real failure mode. There's a meaningful difference between a glitch that creates interesting player agency and a glitch that's just annoying. A physics exploit that lets you skip half a level is exciting. A collision bug that kills you through a wall you didn't touch is not. The difference is usually whether the player feels like they have any control over the weirdness.

Some studios have leaned too hard into the aesthetic of brokenness without doing the harder work of making it fun to interact with. Slapping a CRT filter on a game and calling it intentionally lo-fi doesn't make the bugs charming — it just makes them bugs with a vintage tint. The studios that are doing this well are the ones where the glitches feel like invitations rather than obstacles.

What This Means for the Future of Polish

The broader implication here is a quiet challenge to one of game development's most entrenched values: the idea that polish is the goal. That shipping a clean, complete, fully-tested product is the mark of professionalism.

That's not wrong, exactly. But it's increasingly incomplete. Some of the most memorable gaming experiences of the last several years have come from places where the seams are showing — where you can feel the system straining against itself and producing something unexpected. That texture, that sense of a world that doesn't quite behave, creates a kind of authenticity that no amount of playtesting can manufacture.

For indie developers working with limited resources, this is also genuinely liberating. You don't have to out-polish a AAA studio. You can out-weird them instead. You can build something that feels alive precisely because it isn't perfectly controlled.

Zero Radius Games exists because we believe the most interesting stuff happens at the edges — the places where design meets accident, where the expected breaks down into something stranger and more honest. The glitch economy is just one more reminder that the edge is exactly where you want to be.