How One Super Metroid Guide Made Plain Text Line Up

The margin is a grid

Open an old .txt file in a terminal and the right edge is usually ragged. That uneven edge is not a failure; it is the honest shape of prose inside a grid. In monospace typography, each glyph—the drawn shape of a character—occupies the same horizontal cell. That makes programming code, tables, and old game guides dependable, but full justification, the practice of making both the left and right edges line up, becomes a stubborn puzzle.

The puzzle can be stated in one sentence: how do you fully justify monospace text without turning every gap into a canyon? Most writers do not. They accept a ragged right edge, especially in ASCII (American Standard Code for Information Interchange) files edited with old plain-text tools.

Why ordinary justification breaks

A proportional typeface lets a narrow i take less room than a wide m. A layout engine, the software that calculates where text sits, can distribute leftover width in tiny increments. On a web page, Cascading Style Sheets (CSS) can request justification, and the browser can add space at word separators or, for some writing systems, between characters. In a plain file, a space is not a visual suggestion; it is a saved character, so two spaces remain two spaces when copied, searched, or pasted elsewhere.

Right alignment only needs padding on the left. Centering becomes awkward when a line has an odd number of leftover cells because the grid has no half-space. Full justification is more conspicuous: if a line needs three more columns and has five gaps, plain text can add an extra space to only three of them, producing uneven holes. An extra cell is a large visual event when every other character is also exactly one cell wide.

Hyphenation—the practice of splitting a word at a legal point and showing a hyphen—offers book typography a useful escape. In a plain-text document, a hard hyphen becomes part of the data, which can distract the eye and alter copy-and-paste results. That leaves an unusual but powerful alternative: change the words rather than the spaces.

The line-length equation

For basic printable ASCII, each character can be treated as one column. A line with six words has five spaces between them, so its width is the sum of the word lengths plus five. One exact 32-column example is:

Samus enters the dark shaft now!
5 + 6 + 3 + 4 + 5 + 4 + 5 = 32

The final 5 represents the spaces between the six words; punctuation counts too, so now! occupies four columns. Replace dark with narrow, and the line grows by two columns. Replace enters with moves, and it shrinks by one. Every synonym becomes a layout decision.

Once a writer inserts hard line breaks—newline characters that force a new line—the geometry becomes part of the document. An edit near the beginning can push later words onto different lines, so proofreading is no longer only about grammar or facts. The writer is balancing meaning, rhythm, and a column budget at the same time.

A guide written as a layout

A striking example is an old Super Metroid speed guide associated with the handle rs1n. It was written in an ASCII editor and maintains a clean right edge across roughly 17,000 words without depending on a justification program or filling gaps with repeated spaces. The guide is still a walkthrough, but it also behaves like a hand-built text grid.

The remarkable part is not a formatting command. The work moved from typesetting—the arrangement of text on a page or screen—into composition: a shorter verb here, a different noun there, a sentence rebuilt because one extra character would not fit. One change could affect the next line, and the next, turning a paragraph into a chain of small compromises.

That is why this feels different from a program that inserts extra spaces. The margin is evidence of editorial labor. You can read the prose for its game advice, then notice that the rightmost letter keeps arriving at exactly the same place.

What a small script can and cannot solve

A few lines of code can check the arithmetic, even if the writing is harder:

def columns(words):
 return sum(len(word) for word in words) + max(0, len(words) - 1)

line = 'Samus enters the dark shaft now!'.split
print(columns(line)) # 32

This function counts the characters in the words and the spaces that separate them. It is a checker, not a novelist: it can tell whether a candidate fits, but not whether moves sounds better than enters. Python’s standard textwrap module handles the more common task of keeping lines at most a chosen width; it does not rewrite a sentence to make every line exact.

To reproduce the guide’s method, a custom tool would need to search candidate phrases, reject anything over the limit, and score awkward wording or bad line breaks. That is a constrained optimization problem, meaning the program must obey hard rules while choosing the least uncomfortable result. Dynamic programming—a technique that reuses answers to smaller subproblems—could reduce the search, but it still needs a human-shaped scoring system. Language has too many good reasons to break a rule.

Where the same constraint appears today

The same pressure shows up in a user interface (UI), the buttons, labels, and messages through which software communicates. A button may have room for twelve columns while the accurate phrase takes seventeen, and a tooltip—a small explanatory message attached to a control—may be constrained by a narrow panel. Rewriting can preserve clarity where shrinking the font or squeezing the spacing would make the interface harder to read, but cutting words blindly can remove useful context.

The lesson is not that every label should become cryptic or every paragraph should have a ruler held against it. It is that language is part of layout. Terminal dashboards, source-code comments, configuration files, and text-based games all make that relationship visible: every extra word spends space.

The Unicode catch

There is one technical catch to the little equation above. It assumes a predictable character set such as printable ASCII, spaces instead of tabs, and a known monospace font. Unicode—a standard that represents writing systems and symbols—includes combining marks that attach to a previous character, wide Chinese, Japanese, and Korean (CJK) characters, and emoji whose display width can depend on the environment.

A programming language’s string length is not always a terminal column count. Terminal software may use the Portable Operating System Interface (POSIX) wcwidth function to estimate how many columns a character occupies, and real tools still need to test how a selected font and terminal render ambiguous cases. For a reliable fixed-width document, define the width policy first: allowed characters, tab behavior, line endings, and the target display.

The Super Metroid guide works partly because it stays in a world where the grid is stable. Its magic is not a secret justification command. It is the decision to make vocabulary serve the margin without letting the margin completely take over the voice. Every clean line records a tiny edit, and plain text ends up revealing the human work that polished typesetting usually hides.