In the days of mainframes and minicomputers, a common user interface was a serial terminal where each keystroke was sent to the computer, which could respond with an update to the contents of the screen.

At some point, IBM at least - maybe also other manufacturers - invented smart terminals, which had enough processing power to handle user interaction to the extent of filling out an entire form; only when that was done, did the contents get sent to the computer. This increased the number of concurrent users a computer could handle.

It seems to me that a smart terminal would need a microprocessor, so I would expect them to start showing up in the early seventies, but I'm prepared to be corrected.

When did they arrive on the scene?

  • 5
    "It seems to me that a smart terminal would need a microprocessor" -- in actual fact, it's worth noting that the Intel 8008 was designed to replace the TTL-logic processor from the Datapoint 2200, an early smart terminal, so you could argue that it was actually more the other way around...
    – Jules
    Mar 5, 2018 at 20:39
  • 1
    FWIW, sending every keystroke as soon as it was typed did not stop us from calling some terminals that did that, "smart." The first time I ever heard anybody distinguish "smart" from "dumb" terminals, they were talking about terminals that either did or did not have enough features to support Emacs. Jun 11, 2020 at 17:41

5 Answers 5


It seems to me that a smart terminal would need a microprocessor, so I would expect them to start showing up in the early seventies,

Not really, as discrete, specialized processors could do the job even before that.

When did they arrive on the scene?

TL;DR: Gradually between 1964 and 1971

As with every 'first' question, the answer is rather vague and needs a plethora of adjectives to construct a 'first'.

The use of 'smaller systems' with specialized programming as 'intelligent' subsystems can be traced back as early as the 1950s. Distinction between specialized computers (subsystems) and Terminals is a bit blurry in the beginning, but a rough timeline can be drawn. The following examples follow mostly IBM developments. There have been several others, and IBM wasn't always the first to introduce a feature, but in the long run they not only resulted in the widest usage but also reflected the best known instances. Last but not least, differences in introduction between competing systems where rather in a scale of month than years.

Further, we should clarify the term 'intelligent terminal' as some kind of device(s) allowing local editing/manipulation of data output from a computer before sending the result back for further processing.

With this definition a point could be made that already the punch card environment of the 1940s may qualify by offering local punching, reading, duplication, and repunch of cards to be fed back again. The more compact IBM 26 Interpreting Card Punch of 1962 does define local editing. But yeah, it's a stretch.

(modified) TTY are the beginning of individual terminals. They are the equivalent of a dumb terminal. Every character typed is send right away toward the mainframe. With an increasing number of terminals, mainframe side buffers/communication controllers where added to reduce interrupt load, making them somewhat less dumb by collecting a line before interrupting the host.

IBMs 1050, a printing terminal, introduced in March 1963, diverged (first?) from TTY like unsynchronized single character I/O and introduced a line mode. Here the 1051 Control Unit managed a line buffer. While each keystroke was directly displayed, a line was only sent to the mainframe when EOB (End Of Block) was pressed. CR did implicitly send an EOB following the CR. After sending the keyboard became locked until released by the mainframe (*1). Another important improvement over TTY with its 10 characters per second was that the used Selectric mechanics did allow a 15 characters per second output.

IBM's very first (graphical) terminal system, the 2250 of 1964 did also use a line/block mode when it came to text entry. While the terminal was direct connected to the Mainframes I/O channel, a local data buffer was used for editing. Entered text was displayed and could be edited in line mode. When a 'message was composed', as it was called back then, a mainframe I/O interrupt was issued to transmit the whole data block. To some degree the 2250 did set the lead for all terminals to follow, while it's direct impact was rather limited (*2).

IBM's 2240 of 1964 and later 2241 did continue what was set with the 1150. But without the ability of additional peripherals like card punch/reader or paper tape handling in favor of a simple low-cost approach to terminals. Instead of integrating a Selectric mechanism in a new case, controlled by a separate controller now a more standard Selectric with new logic could be used. The advantage was achieved due higher integration using SLT (Solid Logic Technology).

March 1965 brought what eventually could be called the first intelligent terminal as we see it today: The 2260, IBM's first CRT based text terminal. Unlike the 2250 it was raster based (*3). Here for the first time a whole screen or parts thereof could be edited and sent back when done. Line mode was thus replaced by a wider block mode. In a strict sense it was still not an all-in-one terminal, as the logic, handling and storage was contained in a 2248 Display Control Unit which in turn handled up to 24 terminals at once. The 2260 Unit itself was barely more than keyboard and monitor. The first 2260 'only' displayed six rows of forty characters each. Model 2 did 12x40 characters and Model 3 finally 12x80 characters.

September 1966 brought the 2250 Model 2/3 which now no longer needed to be direct connected to the mainframe I/O, but acted via a 2840 control unit over remote, serial line. (*4)

In February 1968 the 2265 got introduced. IBM's first terminal where controller and display where located in one case, close to what we today imagine as a terminal. Functionally it was the same as 1965s 2260, but now a single terminal was tied to a single serial line. Beside the 2260's 12x80 mode a more form entry orientated 15x64 mode was offered (*5).

Other companies did also work on intelligent terminals (-systems). In 1969 SIEMENS introduced the 8150 system. While it was, like the 2265, a single terminal per line, its electronics were still rather huge and confined in a heavy, tower PC like case. Display size was 20 lines with 54 characters each (*6). To my knowledge, the 8150 system was the first to introduce field delimiters and attributes, so forms could be displayed and cursor handling was done according to these fields. Even simple data local entry checks could be done by declaring a field as numeric, so only digits could be entered.

To handle these more complex operation a microprogram controlled discrete, specialized processor was implemented on 12 Eurocard like PCBs. In a simplified view, the microprogram was much like an interpreter processing the screen data for each frame, feeding the test according to the attributes to the character display logic. Display was done as vector output, so each character was just drawn as it came along. Keyboard input was handled whenever the cursor position was reached. The whole program structure was rather clever, albeit unusual from today's view (*7). Each Field descriptor did take up a character position and was displayed as a space. The later 8160 system of 1975 removed that limitation and added a few more features.

Eventually the largest 8150 installation early on where the 1972 Munich Olympic Games, where more than 200 terminals where connected to a single mainframe to collect data from all competitions and deliver real time information updates them to journalists.

Now, in 1970, in retrospect, another milestone was introduced: The Datapoint 2200. Delivery started in Summer 1971. Like the IBM 2260/65, display was 12x80, but unlike the IBM it was not meant to be 'a' terminal, but to emulate as many as possible other terminals. After designing their first product, the Datapoint 3300, a classic dumb glass-TTY, CTC realized that there is a market for compatible terminals. So they decided to go for a programmable system they could adapt. But instead of keeping it a closed system trying to earn a premium by adapting the emulation to new systems, they made it an open system with programming available to users. While the basic idea was to enable some local programming to improve data entry, customers soon used it as a desktop computer. The fact that they convinced TI and Intel in trying to fit their CPU design on a single chip still shapes today's computing :))

Finally, in May 1971 the IBM 3270 terminal system was introduced. Various models displaying 12x80 up to 43x80 and 27x132 were available. But more important, form handling was added. The rest, I guess, is history:)

Caveat: As said before, this timeline is (mostly) IBM orientated, but there where many more companies, during the 60s and 70s usually ahead of IBM.

As a final note it might be useful to explicitly note that the 'intelligent'(CRT based) terminal is not an evolutionary step from 'dumb' (CRT-based) terminals. This common assumption is wrong. Both developments happened in parallel. Dumb terminals are a rather straight continuation from TTYs, supported by the growing availability of local computing power (aka mini computers) and direct CPU interaction. Demand to handle more users (terminals) was satisfied by buying more computers (and partitioning workload along department lines).

In contrast intelligent terminals were developed to offload editing and screen manipulation duties from the mainframe to enable more terminals to be handled by a single machine. Intelligent terminals where created by departing from the TTY paradigm, not dumb terminals.

*1- After all, this already constructs a simple hardware implementation for a command line, doesn't it?

*2 - Not the least due its initial price of 200-300 thousand USD. No, not today's, but 1964 Dollars - make that more like 2 million of today's.

*3 - Scanned 'sideways' - the beam did not run in horizontal rows, but vertical columns. Yup, These are terminals, not TVs, so not limited to TV specifics.

*4 - Notable, it also introducing a character generator within the 2840, so the mainframe no longer had to send each output character as series of strokes :))

*5 - the 2265 was also the first IBM terminal system to use the ASCII character set. While transmission encoding was still BCD based, all ASCII glyphs could be displayed.

*6 - Like many manufacturers of compatible systems, SIEMENS had to offer more than IBM to convince customers (or more precisely, their management), so 1080 characters on a single screen instead of 960 is a lot, isn't it :)

*7 - Or in other words, it was clever and elegant programming instead of throwing code and libraries on a problem until it surrenders.


Arguably the prototypical smart terminal was the IBM 3270. According to this link IBM History the 3270 was first demonstrated on May 23, 1971. While the Intel 4004 was shipping already at that time, the 3270 didn't use it - and the 4004 really wasn't powerful enough to run a terminal like the 3270.


1970s - as pointed out above, 1971 was the advent of the IBM 3270, which I think qualifies as what you are asking.

But you are still making assumptions about how things work which is leading you to wonder something that isn't quite true - i.e., didn't they need a microprocessor?

3270 terminals had some intelligence in the terminal itself, but they were connected (meaning multiple ones) to a box called a 3270 controller. That is where the real processing took place.

It's really interesting to go back and look at the architecture of the old IBM mainframes, especially System/370. The mainframe itself was focused on computing as much as possible, and tasks like IO were intentionally offloaded from the CPU as much as possible. That architecture had one or two 'channel controllers', which actually did burst IO work inside the mainframe box. So, the 3270 terminal did what it could locally; a lot of the real work was done in the 3270 controller, which aggregated a number of 3270s, and that controller received and sent data in a very bursty way from the channel controllers, which then put data in/out of the memory for the CPU.

  • The mainframe itself was focused on computing as much as possible, and tasks like IO were intentionally offloaded from the CPU as much as possible. This arrangement was pretty common. For example, the contemporary CDC mainframes like the 6000/7000 series had packs of 12-bit computers called Peripheral Processors that offloaded I/O from the main CPU. May 15, 2018 at 2:05

A typical video display terminal includes a means of taking received bytes and storing them into a buffer while the contents of that buffer are being repeatedly read out and used to drive a CRT (typically by generating an associated sequence of pixels). Although typically the only things sent to a remote device would be characters typed on the keyboard, as they are typed, a terminal may include a means of sending the character at the cursor position to a remote device and advancing the cursor. This does not require very sophisticated hardware.

One such device I've used (probably in the late 1970s, though it may have been built before that) was connected to the on-line library cataloging system (OCLC--I forget exactly what words that stood for). During normal operation, typed characters would be sent to the display. Pushing SEND would lock out the keyboard, home the cursor, wait for a polling signal, and then start characters off the display and sending them until an end-of-transmission character was reached. The system would then await a response from the remote system and send it to the display, after which it would unlock the keyboard.

While such devices could have used a microprocessor or small computer to drive it, they could also be built without them. Such devices fell somewhere between what would typically be called "dumb terminals" and what would typically have been called "smart terminals".

Note also, btw, that terminals which included some form of buffering (but no other intelligence) could have relatively unsophisticated computers to be shared more efficiently than terminals which didn't. Some computer systems like the HP-2000 had a front-end which would buffer lines of data from dumb terminals and then send entire lines to the main computer at its convenience, but the front end necessary to interface a bunch of terminals was a computer almost as big as the "main" one. Terminals which included their own buffering could eliminate the need for such a front end.


The SABRE reservation system introduced 'smart' terminals, or at least semi-smart, block mode terminals (like 3270, but ALC bisync multidrop protocol) such as the Sperry Unimatic in the mid to late 60s. One could argue as well that the operator console of SABREs progenitor, the SAGE early warning system, is a smart-terminal ancestor based on vector displays in the late 50s/early 60s.

GE had a "Data Editing Display" terminal in 1964. There's not a lot of info, but it supposedly was an early block mode terminal with some local smarts: marketing slick. GE also made ALC reservation terminals in this timeframe.

The Tektronix 4002 came out in 1969, I think, and was really smart for the time because it was a vector display that required a lot of smarts to run. But it used all it's smarts to paint the screen; it wasn't block mode or otherwise what we'd think of as a 'smart terminal' later on. More like the SAGE console. It evolved into the famous Tek 4010.

My personal fav, the Tek 4207, came along in 1986. Would love to find one...or better a 4209. Ah, well.

Just goes to show...some things are hard to define.

  • "the SAGE early warning system, is a smart-terminal ancestor based on vector displays in the late 50s/early 60s" - No, SAGE was driven directly by the controllers on the main CPU. The only smarts in the terminal was the light gun, which counted up from some set value (refresh start?) and returned that value when the photocell triggered. There was a controller, but it was part of the mainframes and shared among terminals. May 11, 2018 at 17:55
  • @MauryMarkowitz - I thought the displays were driven by a separate PP attached to the main CPU. But you're probably right and thanks for the correction. May 12, 2018 at 14:54
  • I suspect that was true, especially for the remote radar-head readers (which were freaking cool, they scanned a normal analog display) but I'm not sure one could clearly point to where the CPU ends and the TS begins in the actual direction centers. May 14, 2018 at 13:32
  • @MauryMarkowitz - That's a fair assessment. Shows how tough it can be to define such things. May 15, 2018 at 2:01
  • Memory was extremely expensive back in the day. Text was normally drawn dynamically and refreshed from a block of characters rather than storing them as points which could then be displayed. This made graphics hard. Hence the use of storage tube displays which Tektronix was also using for oscilloscopes. Graphics and text could be drawn on the display which would hold the image until erased. Some displays such as the 4014 allowed both stored data and normal rapid refresh text at the same time.
    – hughk
    Apr 13, 2021 at 7:59

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .