Contrary to what the layman might think, the terminal is not only relevant in the 21st century, it is, for a lot of operations, still the most pragmatic and efficient way to use the computer.
UnixDigest provided an excellent discussion on what differentiates the terminal, the console and the shell, which you can find here. (there's also plenty of images relevant to this topic). He is by far the greater authority on this matter because his whole life and career has been in IT : what you will see here is just an end-user (whom laymen would call a "power user") explaining his own reasons for using the terminal for most of his needs. I really do recommend following his website, as it was a major inspiration for the layout and look of my own website.
This article focuses on the practicality and reasons for why it should be at least considered by anyone willing to
optimize their usage of their PC - it is not an exhaustive history or any technical discussion on how the technologies
in question work. For the purpose of keeping this article brief, we will only focus on the modern usage of the terminal after a brief
historical introduction, while the technical details and full history will be provided via links.
Up until the invention of the Graphical User Interface (GUI), manually punching in or typing commands was the default. In the very beginning, there was the Teleprinter, better known as a Teletypewriter or simply a TTY. It was, for all intents and purposes, a sort of typewriter-like machine (at least on the outside) which used the keyboard for inputting commands to a computer.
This method of inputting commands (outside of using a Punched card until the 1960s which preceded it) was the default until the early to mid 1990s, when the Windows operating system started dominating the PC industry. Between these two points, from the Introduction of the computer and using Punched cards, to using a teletypewriter, computers went from being Mainframes (huge computers that would demand a large room and often dozens of personnel using them, famously dominated by IBM and DEC in approximately 90 % and 10% ratio, respectively) to being Minicomputers (something in size which would be comparable to a large refrigerator) to Microcomputers which were the dominating force starting in the 1970s until the 1980s.
Then came the rise of the Personal computers in 1977, such as the Apple ][, TRS-80 and Commodore PET. There were others in this time as well of course, but these big three started the PC revolution and were all still using manual input in a console despite the Xerox Alto pioneering the GUI in 1973. The explosion of popularity of the three aforementioned computers and their ecosystems, as well as the 1981 introduction of IBM's personal computer (hence the term PC) which stormed the industry and prompted a cloning war, didn't stop the console from still being the default user interface in operating oystems such as OS/2 , CP/M, UNIX, DOS and later BSD and (GNU/)Linux. The only thing that changed was that the user was typing commands to his own computer, not a machine shared by multiple people. Users had the choice of typing commands or using a Text-based user interface.
Then came the rise of the GUI, most notably the Apple's GUI on the Lisa and The original Macintosh (better known as Macintosh 128K) in 1983 and 1984, respectively, X window system also in 1984, Windows 1.0 in 1985, the Presentation Manager for OS/2 in 1987. The manual input via commands was quickly relegated to the terminal emulator, not the console, though in most cases the GUI was optional. Only later with the rise of Windows 95 did the user get the GUI out of the box instead of having to launch it from the shell (the Lisa and Macintosh were exceptions). With the dominating popularity and success of Windows 95 and its descendants, the manual input of commands was left in the eyes of many as a legacy feature, not something the common man ever needed to touch.
However, the Terminal emulator lives on to this day, and its popularity, while niche outside of certain use cases such
as running scripts, is alive and healthy. There are more than enough Text-based user interfaces being developed to this day,
and modern utilities that replace the GNU, UNIX, or other core utilities which further expand the functionality or ease of use,
such as adding color output to previously monochrome output, or being written in such a way to be faster or more secure. In other words, while the world of the (virtual) terminal is niche compared
to the mainstream, if one dives deep, they will find programs for almost everything, from the aforementioned core utilities replacements, to browsers, music players,
IRC chat clients, RSS feed readers, file managers, torrent clients, and more.
Note that instead of terminal emulator, I use the term terminal for simplicity's sake. Due to the nature of modern computing, while living in the command line without any graphics is very much possible, it's too limiting for most people, as the access to the modern Web requires graphics and simple HTML parsers and browsers such as Lynx, w3m and similar programs are not practical. A good compromise is a simple Window Manager coupled with terminal applications.
The terminal offers an environment that is as minimal and distraction-free as possible
Plain text (and occasional ASCII if needed) is as about as minimal as computing can get without actively handicapping the user. This means that dynamic elements such as animations are almost totally thrown away, and what is left is the actual content, not the form. Even though someone who is used to a GUI all their life would consider their environment minimal (such as using a minimal wallpaper or just a solid color for one), the GUI of an operating oystem still relies on the abstractness of the icons to present meaning to the user instead of words. Getting rid of animations helps, but the cognitive load will always be bigger in the case of a GUI, and even a TUI. What is left is a situation where subconsciously we have to process the abstract meaning encoded in the icons instead of the semantic meaning of words, and when one gets used to the terminal, he finds it much less distracting. Laymen who see the terminal for the first time often feel overwhelmed because of the lack of elements on the screen, not because of it. This is the result of learning and getting used to the number of elements creating the perceptive field shown on the screen. Conversely, those who would have used the shell or terminal for long periods of time might find a GUI endlessly exhausting and overwhelming (such as the case with myself). I suspect Introversion and its effect on stimulation-seeking to be a notable factor here, as the Reticular formation has a crucial role in arousal levels.
The GUI was designed to help bridge the abstract nature of computing so that it can be used by the tech-illiterate, and in this regard, it did indeed succeed. However, we are not going to the other extreme and actively hiding error messages from users by telling them "something's wrong", perhaps followed by a vague code instead of giving the full output somewhere on screen such as the case of Gemini's web-based interface, or just telling them we're "Getting their PC ready" when installing Windows. While these do indeed help the tech-illiterate by not overwhelming them, they also actively handicap their ceiling because the goal of most people is to arrive from point A (booting into the system) to point B (finishing a report in Microsoft Word). It is natural for most people to view this "excess" information as noise on their way to do their job, however, there's two main issues with this :
Hiding error messages increases frustration
This is the result of the fact that the source of the obstacle now appears unknown, which immediately increases frustration. We naturally get more frustrated if the reason for why we can't reach something seems arbitrary, which in the case of hiding error messages, showing just an error code without explanation or showing loading circles instead of direct output.
With a CLI tool, this is usually avoided entirely. The errors are printed and the user is expected to do their work in understanding them (or these days, ask a LLM for help).
Overcoming obstacles and dealing with frustration by problem-solving increases the understanding of how a given topic works. GUIs often discourage this.
This is another universal principle, and the push for abstractness and "ease of use" just ends up handicapping the user in the long run, as mentioned previously. The reason why older computer users are so much better at troubleshooting or finding their way through problem-solving is the natural result of countless interactions between the user and the computer, in which there was an obstacle which needed to be dealt with. As computers became more mainstream, the need to make User Interfaces accessible for those uninterested in how computers worked increased, and thus, a positive feedback loop was created which resulted in each computer generation becoming more and more illiterate as time went on. People often talk about the DOS generation and great programmers, such as :
There's of course, many others. This is just an example.
What do all these men have in common?
All of them had to overcome technical obstacles in order to achieve their goals. In the process, they grew in their understanding of the fundamentals of programming and the limits of both hardware and software.
Today we have the luxury of well optimized compilers, the seemingly endless abundance of information and tutorials on the Internet, computers orders of magnitude more powerful than the top of the line machines that were available to million dollar businesses and even governments, and yet, the software is as unoptimized as ever (a great example is the Video Game industry which deserves to crash), treats the user in a condescending manner ("Hi, we're getting your computer ready for you"), gives arbitrary or non-existent feedback about what's behind the curtain (and wishes the user never knows or understands what's beneath), and takes comical amounts of resources (for example, the idiocy of programming the Start button in React). This conveniently brings us to the next reason the terminal can be considered superior.
It's hard to imagine a single terminal program to take more than a couple dozen megabytes of RAM, except maybe Vim or EMACS when these are fully configured or we're talking about their distributions. Most of terminal programs are written in C or Rust, and thus their performance impact is about as optimized as possible. Just having something graphical instead of rendering text already increases the demand on hardware significantly, and this is one of the reasons why Linux and BSD operating systems have a well-deserved reputation of being able to run on decades old hardware. If it wasn't for the need to use the modern Internet so much, most machines would also be simply usable for decades to come. As long as there's no heavy work involved, and if the user theoretically doesn't even use the Web that much, even a computer from the early 2000s or even 1990s can be used efficiently, and we're still talking about a GUI here. Even if it's a modern machine running a simple window manager and the user prefers a terminal-centric workflow, the footprint will almost certainly take less than 800 MB of RAM, and this is with the equivalent functionality of a regular Desktop Environment. Even the large and heavy ones like KDE Plasma typically don't exceed a gigabyte, yet something like Gnome takes sometimes over a 1.5 GiB just upon boot. With a simple window manager and terminal utilities for almost everything, it's easy to fall below 500 MiB, especially if the Linux distribution in question also has few jobs at boot. A well optimized Gentoo system with a simple X server can easily take less than 100 MiB of RAM, for example, which is unimaginable in today's computing world to those who are accustomed to having their Start button take more RAM and CPU usage than a well optimized graphical server.
This can make the need for a mouse almost totally redundant (or in my case, actually redundant, but this depends on the needs of the user and the workflow). Since the primary way to interface with terminal and TUI applications is the keyboard, combining this with a Window Manager which has integrated keyboard shortcuts (or even a full Desktop Environment which offers this functionality) allows the user to never move their dominant hand away from the keyboard, and ideally, the home row itself. The famous H, J, K, and L keys might have been chosen because Vi's creator used a terminal without the arrow keys, but the never-ending popularity of (n)Vi(m) ensured that programmers and users wished to deploy these keybindings and even entire workflow to other applications, resulting in good support for an almost universal way to navigate with the keyboard most if not all of the essential elements inside a TUI or cli program. Good examples include web browsers such as Qutebrowser, w3m and lynx (for the Chromium-based browsers and Firefox there are extensions like Vimium C), Window Managers (almost all of them include the HJKL navigation by default), RSS readers such as Newsboat, E-mail clients such as aerc and neomutt, and so much more. For a user who intends to optimize their workflow with speed and efficiency (and be willing to develop the muscle memory for it), terminal applications coupled with a keyboard-driven Window Manager are able to never move their hands from the keyboard and combine the distraction-free workflow with an ergonomic and quick way to use their preferred operating system in a manner that seems like a very logical continuation of the previous tradition of only using the command line for everything - in fact, it feels like entering a parallel universe where the mouse never took off. This is of course very dependent on the workflow : those who use graphical editing programs or video editors might have a limited use of this. Still, if we consider these use cases as not representative of the general population, this workflow would in theory be optimal, but due to engrained learning to use a GUI, it will forever be a niche way to use a computer, despite all the benefits. Ergonomic keyboards would certainly take this theoretical ceiling to the maximum possible extent.
Despite all of the above, there are valid reasons for why terminal applications aren't more mainstream or at least aren't enticing to potential users. It should be noted however, that the downsides aren't nearly close to the upsides
in terms of the overall impact of the user experience, once the shift in mentality has been established. Most of these are a simple result of the following :