Eternal Threads

Most time-travel games cheat. They hand you a rewind button, let you undo the last five seconds, and call it a meditation on consequence. Eternal Threads does not cheat. Cosmonaut Studios built an actual causal engine, and then had the nerve to put a mundane domestic tragedy inside it.

The setup is clean. You are Operator 43, dispatched backward to repair a corruption in the timestream: a house fire in the North of England, May 2015, six residents dead. You cannot stop the fire. That constraint is the entire design — it’s the fixed point everything else bends around. What you can do is move through the week leading up to it, watching events replay as ghostly holographic reconstructions, scrubbing forward and backward along a branching timeline, and changing roughly a hundred individual decision points. Change one, and the ripple propagates: later scenes unlock, mutate, or vanish outright, not just for that character but for everyone entangled with them.

This was an Epic Games Store exclusive before its wider 2022 release onto Steam and Switch, which explains why a game this structurally ambitious arrived with so little noise. The split the design invites is baked in: people who come for a story puzzle find something close to unique, and people who come for a drama find the drama thin.

Positioned against Return of the Obra Dinn, Her Story, or The Forgotten City, Eternal Threads is the most mechanically ambitious of the bunch and the least dramatically sharp. It’s a small studio swinging at a genuinely hard systems problem and mostly — not fully — connecting.

• The Thread Map: A visual branching diagram of every character’s storyline, showing where each person’s path forks and which branches terminate in survival. It is the best interface object in the game — a legible, scrubable model of causality that turns an abstract mess into something you can actually reason about.
• Ripple-Effect Decision System: Roughly 100 decision points across the week, each one rewriting downstream availability. This isn’t a dialogue tree with cosmetic variance; scenes cease to exist when their prerequisites are erased.
• Six Simultaneous Survival Conditions: The win state isn’t saving someone. It’s the one configuration that saves all six housemates at once — a constraint-satisfaction problem dressed as a soap opera.
• No Combat, No Fail State: You cannot lose, only misunderstand. Progress is gated entirely by deduction and attention.
• Environmental Investigation: The house itself is the document — letters, receipts, objects, the texture of six people’s ordinary lives, most of which the game never points at directly.

The Gameplay Loop

Here’s the honest version of the loop: you walk into a room, a scene plays as translucent figures, you watch it, and at the moment of decision you choose. Then you open the thread map, see what just changed three days downstream, and go watch that.

Stated flatly, it sounds inert. And at the outset, it is inert. The onboarding friction here is real — Eternal Threads asks you to absorb six characters, a week of overlapping events, and a novel timeline interface before any of it pays off. The opening stretch is the game’s weakest, and it demands patience before the part that works arrives.

The part that works arrives when the map stops being a menu and starts being a hypothesis space. You notice that one housemate’s late-night argument only happens if another one stayed home, which only happens if a third didn’t borrow the car. You start reading the thread map the way you’d read a dependency graph — tracing backward from a death to the earliest branch point that could have prevented it, then checking whether that branch breaks someone else’s survival path. That’s the loop. It’s constraint satisfaction with a human face on it, and when a long chain finally resolves and two threads light up green at once, the payoff is legitimately excellent. It’s earned by inference, not by persistence.

The deeper trick is that the puzzle and the character work are the same object. You cannot solve the timeline without understanding who these people actually are — who’s lying about money, who’s covering for whom, whose resentment is old and whose is new. The mystery isn’t “what happened.” It’s “what were they each protecting.” That’s a smart design thesis, and the game commits to it fully.

Where It Thins Out

Eternal Threads is light on game, and that’s a fair criticism of the design. Outside of choosing at decision points and navigating the map, your verbs are walking and looking. There’s no manipulation, no tool, no systemic surface to experiment with. Across the game’s length, the rhythm of watch scene → toggle decision → watch scene again wears a groove. The middle third, once the system is grasped but before the endgame constraints tighten, is where attention goes slack.

Then there’s the writing, which is where the game falls hardest short of its system. The performances are competent and the dialogue is plausible — these sound like actual housemates in an actual shared house, with all the low-grade friction that implies. But plausible is not the same as compelling. The register stays flat across grief, betrayal, and reconciliation alike. Several characters are built from familiar parts: the controlling boyfriend, the one with the secret debt. When the game needs you to feel the weight of six deaths, it’s relying on writing pitched at the level of a decent television drama rather than a great one. That emotional flatness is real, and it’s the ceiling on the whole project.

There’s also a structural cost to the no-fail design. Because nothing is ever lost, experimentation carries no tension. The game permits brute-forcing branches by flipping decisions and checking the map — which undercuts the deduction it’s otherwise built to reward. A little friction, a limited number of timeline rewrites, an accounting of interventions, would have made the smart play feel distinct from the exhaustive one.

Interface

The thread map is the game’s best-designed object and deserves specific credit. Encoding a hundred interdependent branches into something a person can scan at a glance is a hard information-design problem, and Cosmonaut solved it with color, position, and restraint. Survival branches read instantly. Dead ends read instantly. It is the rare in-game diagram that functions as a real thinking tool rather than a lore prop.

The aesthetic is a deliberate two-layer contrast: a drab, lived-in Northern English house rendered in flat, unglamorous Unity realism, overlaid with the cool blue translucency of the holographic reconstructions. The ghosts work. A changed conversation replaying in shimmering half-presence sells the fiction of observation-at-a-distance better than any amount of exposition would.

The house itself is where the budget shows. Textures are serviceable rather than detailed, lighting is functional, and the environment art carries none of the density that makes a space like the Gone Home house feel inhabited. Character models sit just far enough into the uncanny range that facial performance does no work — a real problem for a game whose entire emotional load rides on people talking to each other.

By design, this is not a demanding renderer; a game of this scope is light on hardware, and the scene-scrubbing architecture is built for quick jumps through the week. The technical achievement here is state management, not pixels: keeping a hundred interdependent scenes coherent while you jump arbitrarily through the timeline is hard engineering, and the design is built to carry it.

On Steam, mouse and keyboard is the correct way to play. The thread map is a dense node graph, and pointing at a branch directly — hovering, comparing, jumping — keeps the interface in the realm of a tool. Free-look navigation of the house is faster with a mouse, which matters more than you’d think in a game where you’ll cross the same hallway a few dozen times.

On Switch, the tradeoff is real and mostly worth it. Driving a cursor across that map with the analog stick is slower and fiddlier than a mouse, and the map’s dense text is a genuine legibility risk in handheld mode — this is a reading-heavy game, and a small screen makes it work harder. But the format suits the content: a contemplative, no-fail, no-reflex game is an almost perfect handheld object, playable in twenty-minute slices without losing the thread, because the map is the thread. Just don’t expect the crisp interface feel of the PC build.

Eternal Threads is the kind of game more studios should attempt and fewer should ship at this exact level of polish. The central system — a hundred decisions, six lives, one correct configuration — is the real thing, not a marketing claim, and the thread map that makes it comprehensible is a small triumph of interface design. When it clicks, it produces a flavor of satisfaction almost nothing else offers: the feeling of having understood six people well enough to save them.

What it can’t quite do is make anyone care about the six as much as the puzzle they form. The drama is adequate where it needed to be devastating, and that shortfall is exactly why the recommendation here is a qualified one. As a machine, it’s remarkable. As a story, it’s ordinary. Both things are true at once, and the second is why this lands as a mixed verdict rather than an easy one.

Buy it for the structure. Stay for the moment the map turns green. Adjust your expectations for everything in between.