Ethernet Gateway

1963 — ASA X3.4. ASCII (American Standard Code for Information Interchange) was published in 1963 by the American Standards Association's X3.4 committee, with significant design contributions from Bob Bemer at IBM — widely credited as "the father of ASCII" for proposing the escape character, the backslash, and the case-toggle bit alignment. The committee was a cross-vendor effort (Teletype, IBM, AT&T, Burroughs, RCA, and others) and its task was to replace a patchwork of incompatible 5-bit teleprinter codes (Baudot/ITA2), 6-bit military codes (FIELDATA), and IBM's own 6-bit BCDIC. The first published version had only uppercase letters; lowercase was added in the 1967 revision (USASCII), which is the table you see above.

The 7-bit choice. Seven bits was a compromise: 6 bits couldn't fit upper- and lowercase plus digits and punctuation, while 8 bits would have wasted a bit on serial lines that already paid for a parity bit. The 8th bit (0x80-0xFF) was originally a parity bit, which is why ASCII proper stops at 0x7F — the upper half was reserved for transmission integrity, not characters. This is also why so many later codepages (Latin-1, PETSCII, ATASCII) bolt their additions onto 0x80-0xFF: that range was free real estate once parity moved out of band.

Why DEL is at 0x7F. DEL (delete) sits at 0x7F — all seven bits set — because on paper tape you "deleted" a character by punching all seven holes through it. There was no way to un-punch a hole, so the convention was to over-punch the position to a known sentinel. 0x00 (NUL) and 0x7F (DEL) are the two values that look "blank" on punched tape: NUL is no holes, DEL is all holes.

Internationalization and the 1980s. ISO 646 (first edition 1973) generalized ASCII as a national-variant standard: countries could replace 12 specific positions (notably 0x23, 0x24, 0x40, 0x5B-0x5E, 0x60, 0x7B-0x7E) with their own letters. The German variant (DIN 66003) put Ä at 0x5B (where [ is in ASCII) and ä at 0x7B (where { is); the French variant (AFNOR NF Z 62-010) put à at 0x40 (where @ is) and é at 0x7B (where { is); and so on — which is why C source code from that era sometimes contains alarming-looking accented characters in place of the punctuation the language actually wanted. ISO 8859-1 (Latin-1, 1987) and finally Unicode/UTF-8 (1992) ended the variant chaos by giving every script its own codepoint.

Today. ASCII is still the lingua franca: UTF-8 was deliberately designed so that any 7-bit ASCII file is also a valid UTF-8 file with identical bytes. Every modern text format — HTTP, email headers, JSON, source code — is ASCII-compatible at the byte level. You're reading ASCII right now.

Pre-history: ASCII control codes weren't enough. The 33 ASCII control codes (0x00-0x1F plus 0x7F) cover the basics — CR, LF, BEL, BS, TAB — but they have no way to say "move the cursor to row 5 column 12" or "draw the next word in red." Early CRT terminals (the ADM-3A, the Hazeltine 1500, the Lear-Siegler) each invented their own escape sequences, and none of them agreed. Software either had to ship a termcap database with hundreds of entries or be limited to the lowest common denominator.

1976 — ECMA-48. The European Computer Manufacturers Association published ECMA-48: Control Functions for Coded Character Sets in 1976 to standardize the soup. It defined the Control Sequence Introducer (CSI = ESC [), the parameter format, the cursor-motion command set, and Select Graphic Rendition (SGR) for text attributes. ANSI adopted it as X3.64 in 1979, and ISO as ISO/IEC 6429 in 1983. ANSI X3.64 was withdrawn in 1997, but the "ANSI" name stuck because that's what U.S. terminal manuals called it.

1978 — the DEC VT100. Digital Equipment Corporation shipped the VT100, an early microprocessor-based terminal that implemented an ANSI-conformant subset (with some DEC-private extensions like DECSC/DECRC and the scrolling region). The VT100 became so dominant that "VT100-compatible" became the practical definition of an ANSI terminal. Its successors — VT102, VT220, VT320, VT420 — layered on more features (8-bit codes, soft fonts, sixel graphics) but stayed compatible. To this day, when you tell ssh or screen your terminal type, you're probably saying xterm or vt100.

The xterm era. xterm was originally written at MIT in 1984 by Mark Vandevoorde (initially for the VS100 stand-alone terminal) and then ported to the X Window System by Jim Gettys, who maintained and extended it for decades. It implemented VT102 emulation faithfully and then kept adding features: 256-color mode (1999, via the ESC[38;5;nm extension), 24-bit truecolor (ESC[38;2;r;g;bm), mouse reporting, bracketed paste, OSC 52 clipboard. Modern terminals (iTerm2, Alacritty, kitty, Windows Terminal, GNOME Terminal) all implement the xterm extension set, often with their own additions. There is no committee shepherding this anymore — the de facto standard is "what xterm does."

Today. ANSI escape sequences run the modern terminal: every TUI tool (vim, htop, tmux, fzf), every CI log with colored output, every progress bar, every git diff. Windows finally added native ANSI/VT support to its console host in Windows 10 (Threshold 2, late 2015), opt-in via the ENABLE_VIRTUAL_TERMINAL_PROCESSING mode flag, ending decades of having to ship an ANSI-to-Win32-Console translator like ANSICON; the modern Windows Terminal app (2019) made it the default. The single biggest practical limitation is still which extensions a given terminal implements — truecolor support, in particular, varies wildly across SSH-into-tmux-into-screen chains.

1977 — the Commodore PET. PETSCII (PET Standard Code of Information Interchange) was designed for the Commodore PET 2001, unveiled at the Winter CES in January 1977 and shipped in volume that October — making it, alongside the Apple II and the TRS-80, one of the "1977 Trinity" of consumer personal computers. Commodore engineer Chuck Peddle — who had led the 6502 CPU design at MOS Technology before Commodore acquired the chipmaker — was the architect of the PET. PETSCII was based on ASCII but extended with a full set of monochrome block-graphics characters, chosen so that the PET could draw boxes, charts, and simple game graphics without a separate graphics chip.

The case-swap quirk. PETSCII has two display modes selected by sending 0x8E (uppercase mode, the boot default) or 0x0E (lowercase mode). In uppercase mode, codes 0x41-0x5A render as A-Z (matching ASCII visually) and codes 0x61-0x7A render as graphics characters. In lowercase mode, the same bytes flip: 0x41-0x5A render as lowercase a-z, and 0x61-0x7A render as uppercase A-Z — effectively swapped from ASCII. The net effect is that any ASCII text printed verbatim on a C64 in lowercase mode comes out CASE-INVERTED. Every BBS terminal, every cross-platform tool, every emulator handles this differently. Ethernet Gateway swaps case in software so a telnet user on a C64 sees the right thing without configuration.

The shared-platform legacy. PETSCII outlived the PET. It carried over with minor adjustments to the VIC-20 (1980), the Commodore 64 (1982, which sold ~17 million units — the best-selling single computer model in history), the C128 (1985), and the Plus/4 and C16 (1984). Color codes (0x05, 0x1C-0x1F, 0x81, 0x90-0x9F) were added on color-capable models; the PET itself was monochrome and ignored them.

Reverse-video and cursor codes inline. Unlike ANSI, PETSCII doesn't use multi-byte escape sequences: every effect is a single byte. 0x12 turns reverse video on, 0x92 turns it off; 0x11/0x91/0x1D/0x9D are cursor down/up/ right/left; 0x93 clears the screen; 0x0E/0x8E switch case mode. This made it trivial to print formatted text from BASIC (PRINT CHR$(147) = clear screen) but means PETSCII files are not portable to ANSI terminals without translation.

Still alive in the BBS scene. PETSCII never died. The Commodore BBS scene of the 1980s is still active: dozens of PETSCII boards run today on real hardware (via WiFi modem cartridges like the WiFi Modem 232 and the Userport Hub) or in emulators, dialing each other up via telnet. Modern PETSCII art has its own demoscene, and tools like petmate and PETSCII Editor target both retro hardware and modern displays. Ethernet Gateway's PETSCII support exists specifically so a real C64 with a WiFi modem can use a modern telnet/SSH gateway as if it were a 1985-era BBS.

1979 — the Atari 400 and 800. ATASCII (Atari Standard Code for Information Interchange) was introduced with the Atari 400 and 800 in November 1979 — the same year as the TI-99/4. The character set was designed by Atari's Home Computer Division under Jay Miner, who would later design the Amiga's custom chips. The Atari 8-bits (400/800/1200XL/600XL/800XL/65XE/130XE/XEGS) all used ATASCII unchanged from 1979 to the line's discontinuation in 1992 — an unusually long character-set lifetime for a home-computer family.

The 0x9B EOL problem. ATASCII's most infamous quirk is using 0x9B (155, "EOL") as end-of-line instead of CR/LF. This was a deliberate choice — 0x9B is a single byte, doesn't require pairing CR with LF, and falls in a range Atari considered "safe" because they didn't use the 0x80-0xFF inverse range for printable text. The downside was severe: every cross-platform file transfer (ASCII mode FTP, BBS uploads, modem terminal programs) had to translate 0x9B to 0x0D 0x0A on the way out and back on the way in. A generation of Atari users learned what "ATASCII translation" meant the hard way after losing line breaks on cross-platform files. The Ethernet Gateway's terminal-detection logic specifically watches for ATASCII-style line endings.

Inverse video as a parallel character set. The Atari ANTIC graphics chip rendered character cells with a hardware inverse-video bit (bit 7 of the screen-memory byte). ATASCII exploits this directly: the upper 128 codes (0x80-0xFF) are not new characters — they're the lower 128 with inverse video applied. This means an Atari programmer could highlight a word in a status line by simply ORing 0x80 into each byte. Six positions (0x9B-0x9F, 0xFD-0xFF) were stolen back as control codes (EOL, delete-line, insert-line, tab-stop set/clear, bell, delete-char, insert-char), so those don't have inverse equivalents.

The Atari BBS scene. Atari BBSes (running software like AMIS, FoReM, BBS Express!) were a parallel ecosystem to the Commodore boards. ATASCII art and animations — using the cursor-control codes to move around and the inverse-video range for color — were a recognizable style, distinct from PETSCII or ANSI art. Commercial online services that catered to Atari users included The Source (a Reader's Digest subsidiary, later acquired by CompuServe) and CompuServe itself, both of which published Atari-specific terminal programs that translated ATASCII to and from ASCII at the gateway.

Today. ATASCII survives in emulators (Altirra, Atari800), in modern cartridges and SD-based loaders that let real 8-bit hardware connect to modern networks (FujiNet, SIO2PC), and in the small but persistent Atari demoscene. The character set is also still used by some specialty software for Atari ST and Falcon machines that retained 8-bit-mode compatibility.

1870s — Émile Baudot. French telegraph engineer Émile Baudot patented his 5-bit code in 1874 to replace the older Morse code on multi-channel telegraph circuits. Morse was variable-length and asynchronous, which made it impossible to multiplex efficiently; Baudot's fixed-width code let multiple operators share a single wire by time-division multiplexing, dramatically increasing the throughput of telegraph offices. Baudot also invented a five-key piano-like keyboard specifically tuned to enter his code — the operator played each character as a five-finger chord. The unit of signaling speed, the "baud," is named for him.

1901-1932 — Donald Murray and ITA2. New Zealand-born engineer Donald Murray redesigned Baudot's code in 1901 to better suit keyboard-driven typewriters: he reassigned codes so that common letters required less mechanical wear on the print mechanism, and added punctuation. The CCITT (Consultative Committee on International Telephony and Telegraphy, predecessor to the ITU-T) standardized Murray's scheme as International Telegraph Alphabet No. 2 (ITA2) in 1932. ITA1 was the original Baudot; ITA2 (Murray's revision) is what almost everyone calls "Baudot" today, including this table.

The shift-state trick. Five bits gives only 32 codes. To represent 26 letters, 10 digits, and punctuation, Baudot/ITA2 uses two shift states — LTRS (code 31) and FIGS (code 27). Each one switches the meaning of all subsequent codes until the other shift is sent. This is why a hardware glitch on a teleprinter line could turn an entire message into nonsense: if the receiver missed an LTRS or FIGS shift, every following character was mis-decoded. Operators developed a habit of repeating shifts every few words for resync.

Mechanical speeds. Baudot ran at 45.45, 50, 56.9, 75, or 100 baud on mechanical teleprinters — speeds chosen to match the resonant frequency of the Teletype's spring-driven type-bar mechanism. Each character was one start bit, five data bits, and 1.5 stop bits (the half-bit stop was a clever way to keep the receiver in sync without a full-bit gap). At 50 baud, that gave roughly 6.7 characters per second — about 400 characters per minute, fast enough for live typed conversation.

Telex and TWX. From the 1930s through the 1980s, Baudot/ITA2 was the backbone of the global Telex network (international) and TWX (Teletypewriter Exchange Service, North America). At its peak in the 1980s, Telex linked over 2 million machines worldwide and was the primary medium for legally-binding international business communication — faster than mail, more durable than phone, and accepted in court as documentary evidence. Telex didn't begin its decline until fax (1980s) and email (1990s) took over.

TDD/TTY for the deaf. After commercial Telex died, Baudot lived on in telecommunication devices for the deaf. The TDD/TTY (Telecommunication Device for the Deaf, also called Teletypewriter) protocol used ITA2 with US TTY variant figure assignments at 45.45 or 50 baud over the regular phone network, with distinctive "warble" tones (1400/1800 Hz). TDD/TTY usage held on into the 2000s before being replaced by video relay services and SMS. Some emergency 911 systems still accept TDD calls today as a regulatory accessibility requirement.

Why no lowercase? Mechanical teleprinters had a single set of physical type-bars per character position — adding lowercase would have doubled the mechanism cost and paper-tape width. By the time printing technology made mixed case practical (the 1960s), 7-bit ASCII was already taking over, so Baudot remained an uppercase-only standard throughout its commercial life.

1982 — Sinclair Research, Cambridge. Sir Clive Sinclair's Sinclair Research launched the ZX Spectrum on April 23, 1982 at the Earls Court Computer Fair in London. The 16K model cost £125 and the 48K model £175 — roughly half the price of an Acorn BBC Micro and a third of an Apple II. This aggressive pricing was Sinclair's signature move; he had already shipped the calculator-style ZX80 (1980) and ZX81 (1981) on the same philosophy. The Spectrum's distinctive grey-with-rainbow case was designed by industrial designer Rick Dickinson, who also did the ZX81.

The dead-flesh keyboard. The original Spectrum used a flat rubber membrane keyboard — nicknamed "dead flesh" by the British computing press — in which each key had up to five different functions printed on it: the letter, a BASIC keyword, an extended-mode command, and two symbols. Pressing K alone entered the LIST keyword; SHIFT+K entered the symbol "+"; SYMBOL SHIFT+K entered "+"; EXTENDED MODE then K entered the keyword TAN. This crowding was a memory-saving trick — the BASIC interpreter could store entire keywords as single-byte tokens (0xFB = CLS, 0xF5 = PRINT) without a parser, because the user literally couldn't type a keyword character-by-character.

Color attribute clash. The Spectrum's display was 256x192 monochrome pixels overlaid with a 32x24 grid of color attributes — each character cell could pick its own ink and paper from the 8-color palette, but only one ink/paper combo per cell. This produced the infamous "attribute clash" where two sprites overlapping in the same character cell forced their colors to merge. Game programmers turned the limitation into an aesthetic: classics like Knight Lore, Manic Miner, and Jet Set Willy have an unmistakable look that comes directly from working within (or against) the attribute grid.

The block graphics range. Codes 0x80-0x8F are 16 block-graphics glyphs covering every combination of a 2x2 quadrant grid. They doubled the effective screen resolution to 512x384 "pixels" for character-mode rendering — useful for charts, BASIC graphics, and simple games that didn't need pixel-exact sprites. The 21 User Defined Graphics slots (0x90-0xA4) let programs install their own 8x8 glyphs into BASIC's character set, which is how nearly every Spectrum game drew its sprites.

Sales and the British games industry. The Spectrum sold roughly 5 million units worldwide, the bulk of them in the UK, where it dominated the home-computer market through the mid-1980s. It birthed an entire British games industry: Ultimate Play the Game (later Rare), Ocean Software, Imagine, Codemasters, and dozens of bedroom developers shipped games on cassette tapes that loaded for five minutes from screeching audio over the machine's EAR jack. Many of those developers are still active in the modern industry. Sinclair sold the Spectrum business to Amstrad in 1986, which kept producing it (the Spectrum +2, +3) until 1992.

Modern revival. The Spectrum has one of the most active retro communities of any vintage platform. Modern hardware reproductions (the ZX Spectrum Next, an FPGA-based reimplementation funded on Kickstarter in 2017, and the ZX-Uno) sell in the tens of thousands. The annual Crash Live and Spectrum demoscene events still draw crowds, and new commercial games for the original Spectrum still ship on cassette every year. The machine's character set, including its block graphics and keyword tokens, is still natively supported by emulators like Fuse, ZEsarUX, and Spectaculator.

August 1977 — Tandy/Radio Shack. The TRS-80 Model I shipped on August 3, 1977 — about two months after the Apple II began shipping and roughly two months before the Commodore PET 2001 reached customers (the PET had been announced in January 1977 but didn't ship in volume until October). Tandy Corporation's electronics chain Radio Shack already had over 3,000 retail stores in the U.S., which gave the Model I instant distribution that Apple and Commodore couldn't match. It was designed by Steve Leininger in Fort Worth, Texas, on the staff of Don French (the Radio Shack buyer who championed the project). The "TRS" stood for Tandy Radio Shack; "80" referenced the Z80 CPU.

The "1977 Trinity." Byte magazine retroactively named the Apple II, TRS-80 Model I, and Commodore PET the "1977 Trinity" — the three machines that turned the personal computer from a hobbyist kit (Altair 8800, IMSAI 8080, KIM-1) into a consumer product you could plug in and use. Of the three, the TRS-80 was by far the cheapest at $599 (Model I, 4K) and had the most retail presence. From 1977 to 1981 it outsold both rivals; estimates put the Model I and Model III combined at roughly 250,000 units.

The 2x3 semigraphics trick. The TRS-80's video hardware had no dedicated graphics chip and no bitmap mode — just a character-cell display. Leininger's solution was elegant: codes 0x80-0xBF in the character set are 64 block-graphics glyphs covering every possible combination of six pixels arranged in a 2x3 grid inside a single character cell. With a 64-column by 16-row text display, that gave an effective 128x48 "graphics" resolution for free, using only the text-mode hardware. Every TRS-80 game, every chart, every menu border was drawn this way. The technique was so effective that the later CoCo (Color Computer) inherited a similar scheme.

The "Trash-80" reputation. Competitors and the computing press derisively nicknamed it the "Trash-80" — partly because of the cheap-feeling silver-and-black plastic case, partly because of the famous silver-mylar keyboard reliability problems on the Model I, and partly because Tandy's tape-loading was notoriously unreliable (the cassette interface clipped at strange audio levels). Despite that, it was solid-enough that an enormous third-party market sprang up to fix or upgrade it: Percom disk drives, Lobo controllers, lowercase-character modification kits, and a thriving software market that survived into the late 1980s.

Model I → III → 4. The Model I was discontinued in 1981 because it failed FCC radio-frequency emission rules — its bare-PCB-on-desk design leaked Z80 clock harmonics across the AM radio band. The Model III (1980) was a redesign in a single integrated case that passed FCC, added lowercase (the original Model I had no lowercase letters; positions 0x60-0x7F were unused or duplicated graphics), and bumped RAM. The Model 4 (1983) added an 80-column mode, more RAM, and CP/M compatibility — a tacit admission that the IBM PC had taken over the business market. The 4P (1983) was a "luggable" portable variant.

Color Computer (CoCo) and after. Tandy's TRS-80 Color Computer (1980) shared the TRS-80 brand but was an entirely different machine architecturally — a Motorola 6809 with a Motorola graphics chip, no relation to the Model I/III/4 line. The Z80-based TRS-80 Model 4 was the last machine in the original lineage; Tandy quietly dropped the Z80 line in 1991 and focused on IBM-compatible PCs (the Tandy 1000 family). The Model 4 character set described in this appendix is the most complete; the Model I was a strict subset (no lowercase, semigraphics-only upper range).

Today. The TRS-80 retro community is smaller than the C64 or Spectrum scenes but very active. Emulators (TRS80gp, MAME, sdltrs) cover all four models faithfully, and projects like the Model 1 reproduction PCB and FreHD (a CompactFlash-based hard-disk replacement) keep real hardware running. The 1977 Computer History Museum exhibit in Mountain View permanently displays a working Model I as part of its personal-computer-revolution gallery.