ASCII
The code approved on 17 June 1963 had no small letters in it. Not a shortage of them: none. When the 1967 revision put them in, it placed every one directly below its capital, and that decision made case and control cheap bit operations. Early bit-paired terminals exploited it directly in hardware; a keyboard today emits key events into firmware and the relationship is one software can still use rather than one the hardware is wired to.
A character, its row, and the bits that pick the column
Type any character. The table is seven bits wide: three choose the column and four choose the row, so the eight characters below share their low four bits and differ only in the top three.
Row 11. Every one of these is 1011 in its low four bits.
- position
- 4/11
- seven bits
- 100 1011
- with Ctrl
- VT, at 0/11
- case bit flipped
- k, at 6/11
- in the 1963 code
- yes
Ctrl clears the top two bits and Shift clears the next one down. Neither key looks anything up.
What 1963 did not have
The first ASCII was approved on 17 June 1963 with the last two columns of the table largely empty, reserved for later standardisation. Two whole columns of the table, the ones a small letter would need, were among them. A teleprinter of that year printed capitals and that was the alphabet.
Turn on the 1963 view above and the table thins out. What is missing is not decoration; it is half the letters anybody writes.
What 1967 did with the space
The revision could have put the small letters anywhere. It put each one in the same row as its capital, two columns to the right, which means one bit apart. All twenty-six pairs, the same bit every time. That is not a coincidence to admire, it is a specification choosing to make a later problem cheap.
The consequence is everywhere and mostly invisible. Toggling an ASCII letter's case is an XOR with a single value; folding to one case sets or clears that bit rather than flipping it. A keyboard's Shift key, for a letter, selects the member with that bit clear. Control clears the two above it, which is why Ctrl and a letter lands you in the control column of the same row: hold Ctrl and press K and what a terminal receives is the character at 0/11, which is VT, vertical tab.
Put that against Baudot, ninety years earlier, and the thread finishes itself. Baudot also needed more characters than his bits allowed, and he bought them with a shift character: a code sent down the wire that changed what every following code meant, until something cancelled it. It cost a whole character, and it stayed in effect, so a lost shift corrupted everything after it. ASCII moved the same idea inside the character. It costs code space rather than nothing, and what it buys is that there is no persistent shift state for the stream to lose.
These ran in this browser when the page loaded. Each claim, whether it held, and the number behind it.
| claim | held | measured |
|---|---|---|
| all 128 codes are reconstructed from their 3-bit column and 4-bit row | yes | RFC 20's sentence about b7 b6 b5 and b4 b3 b2 b1, read as arithmetic; nothing on this page is a table of character names |
| all 26 letter pairs are exactly one bit apart, and it is the same bit (0x20) every time | yes | measured over the pairs, not asserted; if 1967 had placed one small letter anywhere else this would report two values |
| Control is clearing two bits: Ctrl-I is 9 (tab), Ctrl-M is 13, Ctrl-[ is 27 | yes | one mask of 0x1F, which is why those keys are wiring and not software |
| none of the 26 small letters existed in 1963; they fill columns 6 and 7, which the 1963 code left open | yes | the twenty-eight unassigned positions are the reason case folding could be made one bit four years later |
| the 8 characters sharing A's row differ only in the 3 bits that pick the column | yes | row 1 holds 0/1 1/1 2/1 3/1 4/1 5/1 6/1 7/1, which is the whole subject of the page |
What is real here, and what is not
The structure is derived, not tabulated
There is no table of characters in this page's code except the thirty-two control names, which are names and cannot be computed from a number. Everything else is arithmetic on one sentence from the standard: the top three bits give the column, the bottom four give the row. The row of eight, the positions, the effect of each modifier, all of it falls out of that. The test checks the derivation against the code chart in the archived copy of RFC 20, cell by cell.
Shift is only shown for letters, on purpose
The bit that turns a capital into a small letter does something to every other character too, and it is usually nonsense: applying it to 4 gives t. A page that showed that as "Shift" would be describing a keyboard nobody has. So the readout says nothing for characters where the operation is not what the key does.
The 1963 view is a simplification, and here is its edge
The page shows the 1963 code as the first six columns. That is right about the letters, which is what the page is about, and it is rough at the margins: the 1963 standard did assign a few positions in the last two columns and left others open, and several punctuation marks moved between the two revisions. If you want the exact 1963 chart, the annotated history linked below reproduces it. This page's claim is narrower than that chart and is the one it can support: in 1963 there were no small letters.
Nothing here is a terminal
Pressing Ctrl on your own keyboard while this page is open will do whatever your browser does. The page is showing you what the code says those keys mean, not intercepting them, and it deliberately does not capture keystrokes: a page about a control character that swallowed Ctrl-W would be a bad joke on anyone who tried to close it.
Seven bits, and where the eighth went
ASCII is seven bits and 128 codes. It is almost always carried in an eight-bit byte, and what the spare bit did varies: parity on a teleprinter line, a second half of the character set later, or nothing at all. RFC 20's own instruction for the ARPANET was to embed the seven bits in a byte whose high order bit is always 0
. That is one choice among several and this page does not model any of them.
Sources
- RFC 20, ASCII format for Network Interchange, Vint Cerf, October 1969, which reprints the code chart of USAS X3.4-1968 in full and is itself an internet standard, STD 80. Everything structural on this page is checked against this document: the complete table, and the sentence defining it, that the column is bits b7 b6 b5 and the row is b4 b3 b2 b1.
- NBS Technical Note 478, Evolutionary Forms of ASCII, National Bureau of Standards, read here as a scan. It sets out the three versions and their approval dates: X3.4-1963 approved by the American Standards Association on 17 June 1963, without lower case, and X3.4-1967 approved by the United States of America Standards Institute on 7 July 1967. The text layer of the scan mangles the standard numbers, so nothing is quoted from it.
- IEEE Milestone: ASCII, 1963, for the approval date of 17 June 1963.
- Tom Jennings, An annotated history of some character codes, which reproduces the 1963 chart and the 1967 one and walks through what moved between them. The place to go for the margins this page rounds off.
- Baudot, on this site, for the shift that cost a whole character and stayed in effect until cancelled.