This system is 80 columns by 25 lines. Not "about 80". Not "80 on desktop". Eighty, on a phone, on a 4K panel, in a window you have dragged to the size of a business card. What changes with your screen is how large one cell is drawn, and nothing else.

That sounds like a decoration. It is closer to a constitution: almost every awkward decision in this codebase comes from refusing to break it.

What the browser wants to do instead

Every terminal library for the web is built around the opposite idea. You give it a container, it measures the container, it reports back "you have 142 columns and 38 rows", and the program on the other end reflows to match. That is correct for a terminal that hosts someone else's program.

Here there is no other program. The system is the only thing writing to the screen, so the size can be fixed and everything above it can be composed against a known width. That is why the terminal in this site is written here rather than pulled in — not because the libraries are bad, but because their central feature is the one thing that had to go.

Nothing measures text with .length

The first real casualty was string length. "日本語".length is 3, and it occupies 6 cells. "coração" measured after Unicode normalisation can be 8 code points and 7 cells. A line with colour in it —

ESC[91mRUNAWAY ESC[0m

— has fourteen characters of escape that occupy nothing at all.

So there is exactly one module allowed to reason about horizontal space, and it counts cells: grapheme clusters, East Asian widths, combining marks, and an ANSI scanner that skips what is invisible. Everything else calls it. A test fails if any composed screen exceeds cell 80, which is how a typo gets caught before it becomes a crooked box.

Three defences, because one is not enough

1. The model cannot exceed it. The screen allocates exactly 2000 cells. Writing past column 80 wraps. There is no code path that grows the grid.
2. Composition measures in cells. Every listing, every header, every piece of art is measured before it ships. The art validator refuses to build a piece 92 cells wide.
3. The renderer fits, never reflows. Playwright asserts cols === 80 and rows === 25 at 3440×1440, at 1280×720, on a tablet and on a phone.

The part that took three tries

Filling the screen is where the constraint bites. An 80×25 grid has an aspect ratio near 1.6:1; a modern monitor is closer to 1.9:1. Scale the grid until it fills the height and the glyphs come out around 38 pixels tall — legible, and absurd for reading prose. Cap the size and a wide screen shows a lot of black.

There is no arrangement that satisfies both. So the system does the honest thing: it renders at the size an 80×25 terminal has always been — 640 by 400 pixels, cells of 8 by 16 — and lets the surround be black. The frame is a hairline, so the emptiness reads as a terminal in a room rather than a page that failed to load.

It also stopped scaling with a CSS transform, which was quietly resampling every glyph. Setting the font size instead means the browser rasterises at the real size. The text got noticeably sharper the day that changed.

Why bother

Because the limit does the editing. Seventy-six usable columns is roughly the width prose wants anyway; the constraint just makes you notice. A pager forces an argument to have parts. Sixteen colours force contrast to mean something.

None of that is nostalgia. It is a set of limits that happen to produce better decisions than no limits at all.

The prompt at the bottom of this system looks like bash. It completes paths with Tab, walks history with the arrows, understands Ctrl+W, and prints no such file or directory in the right tone of voice.

It cannot run anything. There is no interpreter behind it at all.

What actually happens when you press Enter

The line is split into words, honouring quotes. The first word is looked up in a table. If it is there, that entry's function runs with the remaining words. If it is not there, nothing happens and you get a boxed notice.

That is the entire mechanism. No eval, no Function constructor, no dynamic dispatch on a string, no fallthrough to anything. Type

guest@runawaydevil:~ $ rm -rf /

and the parser produces four words, fails to find rm, and says so. |, >, && and $(...) are not operators here — they are characters that end up inside a word and get looked up like any other.

The part that is easy to get wrong

The temptation, when building something like this, is a small convenience: one command that takes an expression, or a debug hatch, or a plugin hook that takes a callback name. Each is harmless alone and each one turns a table into an interpreter.

So the rule is written as a test:

for (const name of ['eval','exec','sh','bash','fetch','curl','wget','sudo'])
  expect(findCommand(name)).toBeNull()

node exists, but it prints node status — the BBS sense of the word. The test asserts that too, because a name that looks dangerous deserves to be pinned down rather than argued about.

There is no filesystem either

~/journal/2026-08-21-eighty-by-twenty-five.md is not a path. It is a key in a tree of objects built when the site was compiled, from Markdown files in a repository. ls walks it, cat prints its contents, grep searches them. Nothing has a writer. .. cannot climb past the root, because there is no root to climb past — resolution is string arithmetic over an array.

Which means the usual questions about a web shell do not apply. There is no container to escape, no PTY to hijack, no socket to hold open, no host process that exists. The whole system is static files and a program that runs in your browser, and the worst thing a visitor can do to it is press keys.

Why keep the shape then

Because the shape is good. A directory listing is a better index than a navigation bar: it has dates, sizes, and an obvious way to look inside. grep is a better search box than a search box. And muscle memory is real — people who have typed ls ten thousand times should get what they expect.

The commands, the filesystem and the pager know nothing about the DOM. They consume key events and produce ANSI. Point that stream at a socket instead of a renderer and the same system answers a telnet call. That is not implemented and may never be, but the seam is real and it is marked.

There is nothing on the other end of this site. No database, no session store, no analytics pipeline, no consent platform, no log of who read what. Not because those were disabled — because they were never built, and there is nowhere for them to run.

That is easy to claim and cheap to check, so here is the actual accounting.

What the browser stores

Six keys, all prefixed rd.:

rd.lastVisit        the date you were last here
rd.handle           a name, if you ever set one
rd.theme            dos | amber | green | mono
rd.bootSeen         whether to play the connect sequence
rd.history          the commands you typed
rd.readerPosition   the line you left each entry on

All of it is in your browser and none of it is sent anywhere. A test fails if a seventh key appears, and another asserts the cookie jar is empty.

What the network does

One HTML page, one stylesheet, one script, one font, one JSON file. After that, a test watches every request the page makes while a session runs commands and searches — and asserts the list is empty. The terminal genuinely does not talk to anything once it has loaded.

The JSON file is the interesting one, because it used to be much worse.

Thirty-seven copies of the same thing

The shell needs the whole collection in hand whatever route you arrived on: ls is not a per-page question, and neither is search. So the payload was embedded in the page — which meant every one of the site's 37 routes carried its own copy of the same 67KB.

before   dist 3166 KB   index.html 82 KB
after    dist  490 KB   index.html 5.4 KB

Two changes. The payload became one static file that every route fetches and the browser caches once. And the plain-text field came out of it entirely — it was 30% of the bytes and it is derivable, since stripping the escapes off the rendered lines gives the same words. It gives them better, actually: grep now matches exactly what is on the screen.

The page is now smaller than most sites' cookie banners.

The feeds are the point

There are four, because different people read differently:

/feed.xml     RSS 2.0
/feed.atom    Atom
/feed.json    JSON Feed
/sfeed.tsv    sfeed's TSV, for reading from a terminal

All four carry every entry in full. No account, no email, no "subscribe to continue". The Markdown source of any entry is at /posts/<slug>/index.md if you would rather have the file than the page.

And it works with the terminal off

Every route renders as ordinary HTML from the same Markdown. With JavaScript disabled you get the text, the links, the credits under the art — a plain document. The terminal hides that fallback once it starts, and if it never starts, the fallback is the site.

The terminal is the interface. It is not an excuse to break the web.

Havia uma hora exata em que a linha ficava livre. Depois das onze, quando ninguém mais ia usar o telefone, o modem podia gritar à vontade. Aquele ruído — o carrier, a negociação, o silêncio súbito quando os dois lados finalmente concordavam — era a coisa mais próxima de uma porta se abrindo que a informática já produziu.

Um lugar com capacidade um

O que mais me impressiona hoje não é a lentidão. É a exclusividade.

Um BBS de um node só aceitava uma pessoa por vez. Enquanto você estava lá, ninguém mais no mundo estava. Não havia timeline, não havia outras pessoas rolando a mesma tela em paralelo, não havia contagem de quem estava online. Havia você, o sysop dormindo, e um computador na sala dele.

Um lugar que só existe enquanto alguém está conectado é uma ideia estranhamente honesta sobre o que é estar em qualquer lugar.

O que se fazia lá

1. Ler as mensagens novas desde a última visita.
2. Responder duas ou três.
3. Baixar um arquivo de 300 KB em quinze minutos.
4. Olhar a arte ANSI da tela de entrada por tempo demais.
5. Deslogar antes que a conta do telefone virasse assunto de família.

Cinco coisas. Não havia uma sexta. A ausência de uma sexta coisa é exatamente o que fazia as outras cinco valerem a pena.

Coração, informação, acentuação

Uma nota técnica, já que este site insiste em ser um terminal: o português sempre foi um pequeno problema para telas de texto. Os acentos viviam na parte alta da tabela — ç, ã, õ, é —, e cada BBS decidia por conta própria se falava CP437, CP850 ou nada disso. Você digitava coração e o outro lado lia cora‡Æo.

Aqui isso está resolvido: por dentro é tudo UTF-8, e o CP437 fica onde deve ficar, que é no desenho.

O que sobrou

Sobrou o formato. Uma tela por vez, um assunto por tela, e a certeza de que quando você desligar aquilo tudo simplesmente deixa de existir até a próxima madrugada.

Não é nostalgia. É que a coisa funcionava.

The IBM PC text mode gave an artist sixteen foreground colours, eight backgrounds, and 256 shapes. No pixels, no gradients, no partial transparency. A cell was one character in one colour on one background, and that was the whole medium. People made astonishing things with it for twenty years.

Everything drawn for this system works under the same rules. Here is what that means in practice, and what the build does about it.

The vocabulary is smaller than the palette

█ full block     ▓ dark shade
▒ medium shade   ░ light shade

Those four are not textures — they are mixing. Light shade of white on black is a grey that does not exist in the sixteen. Medium shade of bright blue on blue is a blue that is not in the palette either. The entire tonal range of the medium comes out of four characters.

The site's own pieces are held to the CP437 character set, and the validator says so out loud when they wander:

WARN  ornaments   27x4   outside CP437: ▪ ▫ †

Which is how ▪▫▪ became ■·■ and a dagger became ♦. Worth knowing: CP437 has no tilde vowels. It has ç, it has á, it has no ã. That is exactly why a Brazilian on a 1994 board read cora‡Æo instead of coração — and why the webfont here is the "Plus" variant rather than the pure 437 one.

The art is data, and that is deliberate

Original pieces live as typed data rather than as .ANS files on disk, so the compiler and the tests can measure them with the same code that measures every other line in the system. A piece 92 cells wide fails the build instead of arriving crooked.

The format is not lost. npm run art:export writes each piece out as a real .ANS: CP437 bytes, CRLF, a SAUCE record built from the registry, a terminating SUB. They open in PabloDraw and pass through AnsiLove.

Getting that right took two bug fixes worth mentioning, because both destroy art silently:

• encodeCp437(' ') returned 0x00, not 0x20. Byte zero also decodes to a blank, and it won the reverse lookup.
• Escape, carriage return and line feed were being encoded as ←, ♪ and ◙. In an art buffer the low bytes are glyphs; in a stream they are controls. Confusing the two turns every colour change in a file into a arrow character.

Nobody's work goes up without their name

Every piece has an entry in src/art/art-registry.yml: author, handle, group, year, licence, original filename, notes. A piece with no entry does not build. When the terms are unclear the entry says reference_only: true, and the validator keeps it out of the build, out of the gallery and out of dist/.

SAUCE records — the 128 bytes the scene stapled to the end of a file with the artist's handle, group and date — are read on import and shown by art info <slug>. They are the reason we still know who drew what, thirty years later.

There is one rule with no exception: an artist's signature is never removed. Not to fit a layout, not to fit the grid. If the signature does not fit in 80 columns, the piece does not go in.

Why it still reads well

A constraint that severe forces an artist to think in shape and value rather than detail. Same discipline as woodcut, as stencil, as any printing process with a limited number of passes. Work made under those rules tends to survive changes in display technology, because it never depended on the display being good.

An ANSI drawn in 1993 on a CRT still looks correct on a 5K panel in 2026. Very little else from 1993 can say that.