In an answer to Why did IBM System 360 have byte addressable RAM I wrote regarding the choice of byte size:
7 bits would be a perfect match for ASCII, but engineers would instinctively recoil from basing the word sizes on a prime number.
(Okay, someone else pointed out that EBCDIC actually uses 8 bits, but that would only be a concern for IBM in particular.)
Now it occurs to me to wonder, did anyone ever build a computer with a 7 bit byte? Or with a 14, 28 or 56-bit word?
The PDP-10 had 'byte instructions' that could process a sequence of bytes of size 1 to 36 bits. The byte pointer was a word containing an 18-bit word address (and the usual index/indirect indications) plus position and size of the byte within the word.
It was common to use 7-bit byte sequences for ASCII text, which gave 5 characters per word and one (usually) unused bit.
There were monitor calls (system calls) that accepted strings of 7-bit characters packed in this way.
So: at the hardware level, bytes were variable-sized. At the software convention level, a byte was frequently 7 bits.
See section 2.3 in the KA-10 system reference manual.
The VT52 text terminal certainly doesn't qualify as a full computer, but it does have a processor running software out of a ROM. The RAM holding the displayed text is 2048 7-bit bytes. The character generator ROM is also 7 bits wide.
The second-generation Soviet computer Minsk-32 (the series size is 2889 machines, 1968-75, civilian use, one of the rare early mainframes noted for use in Antarctica) used a 37-bit word and 7-bit representation of alphanumeric characters (5 in a word). Yes, the concept of "bytes" is difficult to apply to a similar old computer (which continued the line of vacuum tube machines), but special commands for the convenience of operations with 7-bit blocks took place in the command architecture.
The well-known IBM 1401 technically had a 7-bit byte (plus parity). It was designed around the common format of IBM punched cards, which it was designed to process; these had ten "digit" rows and two "zone" rows, of which one digit and optionally one zone (for which the zero row also counted as a third zone) could be punched simultaneously in each column.
This essentially meant that each column of a card contained a value that could be encoded in 6 bits - 4 representing a BCD digit, and two more indicating the zone (no zone, first zone, second zone, or zero row). To this, the 1401 added a "word mark" bit for internal use, for a total of 7 bits.
Yes; there have been several (although, to my knowledge, none in the most simple sense where seven binary bits are treated strictly as as a base-7 system of Peano-like numbers). Instead, they are systems in which at least one (typically, two or three) carry are treated as separate state-modification bits.
The most oldest/most simple example (although it may not meet the definition of a Turing-complete computer) is the ancient 5/2 abacus.
More recent examples generally are cases where some form of binary-coded decimal is used, particularly those that use Chen-Ho encoding (which fit a better conception of the system being "7-bit", as Boolean logic/operations can still be (relatively) easily applied, as opposed to more packed (or packed/padded) 7-bit numbers, which require a variable number of instructions to ascertain certain binary/two's complement values.
Of these, the "two of seven" approach is most common. Examples: the IBM 650, the FACOM 128, and the "IBM 370 compatibility feature" (hardware emulation) built in to the IBM 7070/7074.
The Norsk Data ND-505 had a 28-bit address bus.
The ADAU1701 is a 28-/56-bit DSP for audio processing. CHAR_BIT is probably 28 on that platform like most odd-sized DSPs but I'm not quite sure since I couldn't find its programming manual
Some famous Microchip PIC processors, such as the Microchip PIC 16F84 and the Microchip PIC 16F877A, have a "14-bit processor core". They execute all instructions out of a 14-bit-wide memory. In other words, their program memory has a 14-bit word. .
In addition to executable code, programs running on some (but not all) "14-bit processor cores" can read and write all 14 bits of any word in the non-volatile program memory. A few programs pack character map image data into 14 pixels per program word or 7-bit ASCII text into 2 ASCII characters per 14-bit program word.
Alas, programs running on the original PIC16F84 cannot read or write their own program flash memory (only execute), so if they use constant character data at all, they generally store one ASCII character per 14-bit program word.
