Note that I have left the Linux part of Gentoo left out on purpose because it supports GNU HURD as well, giving even more choice to users.

Gentoo can be viewed as representing the apex of what the Linux distribution model can offer without turning into a venture by the user to create their own distribution. It is the logical end-point of customizability and control, and thus has a rather steep learning curve if one hasn't installed it, used similar minimal distributions or used it at least a few months. Thus, it is not well suited for the casual or even moderately enthusiastic user because it expects the user to read documentation and install instructions that are more detailed than those required by the likes of Arch Linux, Void Linux , or similar Linux distributions. What Gentoo offers in return is complete control and customizability which helped it stay relevant and used for well over two decades by the time I am writing this article. This will not be an exhaustive "review" of Gentoo, and neither will it go into the history of it. This will only serve as a quick reference for why someone would even bother trying yet another Linux distribution.

The reasons can be listed as follows :

1. Gentoo is a very minimal distribution

This puts it in the same category as the aforementioned Arch and Void Linux distributions, among some others. It does not come with almost anything out of the box and expects the user to install only what the user in question actually wants and needs. As such, those without at least some experience with the various programs offered by the Linux ecosystem will have to spend additional time researching packages instead of immediately installing what they need and going forth with the installation. The installation of Gentoo typically is in a couple of hours, so those wanting a quick setup need to look elsewhere, The upside is that the user controls what is installed and what is not.

2. Gentoo is source-based

This is its main point of distinction in the Linux world. Being source-based means most packages will be compiled rather than just installed and this will make updating the system take far longer than the typical minutes needed by binary distributions. The upside is that the user gets complete control over the software they install using what are called USE flags.

USE flags offer unparalleled freedom and control of the software by enabling and disabling the features offered by the program in question. For example, if the user does not use KDE, they can globally disable USE flags refering to KDE, this making the compiled binary more optimized and less bloated. Another good example is if the user uses a PC at home and does not use Bluetooth. Bluetooth becomes another point of vulnerability without a upside when it's not used, and this backdoor can easily be dealt with by simply globally disabling support for Bluetooth for the whole system (though Gentoo offers per-program control as well).

Another great feature is the clear separation of programs by software licenses, and if somebody would want their system free of proprietary programs, they can easily configure Gentoo within a minute or two by editing the ACCEPT_LICENSE variable in make.conf. With a single line being edited, the whole system will re-compile whatever is necessary to obey the user's will. This flexibility, coupled with the minimalism offered out-of-the-box, makes Gentoo an exceptional long-term investement, because the user both gets what he/she wants and since it was the user who configured the system, not a vendor or distribution maintainer, they also learn and remember how the system works by actively configuring it. This makes a sort of feedback loop where the user is both in control, but also rewarded for going deeper into learning how Linux distributions work. Gentoo is in fact, so flexible and so non-willing to force the user into any choices that it's sometimes reffered to as a meta-distribution. This is the natural result of offering a system tailor-made to the user's preference - each Gentoo system will be different and unique, with it's own unique USE flags, window managers or desktop environments, programs installed and so on.

My own reason for sticking with Gentoo despite uninstalling it twice was simple : due to the ability to have my system the way I want it, I can easily bypass age verification introduced by systemd by simply not having systemd, but rather, the default Open RC init system - and if some other mandatory feature I don't like ever gets introduced in any other software, I will be able to build it without those features enabled. This alone makes Gentoo worth it for me . It's clear seperation of what license groups each software belong to, and its ultimate customizability are the real killer feature. Everything else is just a bonus.

Gentoo also offers a first-party binary repository as well as official and unofficial repositories.

3. Gentoo offers easy tweaking of the Linux kernel

A often heard argument is that Gentoo offers the user to configure the Linux kernel by themselves. While this is true, what people often don't know is that, technically speaking, any distribution offers this.

What sets Gentoo apart is the ease of how this is integrated : users can choose a pre-configured binary kernel (ideal if they are new and are already overwhelmed by all the choice and customizability, and it works perfectly for those who wish to not compile everything in a machine which is either low-powered like a notebook or just wish much faster updates), or they have further two options : compile the kernel as it is in it's default state, or manually tweak it. Going the extra mile of having one's own kernel, with only the features the computer actually has and supports, offers huge benefits seen in the next argument.

4. Gentoo rewards minimalism

The less software there is to install, and the more minimal it is, the faster Gentoo will compile.

This rewards those who wish to optimize and learn how their system works and makes them better users in the long-term. I often find the argument that Gentoo takes too long to install only partially right: yes, it takes much longer than a typical binary distribution, but all the user really needs to do, once everything is set-up properly, is to do a big update during the evening right before bed. Even with my low-performance Ryzen 5 5500U and 16 GB of RAM on a cheap Acer Aspire laptop, it takes one evening to compile everything from the fully bloated Linux kernel to all of my programs (I use sway and mostly terminal applications, and use Brave and Firefox as binary packages). A modern system, especially with a binary kernel or a custom kernel, should take just a few hours. A typical counter-argument is that the performance gains obtained by compiling are trivial - this is true. However, the point of Gentoo was never pure performance, but rather control - performance is just a nice side-benefit, and it's a true testament of the modern compilers that they can so well optimize the binaries without having the user or administrator deal with any aspects of the compilation.

5. The Handbook is one of the most well-writen works in all of open-source.

Even just reading the Handbook without any intent to install Gentoo will offer even a total newcomer to Linux an opportunity to grow in their knowledge base from nothing to a reasonable level of profficiency within a hour or two. It is not an overstatement to call it one of the best guides to Linux or even operating systems avalable on the internet: it is reasonably concise, direct and simple to read, and explains concepts just enough so that the user understands the basic premise, but not so much as to overwhelm them. This is in contrast to the old Arch installation guide, which is scarce in explenations, and is thus a popular video topic for Linux YouTubers who have to compensate for it's lack of context offered.

6. Gentoo is stable

I have never had a single bad update or system crash despite my lack of experience with it in the beginning. I gave up on Arch years ago because I had a few bad updates which either made the userland annoying, or even had boot issues. With Gentoo, despite more reasons things could break, I actually never had any issues or worries a update might derail my plans for the day. This alone made it the only rolling release distribution I would use, since Void and Artix didn't offer close enough or fast enough mirrors, respectivley. Then, after some time I returned to Arch from Fedora, when the introduction of optional age verification on systemd made my case of sticking to Gentoo closed. Earlier in my experience with Gentoo, my main issue wasn't anything related to Gentoo itself, but rather, the poor thermal design of my cheap Acer laptop, which has high-pitched fan noise which annoys me a to great extent. I have decided the fan noise is worth it if what I run actually respects my wishes, and again, this is where nothing even comes close to Gentoo.

In conclusion

Gentoo is not for everyone, but for those who value control, there is nothing like it. Installing Gentoo is not harder than installing Arch, and control offered far exceeds it. It teaches the user how a (GNU/) Linux system works and this knowledge can be used to a certain extent to other distributions as well. No matter what new mandatory feature the user might not like gets introduced, Gentoo offers alternatives far beyond the reach of any binary distribution. Despite it's time-consuming installation, actually running a Gentoo system daily is not too different from any other distribution once the setup is complete, and the user will benifit in control, optimization, a tailor-made environment. Through time, a understanding of how operating systems work on a level far beyond the typical end-user will develop. Just reading the handbook alone will make a newcomer to Linux far more informed than just sticking to a mainstream distribution. In this sence, even just raeding the Gentoo Wiki or installing Gentoo in a Virtual Machine will be worth it for the experience and knowledge gained, even if the users ultimatley decised the listed benifits aren't worth it.

Introduction

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.

A very brief history of the Command Line Interface (CLI) and Graphical User Interface (GUI)

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.

The merits of using the terminal as opposed to a GUI

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 upsides can be listed as follows:

1. 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 :

   1. 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).

   2. 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 :

      • Linus Torvalds
      • Dennis Ritchie
      • Brian Kernighan
      • Ken Thompson
      • Richard Stallman
      • Eric S. Raymond
      • John Carmack
      • John Romero
      • Chris Sawyer
      • Sid Meier

      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.

   
   
2. The performance toll of terminal programs is trivial
   

   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.

   
   
   
3. Terminal programs coupled with a keyboard-driven Window Manager make the usage of a computer more ergonomic

   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.

The downsides of terminal programs

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 :

1. Terminal programs require learning commands, shortcuts, abbreviations, flags, and occasional reading of help and man pages or online documentation.


2. They are not always packaged in the operating system's default package repository or app store, leading to the hassle of adding third-party repositories, manually downloading packages or building and compiling from source.


3. They might be simplified alternatives to fully functional graphical applications (such as CLI clients for streaming music) and thus lack a specific feature which is either not being actively worked on or was never planned.


4. Users unfamiliar with the Vim mindset may be confused by the workflow some terminal applications expect out of the user.


5. Some CLI tools require setup before they are usable (a notorious example is Neomutt)).

In conclusion