Why did 80x25 become the text monitor standard?

Question

Prior to the 1981 release of the IBM PC, the VT05 (72x20 1970), VT50 (80x12 1974), VT52 (80x24 1975), and VT100 (80x24 1978) text terminals were used on many Unix machines and the PDP-11 (probably the most widely used computer at the time). However, just as many other computers used widths of 60 (type writer), 132 (wide printer), or convenient memory page sizes of 32 or 64.

TV's became quite blurry approaching 132 (B&W@625px) char so that seems to be the hardware maximum width upper limit.

Where did the 80x25 text terminal size come from?

Answer 1

A lot of early PCs and terminals were designed to use either TVs or monitors that were built around CRTs that were built to the same specifications as TVs. While (traditional standard definition) TVs don't have a well defined upper limit of horizontal resolution, in practice few of them were capable of handling a signal which varied faster than about 13 or so MHz; in the end, when resolutions of analogue TV were standardized in order to transition to digital a final upper limit of 13.5MHz was defined, but few TVs other than the very best were actually able to reach that, at least in the 70s and 80s; monitors were slightly better, but not much because in many cases they were using the same CRTs, and there was little incentive to produce a higher quality CRT if the rest of the circuitry couldn't use it.

Also, in order to display a reasonable number of lines at a reasonable frame rate, there was an upper limit to the length of time a single line could take to display, which realistically was in the region of 50us. 50us * 13.5MHz = 675 pixels.

Display hardware needs to have a pixel counter that reacts when a limit is reached. It is easier to detect that limit if the binary pattern of it consists of a small number of digits that need to be matched followed by a larger number of zeros. 640 is a good candidate that is close to 675: you only need to examine 3 bits to produce a counter that counts up to it.

Because of these reasons, 640 pixels became a very popular horizontal resolution.

Now, as you point out, 132 character displays can be implemented within the range of a typical TV CRT; you'd need to use 5 pixel wide characters and aim for a resolution of 660 pixels. But with 5 pixels width, and the need to have empty space between characters, that means you have a maximum of 4 pixels per character, and 4 pixel wide fonts are generally quite untidy-looking and can be hard to read.

With 5 pixels to play with things become a bit better, but a major improvement in legibility happens at 6 pixels; along with spacing this means you can fit about 91 characters in a display.

But there was little demand for this width; 132 characters is useful because along with reasonable margins and standard fixed-width fonts, it's about the most characters you can fit on common paper size (e.g. A4 landscape or A3 portrait with 0.4" margins and a 12CPI font, or 8"x11" with 0.5" margins and the same font), so was useful because (1) you could use it for word-processing and see an approximation of what you'd see on paper and (2) you could have a printer that would print the same thing you saw on screen. But there was no such threshold in the region of 91 characters.

80 characters is, as described in the comments, very close to the width you can fit on standard paper sizes in portrait orientation. Most typewriters and "letter quality" printers used either Courier Elite (12CPI) or Pica (10CPI). As long as you used reasonable margins you could fit a line of text of either of those onto an 80 character display, so it is particularly useful for word processing, and again you can easily get a printer that can print whatever you see on screen.

There were other reasons, too. As described in another comment, IBM's standard punched card format allowed 80 columns, and therefore even before switching to CRT-based terminals many computing activities were already optimized around data that would fit into 80 columns. Existing databases that were being transitioned to video display may well have had 80 column maximum lengths on fields, for example, and therefore product buyers purchasing terminals will have wanted to ensure they could display those fields. Programmers were used to programming with 80 column maximum per line.

With 640 pixels being a natural, easy-to-implement screen width for systems using bitmapped frame buffers, those systems had another good reason: it made the text display logic easier to have 8 pixel wide characters, because then to display a row of pixels for a string you could just copy a byte from the font memory into the framebuffer and increment your pointer to move on to the next character, which is much easier than any alternative font width.

As to why 25 rows dominated, it's simply a question of existing hardware and font preferences. CRTs manufactured for TVs had 4:3 aspect ratio, so along with 640 pixels width, 480 pixels height gives you square pixels, which are desirable. By far the most popular fixed-width font is and was Courier; Courier has an aspect ratio of 0.43; 8/0.43 = 18.6, so 19 pixels is probably the ideal height for each character on a square pixel screen. 25 rows * 19 pixels is the most you can fit in 480 pixels. 25*80 is also the most you can fit in a 2K buffer (for a monochrome display) or a 4K buffer (if you have a choice of 16 foreground/background colours).

Answer 2

Where did the 80x25 text terminal size come from?

Quick answer: It's one Punch Card Per Line

Resulting in 24/25 lines (cards) per screen when using a 4:3 tube and a reasonable font as dictated by proportions fostered since Roman times.

Detailed Answer:

Prior to the 1981 release of the IBM PC, the VT05 (72x20 1971), VT52 (80x12 1974), and VT100 (80x25 1978) text terminals were used on many Unix machines and the PDP-11 (probably the most widely used computer at the time).

(Depends on the definition of widely, wouldn't it? *1)

You're maybe focusing a bit to much on the IBM PC and mini computers here. For one, there have been many terminal developments even before DEC started business, and even more when they did. And even more, common memory is defined by many parameters(*2).

However, just as many other computers used widths of 60 (type writer), 132 (wide printer), or convenient memory page sizes of 32 or 64.

It might be a good idea not to mix up different devices made for different usage. And I'm not sure what a memory page size does here (*3).

Type writers are meant to write letters, something no one really thought about when doing computers in the 1950s, even less before. Then again, as with terminals, there is a whole class of typewriters, called tabulators, that did provide a carriage for 132 columns (*4). Like with mainframe terminals, they were usually only seen in back office.

In general, there were two sizes defined in in pre-electronic data processing: 80 characters per block for storage and processing (and sometimes printing) and 132 characters for printing.

The 80 character came from IBM's extended punch card design of ~1930. The 'original' Hollerith card of 1890 had already evolved from 24 columns (characters) to 45 while keeping the basic structure. Still customers continued to ask for ever more storage capacity (*5). So one of the engineers Mr. Watson assigned the task came up with the idea of rectangular holes instead of the round one used up until then. Rectangular holes allowed (almost) doubling the density (*6) form 45 to 80 symbols while keeping the size of the card constant. This happened to be an important decision, as it only required modification on parts of the existing designs, while most of the production chain from paper manufacturing over card storage up to the mechanical parts of processing could be kept the same. Just punch thorn size and timing had to be modified (*7). Also around 1930 Remington doubled the capacity by keeping the round Hollerith holes, but storing two characters per column (90 characters per card). There were other formats as well. At the end of the 1940s (partly due the war) IBM's 80 column card was the industry wide accepted standard.

In 1920 the Tabulating Machine Company (originally The Hollerith Electric Tabulating System, now part of CTR Holding) introduced a new printer-lister system with 132 columns. While not the first to do so (*8), it became the de facto standard, thus setting the 132 characters for tabulating output - what later evolved into mainframe printers (and everything else meant to produce a ledger output).

For data processing on terminals it was a natural goal to display at least one basic data record - read, one punch card - in one display line, so data fields can be viewed as columns. The IBM 1050 Data Communications System is a typical example of an early (printing) terminal system. At the center with an adapted IBM Selectric typewriter, able to print 80 columns.

In fact, while the Selectric is usually seen as an office typewriter to handle standard letters, one major design goal was the capability of printing 80 characters, so it could also replace other data entry and print systems for IBM Mainframes. Mainly ofc, everything based around the IBM Electric typewriter, used for the same role since the 1930s - unlike Selectric also available in 132 character width. (*9)

That manufacturers of typewriters for simple home/office usage did go for design decision with a shorter carriage so only letter size paper (and thus less characters) can be used is unrelated here.

80 columns were therefore also the goal for CRT based terminals. There was some development needed before a 80x24 could be archived. Memory constraints being not the least (*10).

Even IBM struggled with the 2260, the grand daddy of all screen based terminals introduced in 1964. The basic Model 1 displayed 6 rows of 40 characters, while the Model 2 could do 12 line of 40 characters. Only the high end Model 3 could display a whole punch card in a single line with 12 lines of 80 characters. That setup with 3 models was mainly due memory reasons. Less characters per screen means one controller could support more terminals with the same memory. In fact, The 2260 didn't even have screen memory at all. The display was only a CRT and keyboard. Screen memory and picture generation was all within the 2248 control unit - stored in acoustic memory - and transmitted to the CRT.

Since the 1964 2260 Model 3, 80 characters was the standard for mainframes and the goal for everything else.

Many early manufacturers did first ship with terminals with less then 80 characters and 24 lines. Sometimes even in large numbers.

The well known (*11) Datapoint 2200 did support as well 12 lines of 80 character. The similar but earlier Cogar C4) did only 8 lines with 32 characters ... one reason why it never got as popular.

Still, without 80 column support they were less than desirable for any serious usage (aka mainframe related) beside specialized data entry. A general purpose terminal needs to support at least the most common data structure at once.

In fact, DEC's VT series does neatly show the struggle for 80 characters and might be used as an example of non printing terminals toward the 80/132 character per line goal:

• The original VT05 of 1970 offered 72x20 characters in a 4:3 fashion.
• The VT06, essentially a Datapoint 3300, offered 72x25 characters
• The next iteration as the VT50 of 1974 with 80x12 already reached the 80 characters goal, but mostly due memory constraints, only 12 lines were displayed. Since a 4:3 CRT was used, the resulting picture looked a bit like having every other line blanked out.
• A bit more than a year later the VT52 of 1975 supported 80x24 characters. Literally 'filling the blank lines' and even more, as the greatly (for back then) expanded memory allowed to store a window of more than 24 lines, resulting in the ability to scroll up and down thru this buffer (*12).
• In a 'last' step the VT100 of 1978 introduced a 132x24 display, so now every 'professional' output could be shown.

Now the 25 lines is a different but related story.

Technically the gold standard of all CRT based terminals, the 3270, did not display 24 but 25 lines. Just this 25th line was (usually) not accessible to user programs, as it held status information about the connection, session status or terminal/keyboard mode. So on a user level every competitor had to offer (at least) 80x24, which most did. The IBM PC text adapters were designed with terminal emulation in mind. Thus the hardware had to provide a 25th line. A line general available for any program.

That's something not restricted to the IBM PC. Many microcomputers before did offer 25 lines because of that. Heck, even the DEC VT100 did when it was transformed as VT180 into a CP/M machine.

Conclusion: 80/132 character come from the age of punch cards, 24/25 lines due the 4:3 dimensions of common CRTs

TV's became quite blurry approaching 132 (B&W@625px) char so that seems to be the hardware maximum width upper limit.

The whole TV system is made to display continuous greyscales/colours as they appear in real life pictures, not sharp contrast as needed for text display. That's why electronics, coils, and tube coating for dedicated text displays differ from such made for TV purpose. A TV set, including the full path can barely produce 40 characters per line (6/7px per char) in acceptable quality.

---

*1 - If most used is by computing power, or amount of users, then a single /370 installation might outclass a hundred PDPs. It's much like baking a peanut cake takes many more peanuts than one with a coconut filling takes coconuts :)

*2 - And it's a strange thing anyway. DEC's mini computer terminals were outsold by a magnitude by mainframe terminals like IBM's 3270. While mainframe terminals where used in huge installations in companies and government were only seen by a rather small number of employees working them every day all day, DEC products gained a hold in universities where Joe Average was introduced to them for a short time and moved. In most cases to jobs with (back then) no contact with terminals for the rest of their life.

*3 - even less I can see where pages of 32 or 64 - at least not when amended with a unit of byte or KiB - could be anywhere convenient.

*4 - Depending on the manufacturer there have been many different sizes even way past 200 columns. But 132 and 136 became somewhat a standard during the 1930/40s

*5 - The request for ever more storage capacity (and processing power) by users seam to be a constant during all history of data handling.

*6 - It's a bit like the move from FM to MFM for floppies, isn't it?

*7 - In the late 1960s, IBM tried to introduce a 96 column card together with the System/3 series. Here not only density got improved but at the same time the size got almost halved. The idea was quite like the 3.5" floppy: A card should well fit into a shirt pocket. It did prove unsuccessful as no one else, not even within IBM, adopted it. While the System/3 eventually evolved into the AS/400, the 96 column card was outlived by it's predecessor

*8 - Before CTR's printer tabulator there was the already quite successful Powers Printing Tabulator. Again not the first, as the Royden system of Peirce Patent Company already had one - not to mention custom developments like done at Prudential Insurance).

*9 - Since an IBM Electric was used as genuine terminal for the very first DEC machine (PDP-1), it could be argued that DEC's 80 column orientation is originated here :))

*10 - That's why Tectronix introduced storage tube based terminals. First the 600 series devices which later evolved into the 4000 terminal series and further into the well known 4010 family. No dedicated memory needed for screen refresh - but also no real way to do things like scrolling.

*11 - For being the source of all evil ... err x86.

*12 - It also started the downward spiral of decadence by offering lower case letters. Something real programmers (and users therefore) never needed in the first place.

Answer 3

The 80 columns comes via IBM terminals such as the 3270, which themselves got it from IBM punched cards. There was no particular reason to pick 80 over some other width for punched cards except that it is a nice round number and reflects the engineering limits of the day.

The 25 rows is due to the power-of-two nature of RAM chips. These were extremely expensive at the time and so the framebuffer size would be chosen to make efficient use of commonly-available chips. Assuming 80 character columns, 2^10 characters is 12.8 lines, 2^11 is 25.6 lines, and 2^12 is 51.2 lines. The first doesn't put enough text on screen to be useful. The latter has a lot going for it and some terminals did offer it, but the text is quite small and squashed. The intermediate size with 25 lines is just right.

Answer 4

Where did the 80x25 text terminal size come from?

From IBM punch cards. Very slowly, but relentlessly.

Before the mid-1970s there were a variety of line lengths in use. American typewriters were generally considered to type at 72 columns, although that was up to the user and anything from 60 to 90 would be seen. Teletypewriters and similar systems almost always used 72 columns, most notably for this question, the ASR 33, which was widely used on early computers. IBM moved to the 80-column format for their punch card systems in 1928, but the confused things by selecting a 132-column format for their tabulating printers only a couple of years later.

So by the late 1960s there are three widely used "standards", 72, 80 and 132.

Now we come to terminals. In the early terminal era, all three of these could be found. Notably, the Datapoint 3300, specifically designed to replace the ASR 3300 (3300, 100 times better!) and thus naturally used 72 columns x 24. But then the Datapoint 2200, specifically designed to replace IBM card punches, naturally used 80 columns x 12.

This was the norm for the era, not the exception. There were a wide variety of sizes being used across the market and no one gave it a second thought. Drove the programmers nuts, but now we have termcap.

Memory for holding the text in a glass terminal like the 3300 was generally constructed using shift registers. These tended to be small, so the memory for a "screen of text" required many chips. Using fewer chips was better than more, but there was no strong requirement to use a particular number of them unless you were going for the lowest possible cost.

Such was the case for the famed TV Typewriter. In this case, even a single wasted byte was too much, so this display used two screens of 32 x 16 = 1024 bytes. As new forms of RAM emerged that had "binary sizes", you saw a profusion of similar sizes - almost all of the early S-100 systems used 64 x 16 = 1024. This became a fairly widespread "standard" for the mid-1970s.

So by the mid-1970s, there were three different "standards" being widely used, 64, 72, 80. Some terminals also supported 132, those dedicated to accounting as they would generally end up coming out of such a printer, but the technical limitations were many.

But as the price of memory fell, and monitor prices as well - TVs were evolving with IC improvements as well - 80 x 25 began to take over as it was essentially the most common denominator of the various sizes then in use; it fit the IBM format perfectly, could hold a line of ASR, and was roughly the same as a typewritten page. Although it was not suitable for tabulating, few others were anyway.

While this was occurring, similar forces were acting on the printer market. The 132-column standard remained a significant force into the 1970s; IBM's printers starting with the 1403 all used this as their standard format, and when the first low-cost printers emerged, notably the Centronics 101, it used 132 columns.

But as the terminals began moving to 80-columns, so did the printers. By 1977, 80-column became the normal setting for dot-matrix systems and most LQ printers as well. 132 remained an option, but generally using a smaller glyph that lost quality. The Epson MX-80 cemented this standard.

So by the late 1970s the 80-column format from the IBM punch card had become the defacto standard.