Additionally, I can with very high confidence run TUI software inside an ssh session to one of my headless machines, and then further within gnu screen or tmux detach and later resume a session with everything I was doing. Even if I switch from my laptop to my desktop, or want to leave a bunch of stuff waiting for a week and come back to it later.
Once you get the key bindings for screen or tmux thoroughly memorized it's very easy.
Why this is preferable? I would rather have the apps I use represented as a list of apps in my system (drawing on a couple of decades of established UX conventions for how they are displayed and how I can interact with them), the web content I'm reading represented as tabs in my browser, and my terminal sessions represented in my terminal. You present the destruction of this simple separation of concerns as a benefit, but don't explain why it is one.
But then a load of others will complain about electron apps.
Further you then have an os within an os. You need to remember to look in your bookmarks, not your start menu. And you're basically throwing away the window manager too.
I was going to post this but you beat me to it. I think we need the folks whom do not enter the terminal to start using it instead of the other way around.
The LLM fetishists really do themselves a disservice with these wild, over-the-top statements about AI capabilities. I’d be willing to bet money that giving Claude a screenshot of part of this blog post would not producing “something useful” for any reasonable interpretation of useful. This reminds me of a line from Peter Diamandis’ Abundance (basically the only thing I remember) that described Google using a “stroke of HTML” to organize the worlds information.
One of the biggest upsides of TUIs over GUIs is that I can run any number of TUI instances.
Meanwhile a GUI's developer has to decide to grace me with the ability to even open more than one window. "A tabbed interface will be sufficient!" -- yay, I'll never be able to view two screens of info at the same time.
What?
99% of my programs I can open more than one window by just executing the program as normal multiple times, the only ones that enforce a kind of singleton execution are things that also acts as a kind of server, one example is Everything search, but it has a "Open new Search window" for multiple windows.
And that is the default, you have to explicit code in a lock/global mutex thing to block multiple instances.
vscode, electron app, no problem opening multiple windows.
Geany, gtk app, no problem opening multiple windows.
Building software for yourself - and only yourself - is a super-power.
I can see how LLMs help.
I wouldn't want to maintain software for other people entirely vibe coded. I think I might think again about native app development for my own needs, if it's kind of disposable.
Spent 2 minutes skimming, didn't manage to find a single talking point. I've no idea what the thesis is. Seemed like a list of things this person built.
People talk shit about LLM writing. Well, here's a prime example of why I like LLM-speak. Does this article have personality? Yes. Attitude? Yes. Is it structured and accessible? No.
I'll take clarity over personality any day of the week.
That's a false dichotomy. If you launder rambling pointless prose through the llm you don't trade the personality of the writing for a well reasoned argument with clear points, you just lost the personality and gained shitty writing. LLMs aren't magic and can't make your point for you if you don't have one to begin with in the prompt. Garbage in garbage out.
I disagree. An editor can definitely make a piece of writing clearer without further input from the author. I often use an LLM to do that.
Of course, I didn't mean to imply that there's a dichotomy between personality and clarity. There's a dichotomy between ordinary LLM writing and personality.
Haha, no. For a while, many years ago, it seemed TUIs were indeed on the way out, but then they were relived by the awesome work of people who wrote GPU-accelerated terminals, widget libraries, who extended terminals with more colors and the ability to show Unicode and graphics.
The main thing I like is that TUIs are guaranteed to be navigable by keyboard. So many non-TUI apps don't include shortcuts at all for critical actions. It makes the first week of using the app more efficient and the entire rest of your life less so. Add on to that, I can probably run a TUI on my server. Or my cloud instance. And in my sandbox. Over SSH.
So: do make TUIs and bind their keys to Vi-like shortcuts as much as possible and I will use your app every time over a GUI app.
Pro tip for Mac users - install Karabiner and bind right-Alt + jklm to cursor movements. Immediate VIM navigation through the whole OS.
To me TUI have a better user experience than graphical applications. And considering the amount of companies that are still using decades old AS/400 systems instead of new ERP system I'm probably not the only one to think it like this.
First, a TUI is usable with only the keyboard. Moving the mouse is a waste of time, and if you are using an application multiple hours a day, it can lead to being more productive.
Second, a TUI has no useless animations, elements, etc. It's not pretty, you have on the screen only the stuff you need to do your job, and you are not distracted by useless elements.
Third, a TUI works beautifully in a client/server world, where you have one central computer and dumb clients that connects to it, and the connection can be a simple serial connection as well as a network connection. It can be rendered even with an ESP32, making it suitable for embedded HMIs and all kind of computing scenarios.
Lastly, the user can choose the font, the colors, the size of the font that are best for him, usually a monospace font that it's surely better to read information multiple hours a day.
To me it's the opposite, GUI interfaces were born to make it intuitive to use a computer, but are not as efficient as TUI in terms of productivity.
I like TUIs, and I chose to build e.g. https://taskusanakirja.com/ as a TUI for a couple of reasons, some of which are in this article and some not. Cross platform compatibility was a big one since at the time I started building it I didn't actually have a Windows or Mac machine handy to test this out.
One thing I think which is overlooked is the raw feeling of speed a good TUI can give you. The lowest grade consumer laptop could probably download my little dictionary program and still get true search-on-keystroke performance, because there is virtually nothing slowing down that path, no animations, no nothing. Now most of that comes down to the data structures involved and making sure nothing ever has to go over a network, but I still appreciate the sheer simplicity of the approach.
It's also nice to know that I can probably recompile this same exact code 50 years from now and still get it to run exactly as intended, since GUI frameworks have waxed and wanted in popularity, but terminals truly don't seem to be going anywhere.
I like TUIs a lot and I use a TUI instead of a GUI as long as there is one available, but please note the main point of the post, the very last sentence
> I barely think about these things as “apps” (I have no intention to distribute them). They’re artifacts of me making my computer do stuff for me, the way I want it to. As a Unix nerd, I’ve always been able to do this, in the language of the command line. Now, it’s just as easy to do that kind of work with graphical interfaces.
And so the author (second sentence of the post)
> I built my first serious Mac application a few months ago, and since then I’ve built more native UI thingies than in my entire career prior to that.
I still build my personal stuff either for the command line (not even TUIs) or in a HTML page but I can see the point of creating a native app. Unfortunately there are some drawbacks: I would have to create the app for GNOME Debian and for Android, while a web app runs on both, and I would have to go all in on vibe coding because my last serious GUI programming has been in the 90s with Motif. The latter point is more or less the point of the author (the LLM does it for you) but it means that programming personal stuff will cost money paid to the LLMs companies. More and more money at each price hike and the multi thousand dollars box to run local models only makes the expense happen immediately instead of diluting over a long period.
Yesterday I was flipping between some TUIs, native apps, web apps and an electron app. I think it was only because I was trying to do a lot in each of them I became really aware of the latency lag in some of these.
There are real advantages of TUIs: less CPU; sometimes I want to be using a personal TUI on a personal dev server quickly from a work laptop at lunchtime and an ssh + tmux + TUI is perfect; most modern TUI libraries are significantly less painful to work with than most modern web app frontend libraries; I can change the font size of my terminal easily if I need to, more easily than native (but not web app). But by far the biggest, is they just generally tend to be very fast and responsive compared to everything else.
If you want to live only in the terminal, you can also use one of the text-based browsers [1] instead of Chrome, Firefox, etc. browsh [2] can also play YouTube videos if you'd like.
You can also just use the system console with tmux or GNU screen if you absolutely don't want any graphics at all.
The TUI programs usually do not consume a lot of resources. They are also very fast and optimized for keyboard-only navigation.
What do you like about them? I disagree, but so many people seem to like them that I assume I'm missing something. The main one I've heard before is that they work nicely over SSH, but I assume there must be more?
I personally like making (and using) TUIs because:
- 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.
IMHO the rise of TUIs is heavily correlated with the near-abandonment of professional quality graphical interfaces.
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.
In addition to what other people have said, the terminal interface is cross-platform and very stable, so TUIs need little or no maintenance to keep working.
- 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.
As someone who works on a very GUI-centric OS (i.e. Mac), TUIs just don't integrate very well with the rest of the non-Terminal ecosystem.
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...
TUI is a kind of self defense. big corps create and kill gui frameworks faster that one can learn them. Browser based ui is a real waste of resources (and also evolve in a absurd pace). The Console is a last resort to write small (understandable) gui that work on many platforms.
Are the TUI apps built on TUI frameworks? Do the TUI frameworks last longer than the gui frameworks you mentioned being quickly killed by "big corps"? In the Windows space, WinForms, WPF, WinUI are likely the biggest examples of gui frameworks, especially from "big corps"; they've been around for decade(s) and have not been abandoned (/ they continue to be supported) - how do TUI frameworks compare? On the other hand, TUIs may be better for things like running over SSH, and for cross-platform compatibility - important, yes. Although for x-platform, things like Avalonia or Uno could be better comparisons?
Huh? Qt, GTK, Cocoa (AppKit and UIKit), bunch of other linux friendly gui frameworks been around for a long time, even Flutter is still around. What is being killed?
gtk1/gtk2/gtk3 code will require you shipping gtk(version) on modern linux, not all distros have the legacy libraries.
Apple deprecated carbon (which was a thing when gtk1 was around). I don't think you have an option for this on their ARM hardware.
QT1->N code has the same problem, the older libraries are not shipped on most modern linux.
I do absolutely understand if you're going to do static compiles, that can work around that problem, but that arguement nullifies everything, since you can run/write/execute anything in a turing complete system, if you complain you're just not dedicated enough.
We're in an era where soon (if not already) it will become straight forward to direct a clanker to move an application from one gui framework to another.
Once we have robust automated computer use, that becomes the verification loop, and this problem will almost surely get solved.
I will just stop here.
No hates for macs, but your typical cli/tui software devoper is concerned about making their software run on almost anything with an actual os. As soon as I see references to specific operating systems or platform specific libraries my bullshit meter goes off.
I was expecting an article about methology and tooling to develop guis, got an apple fan telling stories about ai use.
I like to have my freedom in choosing what software I want to make/use, without anyone dictating what is better for me.
You like GUIs and want to build/use ones that works in MacOS, that's perfect go ahead and build as much GUIs as you want.
However, this wouldn't work for me as I know how bad developing native cross-platform GUI applications is.
Question about Markdown, I'm intrigued by this. I recently bought FS Notes but it has some bizarre bugs on startup. I might consider some other tool, perhaps also something with better MD support. Is this library you mentioned truly fast? https://github.com/gonzalezreal/swift-markdown-ui
Its also a bit funny how the author show cases a bunch of apps that only exist on a very specific setup, IOS Mac devices while TUI can exist everywhere a terminal can reach.
The right tool for the right job, noone would srsly use a TUI photoeditor but for many things the simplicity and constraints that a terminal introduces condenses design.
I got this article about UI density open since weeks and meant to read it https://mattstromawn.com/writing/ui-density/
But from what I could interfere so far..more UI frameworks, more white space, more wasted space.
Also..TUIs usually allow me a wide variety of colorschemes out of the box which is nice
I'm a fan of a TUI, I think because they are usually pretty intuitive out of necessity. I can usually feel the developer's skill level in the user experience.
I think it depends on how you work and what the application does. When I'm in a flow state I need things that are fast. GUIs, even on my relatively fast mac are not terribly fast. They take more time to start. They require more screen real-estate, and more management of same.
For something to become a GUI app (or a web-based UI) the GUI needs to offer something more valuable than a TUI can offer in terms of interaction.
I have one TUI app that wrote a while back to keep track of what I work on. It started off as a "wizard"-style UI. You choose project, then subproject, day, hours, activity and then hours and comment in a sequence of steps.
Arrow keys -> enter -> arrow keys -> enter .... -> comment -> enter
It takes about 2-3 seconds for me to do. And this is a time-sensitive task: if it isn't fast the user will not do it as often. There is a web interface to do the same thing, but the backend is slow. My TUI utility speeds that up by caching (between sessions) the things that the web UI has to look up (slowly) every time.
Then I wrote a more involved UI for it that "looks more like an application". Result? Now we were up to 15-20 seconds of interacting. Oh year it could do more and it certainly looked better, but it was less efficient so I noticed that I would postpone using it to record what I was doing. Because it now had friction. Lots of it. So a couple of weeks later I just did a hard reset and went back to the wizard style, minimalist version.
I would make a web UI, but that would burn 2-3 seconds just to navigate the browser there, juggle tabs (which I have too many of already), find the right browser to open the tab in etc. Once there do I keep it for "faster access" or close the tab? Keeping it is almost always the wrong thing.
There's a reason I have perhaps 15 different tools in my garage that can attach to a given fastener size. And there's a reason for that. Not all 19mm bolts are treated the same way. Some are low torque and live in tiny spaces. Some require precise fastening torque. Some need a lot of force to come loose - some will only come loose with force and I'm okay with destroying them. This is why I have so many tools that all do essentially the same job: apply rotational force to a piece of metal that has a standardized interface.
Similar tasks are not always best solved with the same tool because the context and the details do matter. Same goes for UIs. There are some things TUIs are very good at. Not least portability and remote usability.
Hot take: Too many people are building GUIs for what should just be a TUI, and vice versa
My stances:
- Dev tools need a CLI at minimum, TUI for complexity
- User facing needs a GUI, CLI for power users
If you're building a TUI for a user facing thing, then yeah, you're doing it wrong, but if your target audience is devs then yes, PLEASE do a TUI, and make it nice.
People are unable to do good GUIs. The web shows this; completely disregarding any UI guidelines by web people established since 80s is a proof that most people have no idea how to make GUIs.
I don't know how to make a good GUI. That's why I need good templates and strong guidelines, discipline and spend long time on design. Most people don't do that.
TUI is much, much easier. It's also possible to do bad TUIs, but it's easier to do a good TUI than to do an average GUI.
Making TUIs isn't the issue. Making them with JS/TS, and in general an ecosystem designed for the web, is the problem. I've used some really good TUI apps in the past, but all these new ones mostly based on web tech are just... sloppily bad. Probably because the dev would rather be in the web browser where it's naturally colorful and scripts can run wild, but mostly-static terminal is where things are currently at. And they're using LLMs, which don't have sufficient data on web-tech-in-terminal since it wasn't really a thing until now, which also ensures they will likely never gain enough data on decent patterns since almost nobody will be engineering said patterns, creating a permanently slop-ridden cycle as future models only have slop projects to learn from.
Are there not disparities between running an application in the terminal and running a native GUI? I can only speak for macOS, but my experience with bespoke native GUI applications of my own or other developers (pre-built distributions in GitHub assets) is that I must first pass through the layers of the macOS security model: doing a right-click dance to launch the application, changing permissions in security settings, etc. I assume the experience is different depending on how you set up Xcode to compile, how it's signed, etc (I have zero experience with how this works). That said, I do not recall being subjected to any of this using terminal applications.
Put differently, a GUI application seems to subject you far more to the whims of Apple or Windows than a TUI and perhaps even a different run context. Maybe the permissions fiddling for this is insignificant. Is there a clear user contract from Apple or Microsoft about this?
You know what's awesome about TUIs? They live in a tab in my terminal. 95% of the time, my system has three windows open: terminal, browser, Signal.
Please, make more TUIs and web apps, so they can live in my terminal or my browser.
Additionally, I can with very high confidence run TUI software inside an ssh session to one of my headless machines, and then further within gnu screen or tmux detach and later resume a session with everything I was doing. Even if I switch from my laptop to my desktop, or want to leave a bunch of stuff waiting for a week and come back to it later.
Once you get the key bindings for screen or tmux thoroughly memorized it's very easy.
Why this is preferable? I would rather have the apps I use represented as a list of apps in my system (drawing on a couple of decades of established UX conventions for how they are displayed and how I can interact with them), the web content I'm reading represented as tabs in my browser, and my terminal sessions represented in my terminal. You present the destruction of this simple separation of concerns as a benefit, but don't explain why it is one.
>or my browser
But then a load of others will complain about electron apps.
Further you then have an os within an os. You need to remember to look in your bookmarks, not your start menu. And you're basically throwing away the window manager too.
I was going to post this but you beat me to it. I think we need the folks whom do not enter the terminal to start using it instead of the other way around.
Bubble Tea [1] is my favorite for one-off throwaway stuff in terminal. Wish [2] to make it available over SSH.
[1] https://github.com/charmbracelet/bubbletea
[2] https://github.com/charmbracelet/wish
So you have a cluttered list of terminal tabs instead of a cluttered list of windows.
But with a worse UX?
I built "ssh sshfighter.com" recently, enjoy!
Mine's funky.nondeterministic.computer
So great =D
Couldn't you then just vibe code some window manager app that throws a bunch of your stuff into a tabbed window? Seems like the same thing.
> Couldn't you then just vibe code some window manager app
My reaction to this is basically about the same as the fictional Ivan Chesnokov
(beware, crude language, profanity, etc)
https://m1-garand-rifle.com/ivan-chesnokov.html
It already exists. Tabbed by suckless.
How would that be any better though?
If the point is only that "terminal good because tabs" then that solves that problem
and music
The LLM fetishists really do themselves a disservice with these wild, over-the-top statements about AI capabilities. I’d be willing to bet money that giving Claude a screenshot of part of this blog post would not producing “something useful” for any reasonable interpretation of useful. This reminds me of a line from Peter Diamandis’ Abundance (basically the only thing I remember) that described Google using a “stroke of HTML” to organize the worlds information.
One of the biggest upsides of TUIs over GUIs is that I can run any number of TUI instances.
Meanwhile a GUI's developer has to decide to grace me with the ability to even open more than one window. "A tabbed interface will be sufficient!" -- yay, I'll never be able to view two screens of info at the same time.
But in the article all these GUIs are vibe coded. Tell your AI to allow more than one window. What's the problem?
Opening more than one instance is the default, developers have to actively work to block it. At least on desktop.
Which desktop?
It's not true for AppKit, SwiftUI, GTK, Qt, WinUI, or Electron, and I'm not sure what's left.
What? 99% of my programs I can open more than one window by just executing the program as normal multiple times, the only ones that enforce a kind of singleton execution are things that also acts as a kind of server, one example is Everything search, but it has a "Open new Search window" for multiple windows. And that is the default, you have to explicit code in a lock/global mutex thing to block multiple instances.
vscode, electron app, no problem opening multiple windows. Geany, gtk app, no problem opening multiple windows.
Can you give an example where this doesn't work?
Incoherent and far too long .
Lists a bunch of things .
Fails to make any clear points .
Fails to give real reasons for the few claims it makes .
Building software for yourself - and only yourself - is a super-power.
I can see how LLMs help.
I wouldn't want to maintain software for other people entirely vibe coded. I think I might think again about native app development for my own needs, if it's kind of disposable.
Spent 2 minutes skimming, didn't manage to find a single talking point. I've no idea what the thesis is. Seemed like a list of things this person built.
People talk shit about LLM writing. Well, here's a prime example of why I like LLM-speak. Does this article have personality? Yes. Attitude? Yes. Is it structured and accessible? No.
I'll take clarity over personality any day of the week.
That's a false dichotomy. If you launder rambling pointless prose through the llm you don't trade the personality of the writing for a well reasoned argument with clear points, you just lost the personality and gained shitty writing. LLMs aren't magic and can't make your point for you if you don't have one to begin with in the prompt. Garbage in garbage out.
I disagree. An editor can definitely make a piece of writing clearer without further input from the author. I often use an LLM to do that.
Of course, I didn't mean to imply that there's a dichotomy between personality and clarity. There's a dichotomy between ordinary LLM writing and personality.
Counterpoint: Build more TUIs in Rust using Ratatui: https://ratatui.rs/
Why? Because just look at the examples on that page.
Haha, no. For a while, many years ago, it seemed TUIs were indeed on the way out, but then they were relived by the awesome work of people who wrote GPU-accelerated terminals, widget libraries, who extended terminals with more colors and the ability to show Unicode and graphics.
I salute you, heros.
Make more TUIs ....
The main thing I like is that TUIs are guaranteed to be navigable by keyboard. So many non-TUI apps don't include shortcuts at all for critical actions. It makes the first week of using the app more efficient and the entire rest of your life less so. Add on to that, I can probably run a TUI on my server. Or my cloud instance. And in my sandbox. Over SSH.
So: do make TUIs and bind their keys to Vi-like shortcuts as much as possible and I will use your app every time over a GUI app.
Pro tip for Mac users - install Karabiner and bind right-Alt + jklm to cursor movements. Immediate VIM navigation through the whole OS.
To me TUI have a better user experience than graphical applications. And considering the amount of companies that are still using decades old AS/400 systems instead of new ERP system I'm probably not the only one to think it like this.
First, a TUI is usable with only the keyboard. Moving the mouse is a waste of time, and if you are using an application multiple hours a day, it can lead to being more productive.
Second, a TUI has no useless animations, elements, etc. It's not pretty, you have on the screen only the stuff you need to do your job, and you are not distracted by useless elements.
Third, a TUI works beautifully in a client/server world, where you have one central computer and dumb clients that connects to it, and the connection can be a simple serial connection as well as a network connection. It can be rendered even with an ESP32, making it suitable for embedded HMIs and all kind of computing scenarios.
Lastly, the user can choose the font, the colors, the size of the font that are best for him, usually a monospace font that it's surely better to read information multiple hours a day.
To me it's the opposite, GUI interfaces were born to make it intuitive to use a computer, but are not as efficient as TUI in terms of productivity.
I like TUIs, and I chose to build e.g. https://taskusanakirja.com/ as a TUI for a couple of reasons, some of which are in this article and some not. Cross platform compatibility was a big one since at the time I started building it I didn't actually have a Windows or Mac machine handy to test this out.
One thing I think which is overlooked is the raw feeling of speed a good TUI can give you. The lowest grade consumer laptop could probably download my little dictionary program and still get true search-on-keystroke performance, because there is virtually nothing slowing down that path, no animations, no nothing. Now most of that comes down to the data structures involved and making sure nothing ever has to go over a network, but I still appreciate the sheer simplicity of the approach.
It's also nice to know that I can probably recompile this same exact code 50 years from now and still get it to run exactly as intended, since GUI frameworks have waxed and wanted in popularity, but terminals truly don't seem to be going anywhere.
I like TUIs a lot and I use a TUI instead of a GUI as long as there is one available, but please note the main point of the post, the very last sentence
> I barely think about these things as “apps” (I have no intention to distribute them). They’re artifacts of me making my computer do stuff for me, the way I want it to. As a Unix nerd, I’ve always been able to do this, in the language of the command line. Now, it’s just as easy to do that kind of work with graphical interfaces.
And so the author (second sentence of the post)
> I built my first serious Mac application a few months ago, and since then I’ve built more native UI thingies than in my entire career prior to that.
I still build my personal stuff either for the command line (not even TUIs) or in a HTML page but I can see the point of creating a native app. Unfortunately there are some drawbacks: I would have to create the app for GNOME Debian and for Android, while a web app runs on both, and I would have to go all in on vibe coding because my last serious GUI programming has been in the 90s with Motif. The latter point is more or less the point of the author (the LLM does it for you) but it means that programming personal stuff will cost money paid to the LLMs companies. More and more money at each price hike and the multi thousand dollars box to run local models only makes the expense happen immediately instead of diluting over a long period.
Yesterday I was flipping between some TUIs, native apps, web apps and an electron app. I think it was only because I was trying to do a lot in each of them I became really aware of the latency lag in some of these.
There are real advantages of TUIs: less CPU; sometimes I want to be using a personal TUI on a personal dev server quickly from a work laptop at lunchtime and an ssh + tmux + TUI is perfect; most modern TUI libraries are significantly less painful to work with than most modern web app frontend libraries; I can change the font size of my terminal easily if I need to, more easily than native (but not web app). But by far the biggest, is they just generally tend to be very fast and responsive compared to everything else.
If you want to live only in the terminal, you can also use one of the text-based browsers [1] instead of Chrome, Firefox, etc. browsh [2] can also play YouTube videos if you'd like.
You can also just use the system console with tmux or GNU screen if you absolutely don't want any graphics at all.
The TUI programs usually do not consume a lot of resources. They are also very fast and optimized for keyboard-only navigation.
[1] https://en.wikipedia.org/wiki/Text-based_web_browser [2] https://github.com/browsh-org/browsh
No. I like them.
What do you like about them? I disagree, but so many people seem to like them that I assume I'm missing something. The main one I've heard before is that they work nicely over SSH, but I assume there must be more?
I personally like making (and using) TUIs because:
- 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.
IMHO the rise of TUIs is heavily correlated with the near-abandonment of professional quality graphical interfaces.
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.
Lightweight and can run over ssh are 2 main reasons i like them.
In addition to what other people have said, the terminal interface is cross-platform and very stable, so TUIs need little or no maintenance to keep working.
I don't think TUIs are inherently better but some are simply too good versus the alternative. magit and k9s for example.
(other user) in my typical experience:
- 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.
It's easier to automate TUIs, since it's just text.
As someone who works on a very GUI-centric OS (i.e. Mac), TUIs just don't integrate very well with the rest of the non-Terminal ecosystem.
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...
TUI is a kind of self defense. big corps create and kill gui frameworks faster that one can learn them. Browser based ui is a real waste of resources (and also evolve in a absurd pace). The Console is a last resort to write small (understandable) gui that work on many platforms.
Are the TUI apps built on TUI frameworks? Do the TUI frameworks last longer than the gui frameworks you mentioned being quickly killed by "big corps"? In the Windows space, WinForms, WPF, WinUI are likely the biggest examples of gui frameworks, especially from "big corps"; they've been around for decade(s) and have not been abandoned (/ they continue to be supported) - how do TUI frameworks compare? On the other hand, TUIs may be better for things like running over SSH, and for cross-platform compatibility - important, yes. Although for x-platform, things like Avalonia or Uno could be better comparisons?
They generally stay supported, or if not supported, working.
Huh? Qt, GTK, Cocoa (AppKit and UIKit), bunch of other linux friendly gui frameworks been around for a long time, even Flutter is still around. What is being killed?
Apple believes SwiftUI is the future, not AppKit and UIKit/Cocoa.
What versions of QT and GTK? Running GTK1 or 2 apps is pretty hard. P TUI apps from that era work just fine!
The same reason webui and js is so popular!
gtk1/gtk2/gtk3 code will require you shipping gtk(version) on modern linux, not all distros have the legacy libraries.
Apple deprecated carbon (which was a thing when gtk1 was around). I don't think you have an option for this on their ARM hardware.
QT1->N code has the same problem, the older libraries are not shipped on most modern linux.
I do absolutely understand if you're going to do static compiles, that can work around that problem, but that arguement nullifies everything, since you can run/write/execute anything in a turing complete system, if you complain you're just not dedicated enough.
We're in an era where soon (if not already) it will become straight forward to direct a clanker to move an application from one gui framework to another.
Once we have robust automated computer use, that becomes the verification loop, and this problem will almost surely get solved.
I absolutely love TUIs, they can live in a pane in my terminal, run via SSH on remote machines, use hardly any resources and are very flexible.
"I built my first serious Mac application"
I will just stop here. No hates for macs, but your typical cli/tui software devoper is concerned about making their software run on almost anything with an actual os. As soon as I see references to specific operating systems or platform specific libraries my bullshit meter goes off.
I was expecting an article about methology and tooling to develop guis, got an apple fan telling stories about ai use.
It’s a matter of preference: Everything OP says about GUI development getting easier is also true about TUI development getting easier.
I like to have my freedom in choosing what software I want to make/use, without anyone dictating what is better for me.
You like GUIs and want to build/use ones that works in MacOS, that's perfect go ahead and build as much GUIs as you want. However, this wouldn't work for me as I know how bad developing native cross-platform GUI applications is.
Question about Markdown, I'm intrigued by this. I recently bought FS Notes but it has some bizarre bugs on startup. I might consider some other tool, perhaps also something with better MD support. Is this library you mentioned truly fast? https://github.com/gonzalezreal/swift-markdown-ui
I am team TUI for the matter.
Its also a bit funny how the author show cases a bunch of apps that only exist on a very specific setup, IOS Mac devices while TUI can exist everywhere a terminal can reach.
The right tool for the right job, noone would srsly use a TUI photoeditor but for many things the simplicity and constraints that a terminal introduces condenses design.
I got this article about UI density open since weeks and meant to read it https://mattstromawn.com/writing/ui-density/ But from what I could interfere so far..more UI frameworks, more white space, more wasted space.
Also..TUIs usually allow me a wide variety of colorschemes out of the box which is nice
I'm a fan of a TUI, I think because they are usually pretty intuitive out of necessity. I can usually feel the developer's skill level in the user experience.
I think it depends on how you work and what the application does. When I'm in a flow state I need things that are fast. GUIs, even on my relatively fast mac are not terribly fast. They take more time to start. They require more screen real-estate, and more management of same.
For something to become a GUI app (or a web-based UI) the GUI needs to offer something more valuable than a TUI can offer in terms of interaction.
I have one TUI app that wrote a while back to keep track of what I work on. It started off as a "wizard"-style UI. You choose project, then subproject, day, hours, activity and then hours and comment in a sequence of steps.
Arrow keys -> enter -> arrow keys -> enter .... -> comment -> enter
It takes about 2-3 seconds for me to do. And this is a time-sensitive task: if it isn't fast the user will not do it as often. There is a web interface to do the same thing, but the backend is slow. My TUI utility speeds that up by caching (between sessions) the things that the web UI has to look up (slowly) every time.
Then I wrote a more involved UI for it that "looks more like an application". Result? Now we were up to 15-20 seconds of interacting. Oh year it could do more and it certainly looked better, but it was less efficient so I noticed that I would postpone using it to record what I was doing. Because it now had friction. Lots of it. So a couple of weeks later I just did a hard reset and went back to the wizard style, minimalist version.
I would make a web UI, but that would burn 2-3 seconds just to navigate the browser there, juggle tabs (which I have too many of already), find the right browser to open the tab in etc. Once there do I keep it for "faster access" or close the tab? Keeping it is almost always the wrong thing.
There's a reason I have perhaps 15 different tools in my garage that can attach to a given fastener size. And there's a reason for that. Not all 19mm bolts are treated the same way. Some are low torque and live in tiny spaces. Some require precise fastening torque. Some need a lot of force to come loose - some will only come loose with force and I'm okay with destroying them. This is why I have so many tools that all do essentially the same job: apply rotational force to a piece of metal that has a standardized interface.
Similar tasks are not always best solved with the same tool because the context and the details do matter. Same goes for UIs. There are some things TUIs are very good at. Not least portability and remote usability.
Hot take: Too many people are building GUIs for what should just be a TUI, and vice versa
My stances:
- Dev tools need a CLI at minimum, TUI for complexity
- User facing needs a GUI, CLI for power users
If you're building a TUI for a user facing thing, then yeah, you're doing it wrong, but if your target audience is devs then yes, PLEASE do a TUI, and make it nice.
Clickbaity title. Boring show off of vibe coded apps that only make sense to the author, disguised as think piece. This post has it all.
aerc is the best program I've ever used. tmux from anywhere. May TUIs never die.
So wrong.
They're fast, efficient, work across SSH, in a tmux, and survive the almost daily browser upgrades.
And they are easy to run as separate users without VNC or sandbox hell.
Like do you want to think about X/Wayland isolation, or do you just want to get shit done?
What is the complaint in the article really about?
People write code using the platform X because they like it. It doesn't make sense to try to stop this
Or, you know what, don't listen to strangers on internet telling you what you should do. Do what you want.
Do more TUIs.
People are unable to do good GUIs. The web shows this; completely disregarding any UI guidelines by web people established since 80s is a proof that most people have no idea how to make GUIs.
I don't know how to make a good GUI. That's why I need good templates and strong guidelines, discipline and spend long time on design. Most people don't do that.
TUI is much, much easier. It's also possible to do bad TUIs, but it's easier to do a good TUI than to do an average GUI.
Making TUIs isn't the issue. Making them with JS/TS, and in general an ecosystem designed for the web, is the problem. I've used some really good TUI apps in the past, but all these new ones mostly based on web tech are just... sloppily bad. Probably because the dev would rather be in the web browser where it's naturally colorful and scripts can run wild, but mostly-static terminal is where things are currently at. And they're using LLMs, which don't have sufficient data on web-tech-in-terminal since it wasn't really a thing until now, which also ensures they will likely never gain enough data on decent patterns since almost nobody will be engineering said patterns, creating a permanently slop-ridden cycle as future models only have slop projects to learn from.
TUIs are just an accessibility nightmare without any of the advantages of a CLI like scriptability. Truly, Truly horrible
Are there not disparities between running an application in the terminal and running a native GUI? I can only speak for macOS, but my experience with bespoke native GUI applications of my own or other developers (pre-built distributions in GitHub assets) is that I must first pass through the layers of the macOS security model: doing a right-click dance to launch the application, changing permissions in security settings, etc. I assume the experience is different depending on how you set up Xcode to compile, how it's signed, etc (I have zero experience with how this works). That said, I do not recall being subjected to any of this using terminal applications.
Put differently, a GUI application seems to subject you far more to the whims of Apple or Windows than a TUI and perhaps even a different run context. Maybe the permissions fiddling for this is insignificant. Is there a clear user contract from Apple or Microsoft about this?
Naturally, this is a non-issue in Linux.
This piece is just marketing for all the authors slop coded projects
Do more TUIs. Please.