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.
Indeed, I've been on vacation this week, but wanted to continue working on some of my hobby projects while I'm in the mountains a bit. Being able to use tailscale to SSH into my home workstation and attach to Tmux with my full session of agentic development, server, notes, design, and everything else has been an incredibly fun experience.
Native UIs simply don't have the same flexibility.
Edit to add: I didn't bring my laptop; I'm working from Termux. Surprisingly effective! The code is all in a folder syncing with my phone via SyncThing, so I can try out the sites I'm working on directly on the phone.
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.
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.
If age of conventions is a valuable metric, TUIs have more. The keyboard hasn't change noticeably, and I can work way faster between separate windows/panes in a terminal and tmux, than in various GUI windows, where mouse focus dictates when I can start inputting.
While a mouse can theoretically use all pixels of a screen, in practical terms a keyboard has a much larger input space than a mouse, and if I can keep both my hands on the keyboard, I can work a lot faster.
At least that's my experience as a (starting) greybeard.
This is the thing - my window manager can manage windows just fine. I suppose you can make the argument that managing multiple terminals in a tab is a better experience than managing multiple windows in my window manager, but that depends heavily on the terminal being used and the window manager being used.
As a devils advocate in response to all the comments claiming TUIs are fine, maybe consider TUIs mostly do not come with many of the advantages of using a terminal CLI app - you can't pipe data into them, out of them, spawn them and collect the output, etc like you can with the usual stuff you run in a terminal.
IOW, they are a reduced functionality of a GUI - resizing works poorly, scrolling works poorly, UI affordances are poor (sure, you can grey out a button, but drag-n-drop hardly ever works between your various terminal tabs, and the smallest UI element is a full character block, unlike a GUI where you can have indicators that are smaller than a character, mini-windows, etc), lack of widgets, etc.
The lightweight argument is not so good either - look at Claude Code, after all. If you want lightweight GUIs, you can do that too.
The only argument that stands is the ssh one, but if working via a remote connection, I'm not going to want a full functionality application anyway - why would I prefer a wordstar/wordperfect interface to a complex document over a GUI interface? For simple documents, sure, TUI all the way, but when I have multiple panes (outline, minimap, status bars, toolbars, etc), it performs poorly in a TUI.
TUIs are making a resurgence, sure, but only in the context of developers and development.
Whether or not you can pipe information into a TUI is a function of the implementation of it. I've written command line apps that are dual function. When you invoke them with no arguments, they launch the TUI, but when you pass an argument, you can get them to behave like a normal CLI. I don't think this is the norm, but there's no reason it couldn't be more widespread, I don't think.
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.
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.
Only if the program is designed to be safe to run in parallel. Which can be done with desktop apps too - and they'll run more efficiently as well, as the windows share memory.
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.
Did you read it all the way to the end? It's coherent and does give real if debatable reasons for the claims it makes, I think it also does so quite clearly although if I'd written it the ordering of the sections would be different.
Here's an organically grown summary:
• TUIs suck because they are primitive, often buggy, hard to write and aren't accessible. Their existence isn't due to any real technical advantage but more because UNIX historically had a very bad UI toolkit (Motif) which established a 'culture' of TUIs.
• It's now easy (on macOS) to write native apps that use SwiftUI and give a much better GUI. You can just vibe code them.
• Some specific skills, features, templates etc are linked which look useful if you agree with this approach.
• You don't have to give up remote access because there's no reason the GUI has to run on the same machine as the thing it controls. A native GUI can just SSH in to a remote machine and run non-TUI CLI tools to control it. Lots of apps have worked this way and it functions fine.
• On the other hand, TUIs are portable (ish). The author concedes this may sometimes be useful.
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.
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.
The real shame though is that you can make gui apps efficient.
I've used the same systems you describe, except in gui form.
And the thing is, with this kind of application, everyone has a different 20% that they spend 80% of their time using. Guis can be as good as the TUI in the 80%, and very handy in the 20% where you aren't so well versed.
The issue, is that guis seem to have dropped the ball with regards to efficiency.
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.
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.
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.
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.
>The main thing I like is that TUIs are guaranteed to be navigable by keyboard
I don't disagree with you, but in ye old days you had guis that were navigable by keyboard.
And these were discoverable. That one program you use every day, you can spend the time to learn the short cuts. You can still get things done by clicking around though.
I suspect the underlying issue is one of limitations. Terminals are limited in what they can do. Guis and the web, you can do so much more, so people do.
I think another issue is touch screens. Guis and the web have moved to optimise for those. It decreases information density, forces a move away from the old standards to new much weaker ones. Tuis can't really do touch, so they don't have to make those tradeoffs.
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.
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.
> 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.
Recently, I posted a GUI mp3 playing program written purely in Tcl/Tk using shell scripts for some things. On my 2011 desktop, filtering for a specific mp3 across all the mp3s stored on my computer (about 80GB of mp3s) takes single-digit milliseconds. I can only imagine what a modern desktop, with an SSD, will do!
GUI apps don't have to be laggy. My Qt and Lazarus apps aren't laggy at all, and are far more snappy and responsive than the clear majority of TUIs I use (like CC).
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.
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.
But you can't really do information dense when you are limited to a fixed grid of monospaced character glyphs.
Variable width fonts are much more information dense for example.
I prefer TUIs personally, but I can't see myself use maps, or visual image editing in a TUI for example, but is vi infinitely faster than vscode for manipulating a codebase? Absolutely.
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.
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.
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
- 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.
Nit.
Surely it would be keyboard navigation? Your macro can consist of the key presses you would actually use, rather than trying to describe mouse movement.
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'
You don't really need metadata to automate in a terminal. Literally everything is there in the clear and ANSI is used for control. It's all characters; no need to think about pixels (I made something that automates TUIs[0] BTW.
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.
> But there’s one of the problems with TUIs: even with a good framework, like Ratatui, Textual, or Bubbletea, you’re fighting the terminal to come asymptotically close to what every native framework does well out of the box. Scrolling and scroll targets are an obvious example.
maybe the answer is... you just don't need features like scrolling? this guy is trying to fit a square peg into a circle hole
Yeah, I think I agree with this. I think making GUIs and reverse engineering proprietary APIs are two things that frontier models make really pleasant - e.g. I made a menu-bar app (very similar to your temperatures dropdown, similar graph, SwiftUI) which connects via bluetooth to my Inkbird CO2 sensor, graphs the CO2 level over time, and looks fabulous.
The skills are useful, thanks for linking them! They'll be useful for my future projects like this. FWIW I've had good luck with using Claude Design first to do mocks.
At the same time, I think there's still the "is this worth doing a hyper-customized version of this software, if I'm also then responsible for fixing the bugs?". But I think increasingly as we improve our agentic workflows and make them more self-contained loops driving the result to completion, this becomes kind of a non-issue.
In general, I do think LLMs are bringing about a new age of hyper-customization, which I welcome.
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.
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.
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.
The CLI/TUI split in the article is right, but to me the more interesting boundary now is human-facing vs agent-facing interfaces. For most things TUIs lose on both sides.
We run an internal agentic development harness we experimentally built for working on large-ish projects. first version started as a TUI, but it quickly became unusable for the large scale projects it was meant to work on (essentially PRD to PR, with planning loops, task decomposition loops and dependency aware execution / review loops). The TUI was too state-bound for another agent to drive reliably, and too cramped for a human to review at scale. We ended up replacing the TUI with a headless cli, and every interface we've built for the harness has become either a text artifact (mostly for agents to work) or a web view (for humans to drive and review).
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...
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.
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 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.
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.
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.
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
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?
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.
As a web developer who has just begun building native apps: running outside of the various sandboxes browser based apps are quarantined in. Deeper file system access, better access to hardware and sensors, notifications where helpful, deeper integration into the operating system (open with, file previews, widgets to launch the app, etc) and performance. Some things the web does well, some things it does less well than native. With a native wrapper around a web app you can leverage the best of both!
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.
Indeed, I've been on vacation this week, but wanted to continue working on some of my hobby projects while I'm in the mountains a bit. Being able to use tailscale to SSH into my home workstation and attach to Tmux with my full session of agentic development, server, notes, design, and everything else has been an incredibly fun experience.
Native UIs simply don't have the same flexibility.
Edit to add: I didn't bring my laptop; I'm working from Termux. Surprisingly effective! The code is all in a folder syncing with my phone via SyncThing, so I can try out the sites I'm working on directly on the phone.
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.
Don’t be so sure about that..
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
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.
If age of conventions is a valuable metric, TUIs have more. The keyboard hasn't change noticeably, and I can work way faster between separate windows/panes in a terminal and tmux, than in various GUI windows, where mouse focus dictates when I can start inputting.
While a mouse can theoretically use all pixels of a screen, in practical terms a keyboard has a much larger input space than a mouse, and if I can keep both my hands on the keyboard, I can work a lot faster.
At least that's my experience as a (starting) greybeard.
So you have a cluttered list of terminal tabs instead of a cluttered list of windows.
But with a worse UX?
This is the thing - my window manager can manage windows just fine. I suppose you can make the argument that managing multiple terminals in a tab is a better experience than managing multiple windows in my window manager, but that depends heavily on the terminal being used and the window manager being used.
As a devils advocate in response to all the comments claiming TUIs are fine, maybe consider TUIs mostly do not come with many of the advantages of using a terminal CLI app - you can't pipe data into them, out of them, spawn them and collect the output, etc like you can with the usual stuff you run in a terminal.
IOW, they are a reduced functionality of a GUI - resizing works poorly, scrolling works poorly, UI affordances are poor (sure, you can grey out a button, but drag-n-drop hardly ever works between your various terminal tabs, and the smallest UI element is a full character block, unlike a GUI where you can have indicators that are smaller than a character, mini-windows, etc), lack of widgets, etc.
The lightweight argument is not so good either - look at Claude Code, after all. If you want lightweight GUIs, you can do that too.
The only argument that stands is the ssh one, but if working via a remote connection, I'm not going to want a full functionality application anyway - why would I prefer a wordstar/wordperfect interface to a complex document over a GUI interface? For simple documents, sure, TUI all the way, but when I have multiple panes (outline, minimap, status bars, toolbars, etc), it performs poorly in a TUI.
TUIs are making a resurgence, sure, but only in the context of developers and development.
Whether or not you can pipe information into a TUI is a function of the implementation of it. I've written command line apps that are dual function. When you invoke them with no arguments, they launch the TUI, but when you pass an argument, you can get them to behave like a normal CLI. I don't think this is the norm, but there's no reason it couldn't be more widespread, I don't think.
I built "ssh sshfighter.com" recently, enjoy!
Mine's funky.nondeterministic.computer
So great =D
>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.
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
How would that be any better though?
If the point is only that "terminal good because tabs" then that solves that problem
It already exists. Tabbed by suckless.
and music
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.
Only if the program is designed to be safe to run in parallel. Which can be done with desktop apps too - and they'll run more efficiently as well, as the windows share memory.
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?
But in the article all these GUIs are vibe coded. Tell your AI to allow more than one window. What's the problem?
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 .
Did you read it all the way to the end? It's coherent and does give real if debatable reasons for the claims it makes, I think it also does so quite clearly although if I'd written it the ordering of the sections would be different.
Here's an organically grown summary:
• TUIs suck because they are primitive, often buggy, hard to write and aren't accessible. Their existence isn't due to any real technical advantage but more because UNIX historically had a very bad UI toolkit (Motif) which established a 'culture' of TUIs.
• It's now easy (on macOS) to write native apps that use SwiftUI and give a much better GUI. You can just vibe code them.
• Some specific skills, features, templates etc are linked which look useful if you agree with this approach.
• You don't have to give up remote access because there's no reason the GUI has to run on the same machine as the thing it controls. A native GUI can just SSH in to a remote machine and run non-TUI CLI tools to control it. Lots of apps have worked this way and it functions fine.
• On the other hand, TUIs are portable (ish). The author concedes this may sometimes be useful.
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.
But it makes some things very clear:
- All those GUI windows look the same. How the fuck do I tell one app from the other?
- The abysmal corner radii are a clear indication of terminal macOS. Pun fully intended.
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.
Or for those coding in Python there's Textual: https://textual.textualize.io/
Or for Go coders there's BubbleTea: https://github.com/charmbracelet/bubbletea
Why? Because TUI!
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.
The real shame though is that you can make gui apps efficient.
I've used the same systems you describe, except in gui form.
And the thing is, with this kind of application, everyone has a different 20% that they spend 80% of their time using. Guis can be as good as the TUI in the 80%, and very handy in the 20% where you aren't so well versed.
The issue, is that guis seem to have dropped the ball with regards to efficiency.
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.
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.
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.
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.
>The main thing I like is that TUIs are guaranteed to be navigable by keyboard
I don't disagree with you, but in ye old days you had guis that were navigable by keyboard.
And these were discoverable. That one program you use every day, you can spend the time to learn the short cuts. You can still get things done by clicking around though.
I suspect the underlying issue is one of limitations. Terminals are limited in what they can do. Guis and the web, you can do so much more, so people do.
I think another issue is touch screens. Guis and the web have moved to optimise for those. It decreases information density, forces a move away from the old standards to new much weaker ones. Tuis can't really do touch, so they don't have to make those tradeoffs.
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.
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.
> 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.
Recently, I posted a GUI mp3 playing program written purely in Tcl/Tk using shell scripts for some things. On my 2011 desktop, filtering for a specific mp3 across all the mp3s stored on my computer (about 80GB of mp3s) takes single-digit milliseconds. I can only imagine what a modern desktop, with an SSD, will do!
GUI apps don't have to be laggy. My Qt and Lazarus apps aren't laggy at all, and are far more snappy and responsive than the clear majority of TUIs I use (like CC).
"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.
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.
I think the "fun as hell to write and use" angle is underrepresented in the comments—thanks for bringing it up.
It is, of course, completely subjective, but I know there are a fair number of people out there who agree with that statement.
But you can't really do information dense when you are limited to a fixed grid of monospaced character glyphs. Variable width fonts are much more information dense for example.
I prefer TUIs personally, but I can't see myself use maps, or visual image editing in a TUI for example, but is vi infinitely faster than vscode for manipulating a codebase? Absolutely.
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.
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.
A good UI can be text, graphic, voice, etc.
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
(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.
Nit. Surely it would be keyboard navigation? Your macro can consist of the key presses you would actually use, rather than trying to describe mouse movement.
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'
You don't really need metadata to automate in a terminal. Literally everything is there in the clear and ANSI is used for control. It's all characters; no need to think about pixels (I made something that automates TUIs[0] BTW.
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.
[0] https://gitlab.com/skeledrew/jaiver
Ah ok. I was thinking from the perspective of automating the input, for a human to view, rather than automatically getting data out.
Automating input is just sending character codes. It's all wonderfully simple and uniform.
It’s a matter of preference: Everything OP says about GUI development getting easier is also true about TUI development getting easier.
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.
> But there’s one of the problems with TUIs: even with a good framework, like Ratatui, Textual, or Bubbletea, you’re fighting the terminal to come asymptotically close to what every native framework does well out of the box. Scrolling and scroll targets are an obvious example.
maybe the answer is... you just don't need features like scrolling? this guy is trying to fit a square peg into a circle hole
Yeah, I think I agree with this. I think making GUIs and reverse engineering proprietary APIs are two things that frontier models make really pleasant - e.g. I made a menu-bar app (very similar to your temperatures dropdown, similar graph, SwiftUI) which connects via bluetooth to my Inkbird CO2 sensor, graphs the CO2 level over time, and looks fabulous.
The skills are useful, thanks for linking them! They'll be useful for my future projects like this. FWIW I've had good luck with using Claude Design first to do mocks.
At the same time, I think there's still the "is this worth doing a hyper-customized version of this software, if I'm also then responsible for fixing the bugs?". But I think increasingly as we improve our agentic workflows and make them more self-contained loops driving the result to completion, this becomes kind of a non-issue.
In general, I do think LLMs are bringing about a new age of hyper-customization, which I welcome.
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
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.
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.
The CLI/TUI split in the article is right, but to me the more interesting boundary now is human-facing vs agent-facing interfaces. For most things TUIs lose on both sides.
We run an internal agentic development harness we experimentally built for working on large-ish projects. first version started as a TUI, but it quickly became unusable for the large scale projects it was meant to work on (essentially PRD to PR, with planning loops, task decomposition loops and dependency aware execution / review loops). The TUI was too state-bound for another agent to drive reliably, and too cramped for a human to review at scale. We ended up replacing the TUI with a headless cli, and every interface we've built for the harness has become either a text artifact (mostly for agents to work) or a web view (for humans to drive and review).
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...
It's somewhat an issue with Linux as well.
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.
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 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.
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.
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.
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
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
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.
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.
Or, you know what, don't listen to strangers on internet telling you what you should do. Do what you want.
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.
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.
This piece is just marketing for all the authors slop coded projects
TUIs are just an accessibility nightmare without any of the advantages of a CLI like scriptability. Truly, Truly horrible
If there's anything that's anachronistic, it's native apps.
You want it graphical: Make a webapp.
You don't: Make a TUI.
What exactly is the use case for native apps? Even lots of legacy code can build to WASM now.
(yes, I'm exaggerating a bit, but not much)
As a web developer who has just begun building native apps: running outside of the various sandboxes browser based apps are quarantined in. Deeper file system access, better access to hardware and sensors, notifications where helpful, deeper integration into the operating system (open with, file previews, widgets to launch the app, etc) and performance. Some things the web does well, some things it does less well than native. With a native wrapper around a web app you can leverage the best of both!
"Stop liking things I don't like!!"
Do more TUIs. Please.