Cracking Fallout's Terminal Hacking Minigame

Terminal, locked

Every Fallout game since 3 hides the same trick behind its computer terminals: a wall of noise text with a handful of real words buried in it, one of which is the password. Guess wrong and the game tells you how many characters matched their position in the answer, without saying which ones. Four guesses, then the terminal locks you out.

That's it. No timer, no reflexes, just deduction. It's Mastermind wearing a green phosphor CRT.

Likeness is a positional diff, not a fuzzy match

The feedback number is the easiest part of the puzzle to get wrong if you don't read the source carefully: it's not "how many of these letters appear in the password somewhere." It's a strict index-by-index comparison.

function likeness(guess, target) {
  var n = 0;
  for (var i = 0; i < guess.length && i < target.length; i++) {
    if (guess[i] === target[i]) n++;
  }
  return n;
}

Password COPY, guess COLD: C and O line up in position, so likeness is 2, even though COLD and COPY share no other letters. Guess PICK: every letter it shares with COPY sits in the wrong slot, so likeness is 0. The number tells you nothing about which letters are right, only how many slots are.

That asymmetry is what makes elimination interesting: two candidate words with wildly different letters can return the same likeness score, and two words that look almost identical can score completely differently depending on where they diverge.

Filling the noise without a real dictionary lookup

The real game pulls candidate words from a length-matched pool and drops them into the noise as horizontal runs. I did the same thing with a small thematic word list bucketed by length, so a Novice board only draws from 4-letter words and a Master board only from 7-letter words:

var lvl = LEVELS[levelIndex];
var pool = shuffle(WORD_POOL[lvl.wordLen].slice());
var chosen = pool.slice(0, lvl.numWords);
password = chosen[randomInt(0, chosen.length)];

Placement walks two parallel noise streams (the game's two columns) looking for a run of free cells that doesn't collide with anything already placed, retrying a fixed number of times before giving up on that word. Nothing fancier than that, the streams are just flat arrays of random symbols with words and bracket tokens punched into them afterward.

Bracket pairs are the escape hatch

Scattered through the same noise are stray bracket characters: (, [, {, < and their matching close. Most are singletons that do nothing, but a handful form complete pairs, and clicking a complete pair fires a bonus:

function clickBracket(token) {
  var pairTokens = bracketTokens.filter(function (t) {
    return t.pairId === token.pairId;
  });
  markUsed(pairTokens);
 
  if (rng() < 0.5) {
    attempts = MAX_ATTEMPTS; // replenish
  } else {
    removeRandomDud(); // eliminate one wrong word outright
  }
}

This is the only source of comeback in the whole system. Burn all four attempts guessing blind and you're locked out regardless of how close you were; find and click a bracket pair early and you either buy back your mistakes or shrink the candidate pool for free. Scanning the noise for brackets before guessing is the entire skill expression of the minigame.

Why this one is also just a text grid

Same reasoning as Breach Protocol: nothing here needs a renderer. Two columns of <span> runs, a handful of click handlers, and a scrolling log panel that appends a line per guess. The CRT look is a couple of CSS layers, a scanline gradient repeating every 3px and a radial vignette, sitting on top rather than baked into anything.

Play it

What I added beyond the original

The original terminal is a one-shot puzzle per location. This version is endless: six difficulty tiers step word length from 4 to 9 characters and scale candidate count and grid size alongside it, a solve advances to the next tier, a lockout resets to tier one. Score rewards both remaining attempts and solve speed, and a running "cracked" counter tracks total terminals breached across the session, same convention as the other two demos.

A few things exist purely because they made the board feel more like a terminal actually booting rather than a chunk of markup appearing:

• Row-by-row reveal. Both noise columns type themselves out left-to-right, one column fully before the next starts, instead of the whole grid materializing at once. A quiet, pitch-varied tick plays every few characters so it reads as a typewriter rather than a silent wipe.
• Keyboard navigation. Arrow keys move focus between the real words in reading order (wrapping at either end, skipping ones you've already eliminated), Enter or Space guesses whichever word is focused. Mouse clicking still works exactly as before.
• Attempts bar has weight to it. Losing an attempt punches the block down in scale with a red flash and a small screen shake, rather than just recoloring silently. A bracket-pair reset does the same in reverse, cascading green across the row.

None of that is in the original ROBCO terminal, it's just standard game-feel debt: an instant state change reads as a bug unless something acknowledges it happened.