Bad End Theater

Most narrative games treat the bad ending as punishment. You made the wrong call, the screen goes dark, and the game politely suggests you load a save. Bad End Theater opens by informing you that every ending is bad, that this is not a failure state but the terms of the contract, and then dares you to do something about it.

The setup is deliberately threadbare. Four characters — an Overlord, a Hero, a Maiden, and an Underling — occupy a stage roughly the size of a shoebox. You are a bored deity in the cheap seats, and your entertainment is watching a fairy tale go wrong four different ways. Pick a protagonist, play their branch, watch it collapse. Repeat.

The developer is NomnomNami — Nami, a solo creator with a long itch.io catalog of small, queer, tightly-scoped narrative games. That pedigree matters here. This isn’t a studio product retrofitted with an experimental hook; it’s the kind of design that only comes out of one person understanding both halves of the problem, the writing and the system, at the same time. The game shipped on itch.io first, then Steam, then Nintendo Switch and Android, and it has found a large, enthusiastic audience — the kind of reception a game gets when it does exactly one thing and nails it.

Positioning-wise, it sits on the same shelf as Doki Doki Literature Club and Slay the Princess — short, structurally clever, priced low enough that the purchase decision is basically frictionless. But it’s less interested in shocking you than in making you think. The pitch is not “this visual novel has a twist.” The pitch is “this visual novel is a machine, and here are the levers.”

• Cross-Character Persistence: Choices made on one playthrough become toggleable behaviors you carry into the next. The Hero’s decision in his own route rewrites what the Maiden walks into during hers. This is the whole game.
• 40+ Endings, All Tracked: A completion grid logs every ending unearthed, converting a narrative into a checklist you actually want to fill.
• 600+ Hand-Drawn Illustrations: Nami’s pixel-and-watercolor hybrid style, backed by an original soundtrack, across roughly 16,000 words of script.
• Four Interlocking Protagonists: The Overlord, Hero, Maiden and Underling each get a full branch, and each branch is simultaneously a story and a set of variables for the other three.
• Two-to-Three Hour Complete Run: Designed to be finished, not abandoned — a single evening covers it.

The Gameplay Loop

Here’s the mechanic, stated plainly: the game is a state machine, and it shows you the state.

You finish a route. It ends badly. On the way out, the game hands you a small set of flags — things your character did — and lets you switch them on or off before the next run. Enable “the Underling ate the mushroom,” and the next time you play the Maiden’s route, the Underling behaves differently, which opens a branch that was previously closed, which produces a new ending, which yields a new flag. The loop compounds.

What makes this land is that the flags are legible. There’s no hidden affection meter, no invisible timer, no obscure “you looked at the vase on turn three” gotcha. The game hands you the dials and trusts you to reason about them. That trust is the design’s core, and it’s why the structure reads as clever rather than gimmicky. You’re not being tricked. You’re being handed a combination lock and told the tumblers are labeled.

The onboarding is quietly excellent, too. The first three or four runs feel like a linear tragedy with mild variation. By run eight, the four stories stop being four stories, and the entire game reframes itself. That shift — the moment reading becomes engineering — happens without a tutorial, a tooltip, or a single line of explanation. It’s the best thing here.

The Writing Under Pressure

Sixteen thousand words across forty-plus endings works out to a few hundred words per outcome. That constraint could have produced thin, interchangeable text. It doesn’t, mostly because Nami writes characters as behavioral rules rather than personalities. The Overlord is not “menacing”; the Overlord is someone who responds to vulnerability in a specific, predictable, escalating way. When you toggle a flag and drop that behavior into a new context, the reaction feels authored rather than combinatorial.

The tonal management deserves specific credit. The premise is bleak — this is a game where children get eaten and lovers get executed — but the register underneath is warm and frequently very funny. The cast is queer, casually and without ceremony, and the relationships are the emotional engine that makes the fortieth reset land differently than the fourth. By the time you’re hunting the one arrangement that saves everyone, you’re not solving an abstract puzzle. You’re trying to get four specific people out of a room.

Where the Puzzle Slips

The flaw is structural, and it’s real. The solution space is small enough to brute-force.

Because flags are exposed as toggles, and because the number of meaningful combinations is finite, a determined player can simply exhaust the permutation set rather than deduce the answer. The completion grid — which is otherwise a superb piece of motivational design — actively encourages this. It converts the endgame from “reason about how these four fates interlock” into “fill in the remaining squares.” The true ending frequently arrives by attrition, not by an aha.

That’s a meaningful design miss. The gap between inferring the arrangement and stumbling into it is the gap between a great puzzle and a thorough checklist, and Bad End Theater doesn’t build enough friction — no combination limit, no cost to experimentation, no soft nudge toward hypothesis — to force the better experience. A little scarcity would have sharpened the whole thing.

The second complaint is length, and it carries less weight. Two to three hours is the correct runtime for this idea. Individual routes are shallow because they have to be; depth per route would bloat the permutation math into tedium. The game is short in the way a good short story is short. If you want forty hours, this was never the product.

Nami’s art is the reason this doesn’t read as a systems demo. The pixel-and-watercolor blend shouldn’t work — hard-edged sprite work against soft, bleeding color fields is a genuine clash — and instead it produces something that looks like a storybook someone drew on a Game Boy. Character sprites carry an enormous amount of expressive load with very few pixels; a two-frame reaction shot does work that a fully-voiced 3D cutscene often fumbles.

600+ illustrations in a two-hour game is an absurd asset density, and it shows. Scenes rarely reuse the same beat twice, which matters enormously when the design asks you to replay the same encounter six times. Repetition is the mechanic’s biggest risk, and the art budget is what neutralizes it.

The soundtrack is understated and does its job — mood-setting rather than attention-seeking, with enough variation that looping shouldn’t grate over multiple runs.

Technically, the design is well matched to its engine. A game of this scope is light on hardware, and the loop depends on instant scene transitions — a two-second load between attempts would have made the whole structure feel like a chore. Fast-forward and skip-read functions are present, which is exactly what a replay-driven game needs.

Steam (PC): The definitive version. Mouse input suits the toggle screen, where you’re scanning a list and flipping switches, and a large display lets you see the entire completion grid at once — genuinely useful for planning your next run. If you intend to actually reason your way to the true ending rather than grind it, play here.

Android: The surprise winner for a certain kind of player. Tapping to advance dialogue is the most natural input this genre has ever had, and the two-to-three hour runtime maps perfectly onto a commute or two. The compromise is the toggle screen: on a phone, the behavior list requires scrolling, so you lose the at-a-glance overview that makes the puzzle tractable. Expect more trial and error here — the interface nudges you toward brute force.

Nintendo Switch: Handheld mode is a fine match for the game’s pacing. The friction is navigational — moving a cursor through a grid with a stick or d-pad is inherently slower than pointing at it, and you’re going to visit that grid dozens of times. It’s a papercut, not a wound, but the PC version’s directness is missed.

Bad End Theater does something rare: it takes a genre convention everyone accepts — the bad ending as failure — and rebuilds the entire game around treating it as raw material. The result is short, cheap, dense, and much smarter than its shoebox stage suggests.

It isn’t flawless. Exposing the flags as toggles is the design’s greatest strength and its most real weakness; the same transparency that makes the puzzle reasonable makes it exhaustible. A version of this game with tighter constraints on experimentation would be a stone classic instead of merely very good.

The writing is good, the art is better, the structure is the thing you’ll actually tell people about, and the asking price is roughly what a coffee costs. We recommend it without hesitation: buy it, block out an evening, and try to save all four of them before you start flipping switches at random.

You will start flipping switches at random. That’s the one battle the game loses.