Then why isn't it done more often? I suspect part of the reason is that most gui frameworks are not really designed for making dense economical interfaces.
> you probably don’t need a user interface on prod. You need a command line interface on prod that
I don't need one, but I often want one. Being able to run vim, htop, etc. on servers is quite useful. Also, it isn't just prod servers. It's also nice to run tuis on VMs and containers that don't have access to graphics.
> I’m not really building applications for other people to use. I’m building them for me. TUI affordances are an awfully big hit to take to get Linux users of programs I don’t even want to publish.
Ok. That's fine. But then why are you trying to convince other people not to make TUIs? If I make an app you find useful, wouldn't you prefer me to make a TUI you can run on your Mac to a linux-only GUI?
Because it tends to require a lot of thought and effort along totally separate engineering pathways than most of the actual functional coding. Good UI design is not easy, and the skills to do it don't directly overlap with good coding skills. It's hard.
> I suspect part of the reason is that most gui frameworks are not really designed for making dense economical interfaces.
Don't blame the tooling for a broad failing of many developers. It's because constructing a genuinely dense and economical interface for most apps requires considerable time and effort, and frankly, most developers are crap at understanding how users other than themselves use applications. Those that aren't crap at it tend to have worked in large teams with dedicated UX people to help drag them away from their preconceptions.
I’m with Tom on a lot of what he says. This is a nice reminder to take another shot at this.
On the other hand, they are easier to build in a cross platform manner.
Linux is probably the most difficult platform to build GUI for, because of all the fragmentation, X11, Wayland, all the different flavors of GUI toolkits, driver issues, window managers issues, font issues etc.
TUI are a bit like web apps in that regard, using the terminal instead of a browser to abstract the platform.
a lot of boomer and millennial dev users love TUI bc that's what they grew up with. part of A\'s early success is hit that sweet spot and triggered a culture shift late last year.
as those age group phasing out, web ui will be dominant
UIs are also useful for information that is best represented in a UI. keep using those too.
You can bend each to be more similar to the other, and that's good too! Sometimes there is a good use case for that.
Sure it looks pretty but it’s impossible to drive from the keyboard without mutant hands and savant level of memory for arcade combos. That means the entire OS relies on being able to drive the UI from a positioning device and thus you have to have the coordination to piss on an ant off a moving train. Which is terrible when the input devices are a touchpad, which varies so utterly frustratingly depending on whether it’s in the laptop or over Bluetooth. That and a mouse which is designed by a complete psychopath. That leaves you with third party options which require apps to not suck and they still suck. Scrolling on Logitech options anyone? Even LinearMouse can’t fix that shit.
Compare windows which works absolutely fine from any keyboard or any mouse and is discoverable and consistent. Also no mutant hands required.
TUIs are closer to windows than macOS. And that’s a good thing.
I did the last ten years on a mac and decided I was just hurting myself. Give me windows or a TUI. I notice Linux desktop environments tend to copy windows with respect to keyboard and discoverability too.
They don't support standard GUI shortcuts. They don't support drag-and-drop. I can't double-click a file and have it open in a TUI. They don't integrate with spotlight metadata. They don't ship document icons. They have terrible support for accessibility APIs. And so on...
Ctrl c does 2 completely different things. Terminology is different. Etc.
Problem is. Terminal applications standardised in the 70s. Guis in the 90s. Although that's being undone by web apps, and the influence of touch screens.
There's more on this here: https://sockpuppet.org/blog/2026/05/12/emacsification/
EDIT
> CLIs have purposes for which they’re irreplaceable. Building a CLI is almost always a good idea. Building a TUI almost never is.
Oh, right. I can see that, but I go the other way: When I have a CLI, don't give me GUIs; give me files. Actually, just give me files and daemons. I'll do the rest, thank you!
- They encourage developing simpler, information-dense, and keyboard-driven interfaces, which I tend to prefer in general.
- I find them more fun to write, and less aggravating to maintain and debug, than interfaces built with GUI toolkits.
- Most software I write for personal use is going to be run in both a Linux and Mac OS environment (and a lot of the time on a headless server to boot), and a TUI often has less fuss than other options (at least, IME).
- I think monospaced text in a terminal just looks cool.
YMMV, of course, I'm just sharing my own experience and perspective.
Anything that lends itself to keyboard input, piping, text manipulation and a bunch of other things are so much faster if you're equally proficient in both input modes.
It is, of course, completely subjective, but I know there are a fair number of people out there who agree with that statement.
If there was a powerful, information dense, configurable docking/tiling, multi-application-composing GUI framework (all things a good terminal can do) then yes, build everything in that. I’d love to see it.
Until then, TUIs are vastly better than another Electron app or Mac app using UI frameworks that are trying their hardest to look and act like basic phone apps.
So even professional tools all follow industry design and product trends which are too simplistic, don’t give you the info you need, and are optimized for abstract brand design or chasing metrics for the company, and not optimized for “how do I let my user accomplish their task as fast as possible”
I love how I have to configure font size and family only once in the terminal emulator and not for each program/GUI toolkit again.
Of course, there is no way to replace graphical-heavy programs (GIMP, QGIS etc.) with TUIs.
- Some are very good tools that have no clear GUI superiors. Vim, Emacs, Mc for example. GUI wrappers over these don't make them better.
- Efficient, meaning fast and limited in scope so you can learn the whole thing.
- The muscle memory you develop is transferable to any new platform or OS you use.
- Often free and OSS so they can't be taken away, making the muscle memory a long-term investment.
- If you work in the terminal for any other reason there's less context switch.
The low bandwidth / high latency lossy link problem is still a major issue. Cell phone service is sufficiently shitty in the area I live in that I have to use mosh to get a usable remote connection many times a year. Mosh is also quite useful while travelling! Got a crappy connection on a train or airplane? No problem. I have so much muscle memory with the mutt email client that nothing else has ever come close. Where's the equivalent of mutt's limit command in Thunderbird?
Try getting a usable VNC session when your cell phone hot spot is hitting 2-30 second ping times (yes -- thirty seconds) with only a handful of packets getting through.
Version 2 of the Amiga's operating system did a great thing in version 2 of AmigaOS which explicitly spelled out what conventions to apply (see Amiga User Interface Style Guide at https://archive.org/details/amiga-user-interface-style-guide). Modern GUIs that have weird meaningless buttons are infuriating. Even moreso when they lack obvious keyboard shortcuts.
- keyboard can be used for pretty much everything
- less visually busy (no/less animations, background images/color variations. often close to plain text on plain background)
- more information dense (fewer things hidden behind hamburger menus, modals, drawers, etc)
- more/more easily customizable and documented
- more often can provide data directly into the terminal that I'm working in, so don't need to copy/paste through windows etc
these aren't necessarily impossible for GUI or universally true for TUI, but maybe I would guess just more an artifact of there being types of people who prefer working in the terminal who are then more likely to make TUIs, and I share their preferences more.
I enjoy the usability and self perceived speed of not having to leave the console or reach the mouse to move a pointer when a cople of key presees is enough.
It's a matter of choice, I know, but I also think there is a genuine case for text over graphics. I see it everyday on businesses that keep old cobol tpvs at the cash, the speed at which the clercks check inventories or perform other crm activities is unmatched to mouse or touch interfaces
If you want to automate from the perspective of what's on screen, tuis have no metadata. A button in a gui does have metadata associated with it, so you could automate 'click button x' where as in a TUI you'd be limited to clicking 'position x,y'
For GUIs you have to handle the particular metadata of a given framework, if it exposes metadata at all for the controls. Otherwise you're dealing with raw pixels which is an instant nightmare, though not so much now there are visual LLMs, but you're still paying for the tokens and/or extra processing.