Why does the input cursor always go from the top to the bottom in a terminal emulator?

The history is that early I/O devices for computers were teletypewriters. These were typewriters which could be connected electrically, so keys pressed would not only put print on paper, but also send information to another device (not necessarily a computer), and that other device could instruct the typewriter to print characters on paper without involving keys.

This has a number of consequences, including:

• input and output are combined on the same medium “of record”, in the order in which they are produced;
• input devices can in some cases produce their own record (see stty echo);
• most relevant to this question, since the systems we use now are mostly based on practices developed in the US and Western Europe, output starts at the top left of a sheet of paper or whatever representation thereof is used.

When screens were added (not necessarily in stead of paper), they were used as a viewport on infinitely-scrolling fan-fold paper. Old habits die hard, and this has survived to this day in terminal emulators (which are by definition throwbacks).

Other input models do exist, including on glass terminals — for example, IBM 3270 terminals are block-oriented and typically used with applications that manage screenfuls of information rather than scrolling information.

The shell isn’t the only way to interact with your computer, and some programs supplement that with alternative models. One example is “orthodox file managers” such as Midnight Commander (inspired by Norton Commander, on DOS PCs); these commonly have a command-line prompt in a fixed position at the bottom of the screen, and provide access to the output in a separate view:

Believe the way it is is the most natural way. At least for people reading left-to-right, top-to-bottom.

A terminal can be viewed as an eternal book / log. It could of course be arranged in reverse, but that would cause some issues. One is that one often work with streams. One would also need to constantly re-arrange the buffer / view.

One problem with multi-line output would be that the end of output could be below the view, thus after a command one would have to scroll down to see. One could of course argue the opposite - that now one have to scroll to see the top, but believe one on average are more interested in last output.

Focus is at bottom because that is where last action is / was.

With command line at top, one would also constantly need to shift focus from top to bottom. Say you do tail -n 10 some_file. You would read the 10 lines, then shift focus back to top.

A command printing information in intervals. How should one do this? Print - read that section. Move focus up, read down to where previous print started, move focus up, repeat.

Believe that would be more prone for missing things then reading top-to-bottom.

Or say one do a command that results in 10k lines. Should one scroll down to view end result? Or say you compile a program. How should the output be arranged?

One have programs that utilize static "comand line", for example terminal IRC clients (irssi, weechat, ...). Here one (typically) have command line at bottom, and log top-to-bottom above that.

In effect a terminal is the same when it screen is filled, though one are not limited by the height of a input line.

The way it is is

1. the simplest way by far (implementation wise),
2. for most (I believe) the most natural way to read information.