alt Hacker NewsStop Making TUIs
Comments
As a ratatui library maintainer, NO - please don't stop making TUIs ;)
As a developer outside of that, I love the scratch the itch apps stuff mentioned in here. I have a vibe coded SwiftUI chess repertoire builder app that fits in that same sort of space that I'm currently working on, where I'd probably not have chosen to explore the idea if not for coding agents.
I agree with the article that the terminal is an odd shape which you're fighting against historical specs, etc. The key observation I have though is that the mismatch of terminal apps and libraries to deal with this are all fundamentally built around character cells and cursor movement plus various CSI/OSC/ASC/DEC/xterm/... protocols which are complex and have varying support and interact in weird ways.
To get a good terminal UX, I think the answer to this is probably to throw all that compatibility mess away and redesign a modern terminal protocol that bakes in accessibility, regions, scrolling, selection, proper keyboard, etc.
I know Mitchell Hashimoto has a bit of a different perspective on this, which seems like it's to define some more protocol stuff and continue to build up on things. I think that probably gets to 95% pretty well. But a 100% good is a full replacement.
Counter proposal: stop making gui, ONLY make TUI.
+ seamless cli integration + network portable + graphics (!!) with modern emulators + always themable + scriptable + works with any navigation modality + you can copy & paste entire segments of your window easily + easy to consistently theme + did i mention entirely network/os transparent? + blazing fast
tongue-in-cheeck mostly, but i assure tfa, the tui serves useful functions. i spend >80% of my time in terminal, and having a pane to do some task a gui would otherwise be needed for is a sheer blessing. being able to essentially move my session to a laptop is wonderful. no mucking with screen sizes or weird X11 wonkery (if you still use x11). what would blow my socks clean off is a tui/gui+gui/tui backend pair so we can have our tui and you can gui it tooie.
No, thanks. I don't want a mere "user" interface, I want a programmer's interface. I don't like the command line because I'm a "unix nerd", I like it because it lets me rapidly cook up little programs and execute them.
Here's an example I just pulled out of my shell history:
c=3afba1a; reset; laptop "virtdev ssh liblinux -- git -C liblinux format-patch -1 ${c} --stdout" | tee /dev/tty | termux-clipboard-set
I didn't need to think to write this, I just wrote it right there in the terminal using the shell's line editor, just because I needed it, and it completely solved my problem. It's as easy as pressing up on keyboard now, and I can easily turn it into a script if needed. Nobody had to bend over backwards to add monstruous features to the apps to accomodate me. I knew what my computer needed to do, and I made it do it.
In my opinion we need more of this, not less. More unix and less iphones.
The people that keep arguing for TUIs for everything seem like religious fundamentalists that can't be convinced with any argument that user interfaces should be about the user, and need to adapt to the task at hand.
Every time I use Claude Code, I'm wondering why the hell I'm regressing to the level of a machine. I paste an image that I want fixed, and I don't see the preview of it. I can't cut or edit text somewhere in the middle of a long sentence like in a normal user interface. I can't visualize any helpful graphics, not even Latex. I'm forced to interface like a machine when I'm a human being.
Why can't developers understanding that GUIs and TUIs both have their usage, it just depends on the task?
I'm fine to use vim over ssh into a server, just don't force me to edit fine typography with it.
Tabs vs spaces.
I’ve always appreciated the positive side of TUIs and appreciated less the positive side of GUIs. I didn’t grow up with a computer at all and in one of my first adult jobs I had to use a TUI at Papa John’s for punching in orders, it was 20x faster than anything I used after it at other restaurants that were GUI driven (keyboard speed wins for me, fit my brain perfectly). I think I learned it in 5 minutes. I was just a normy trying to pay bills.
I dunno why we gotta be insulting to people’s preferences, the article is genuinely bad about this.
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.
The day we get a truly good, native binding, resource efficient, cross platform UI framework, then I will agree wholeheartedly.
I love a GUI in many cases! But if I'm building something, I personally want it across Linux and MacOS at least (personal and work, respectively). TUI answers that problem quickly, easily, effectively, and efficiently.
I'm actually amazed that we have never gotten to a really good UI framework that is cross platform. I really just want something like SwiftUI that's truly cross platform, personally. There are a million arguments to say that we do have cross platform GUIs, but all of them lack in some major way.
Sorry, no.
I don't want to forward a whole desktop environment just because I want to use a small application I have written for myself.
TUIs are much more portable, easier on eyes, can be information dense, and resistant to lassiez-faire UI library changes on platforms. They don't need GPUs to render, megabytes of RAM to run, great amounts of bandwidth to access from afar.
I'll write a library for the functionality, and will slap a TUI on top. You want a GUI, write it yourself. Everything is GPLv3 licensed. You can do whatever you want as long as you respect the license.
> Stop Making TUIs
No, I don't think I will :)
It's great for admin tools, alongside CLIs.
It's portable, it's fast, it's discoverable, it has zero bullshit effects, it's as secure as my shell, it's efficient.
And what is this point about agents making it easy to generate GUIs ? They are equally good (if not better) at generating TUIs using any of the great frameworks for this.
Yes, stop making TUIs. Make GUIs in Terminals!
It’s ridiculous how far we have fallen behind the Terminal GUIs from the early 90ies. Look at the Turbo Pascal IDE and business apps built with it. Windows, window management, scrolling in windows, rich dialogs. Everything there. While many modern TUIs are just lists with numbers you can select. Everything is pretty rudimentary
I was missing a real terminal GUI library for some software I built. The rudimentary libraries did not work for me.
That‘s why I took Free Vision (the Turbo Vision derivative for Free Pascal) and ported it with the help of Claude Code over to modern Delphi, then modernised the object system and added lots of features and from there we ported it to go.
There are still lots of bugs and oversights (some caused by me not really knowing how original TV worked) that I fix as I go along using it for real projects.
https://github.com/oldwired/fv-delphi-modern https://github.com/oldwired/fv-go
Maybe on macOS you have great APIs, libraries and toolkits for making high quality GUIs, but if you're wanting to write open source software or target open source platforms, your options are limited and poor.
On the Linux/BSD side, most toolkits are of not great quality, you'll inherit all sorts of subtle bugs and quirky behaviours. Most of the software that's of _great_ quality doesn't use the toolkit, but interfaces with the compositor directly. The effort for developing GUIs under such circumstances is dramatically higher than a TUI, and a TUI is usually "good enough".
I really would prefer GUIs for a lot of things. But when a TUI takes a few weeks to make, the equivalent GUI would take a few months to make.
> I’m not packaging this application up. If you want it, just screenshot this section of the post and give it to Claude. It’ll build something useful. You see where I’m going with this.
This pretense that the entire value of source code is the "spec" / "requirement" is alarming.
The value of the code is how well-formed the spec is + how well tested it is in the real world. So prompt / mockup cannot replace code.
MacOS: what is my purpose
Me: you exist so I can launch iTerm2, Chrome, and VS Code
MacOS: oh, my god
I can't ever imagine using walled garden graphics api in 2026. Particularly for work tooling
While GUIs have some legitimate use cases, I prefer TUIs if I can get away with it. Its just text, ssh friendly, constraint in a beautiful way that still allows endless possibilities.
TUIs are really the worst of both worlds IMHO.
The one advantage that a terminal has, is that commands can be concise and scriptable. But that only really applies to CLI.
A TUI is just a poor man emulation of a GUI, without any advantages.
Personally, I don't like being told what to do in a title. And personally, my hackles raise when that's combined with in-group jargon.
Intentional or not, the rhetorical style of the title, plus the subtitle opening on the word "weird" before it's defined, has an ostracizing effect on me. I guess that it could have an ostracizing effect on others, though I can only speak for myself.
TUIs, work on several operating systems. I use same set of apps across Mac, windows and Linux.
You can use them remotely over SSH connections, and they can survive disconects (within tmux). No VNC, or X11 forwarding needed.
They take less memory. compare vscode vs nvim.
Super fast to launch.
They can integrate with other TUIs and shell apps, shell-scripts, pipes
and lastly they do not contain Ads. lol
Benefit of TUIs is that sometimes they are extension of CLI.
Sometimes I can use `du` to check what uses so much space, but sometimes ncdu is better for me.
And the best part - I can use both when I ssh to another machine, using the same command line, without thought. While GUIs need added thought, to switch from CLI to GUI on the remote one would need to use a different interface, or have X11 forwarding on (which is also a good option) and x11 libs on the other side.
Or use some other connectivity. ssh is simple, works on most servers I have access to.
"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.
A wiki that's somehow not in a browser, a tv remote replacement without obvious keyboard shortcuts, a jupyter lookalike with no editing (as far as I can tell), and two chat interfaces with skills. Good for you, but not like how I use computers.
Some folks love to live in the golden age of CP/M, MS-DOS, and timesharing green and amber terminals, for whatever reason.
I was alive back then already, and was a relief to finally be able to afford GUI powered computers.
Counterpoint: Build more TUIs in Rust using Ratatui: https://ratatui.rs/
Why? Because just look at the examples on that page.
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.
Keep making TUIs. Keep making whatever you want. These "terminals weren't made for that" kind of comments are a bit tiresome. I can run TUIs on machines I only have ssh access to and they are often leaner than the corresponding GUI variant - though perhaps less so with today's fancier TUIs. 'top' has a TUI and isn't exactly new, some interactivity - yes, even in a terminal - can be nice.
I'm currently trying to create a GUI version (immediate mode library) of a CLI tool of mine and it's mostly a shit show and three times the work of a data-in-data-out CLI tool. Good learning experience, though. I should note that I don't care whether the GUI version has a "native feel" or not (if you have the time to do so, be my guest), only whether it's functional and reasonably fast, since otherwise that's even more work for an open-source tool. Though, when I undoubtedly make the more interactive TUI version later on (ratatui just seems too nice not to try! :-)) it will probably bring a similar complexity development wise.
Then again I'm not into agentic coding at all so maybe the joke's on me. On the other hand, at the moment I need to learn about the data I'm processing, the GUI library/framework I use, and being able to help the people I work with troubleshoot the equipment that collects said data. I'd miss out on most of that if I coded by prompt. Perhaps I'll try later, perhaps not.
Keep making TUIs, or GUIs for that matter.
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.
Agree with the rest of the comments here: keep making TUIs. Fully keyboard-driven, compact interfaces that live in my terminal with the rest of my CLI devtools are the best!
One big benefit of TUIs is that they lower the bar for customer adoption. Before Claude Code, it was unthinkable to come up with a mass-market TUI because most users would not use it simply because it's a terminal. Now, it can even be an advantage. Even inexperienced users are no longer afraid of the terminal.
The nice thing about TUIs is: they are platform independent. Whereas with SwiftUI apps you are bound to macOS.
Bit of an overstatement, but I agree with part of it:
- A lot of TUIs that run on your own machine and have a mature GUI alternative are indeed not necessary. I once tried to replace Spotify with ncspot, which was exactly falling into the "TUI is more advanced" trap.
- The real target of this article is people who treat TUI as a kind of identity, not people who have to work in a terminal because of their job and therefore have plenty of good reasons to use TUIs.
But the title and the general tone are still too clickbaity, which is kind of annoying. In reality, apart from a small portion of TUIs that were created just to follow the trend and clearly have better GUI alternatives, most TUIs are really just side tools that grow out of one premise that we have to work in the terminal.
And even those flashy TUI tools still make life easier for people who work in a terminal. If you prefer GUIs, fine, you don't have to use them, but that doesn't mean they have no users or no value.
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.
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.
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.
How about build whatever interface makes sense for the user? Doesn't matter if it's a TUI, GUI, speech interface, or some physically actuated / haptic feedback based system. Do what makes intuitive sense to the user and provides enough expressive power to get their job done without overwhelming them.
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.
The site layout is great for reading, so props to the author.
I understand the sentiment that TUIs is not as accessible, sucks to use. I still do not like the fact that we should "stop making TUIs" altogether.
Let me give you an example from my carpenter friend in Cananda. He has a saw (TUI) and electric one (GUI).
He uses the saw in diff ways than his electric one. He sometimes extend the saw by attaching it to end of a long stick to cut tree branches he cannot reach. He can do it with the eletric saw but requires much more effort.
But if he needs to cut down the tree, he uses the electric one, and sometimes finish off (trim) with the regular saw (so the tree falls in certain direction).
The gist is, TUIs can be used to do things quick and dirty, and easy/cheap to make/buy. GUI even with AIs, still not as cheap as TUIs to build.
TUIs has a different usage in our field, where it's used more for automation/piping. If you have GUI, it's hard to pull it off unless you build the functionality (which coulda been a command in TUI), and expose it via GUI. the Authros is focused more on consumer side than builder side. With AIs we will all be builders using AIs.
Lastly, shooting down people building TUIs is saying, no more innovations, by building upon other's TUI inspirations.
Unfortunately we seem to live in an era where your mainstream choices for a cross platform app are "Electron taking 1GB when idle" and TUI.
Contentious topic but I have hard time comprehending line height scroll instead of smooth Web like experience and everything rendered in the same font size. I guess it’s a habit for people who started early and never got to use web applications enough to develop distaste to TUI scrolling patterns.
> Nothing is stopping you from designing a dense and economical GUI.
Then why isn't it done more often? I suspect part of the reason is that most gui frameworks are not really designed for making dense economical interfaces.
> you probably don’t need a user interface on prod. You need a command line interface on prod that
I don't need one, but I often want one. Being able to run vim, htop, etc. on servers is quite useful. Also, it isn't just prod servers. It's also nice to run tuis on VMs and containers that don't have access to graphics.
> I’m not really building applications for other people to use. I’m building them for me. TUI affordances are an awfully big hit to take to get Linux users of programs I don’t even want to publish.
Ok. That's fine. But then why are you trying to convince other people not to make TUIs? If I make an app you find useful, wouldn't you prefer me to make a TUI you can run on your Mac to a linux-only GUI?
Three broad notes:
- I'm team GUI! The author outline elegantly why. Sometimes I put command-line-like things in the GUI; I generally view it as a superset of CLI, with vastly richer capabilities. This is kind of interesting in the bioinformatics/structural bio space, which I feel is inherently visual, and benefits from 2d layouts. Most of the tools are CLI and based in I/O of stdout and text-based files. I am taking a different direction!
> Back in 1999, Neal Stephenson wrote an essay about command line interfaces that set the field of human-computer interaction back about 20 years. In it, he depicts the priesthood of Unix nerds wielding CLIs as powerful Morlocks, holding the entire computing industry on their shoulders. The Eloi use GUIs like Microsoft Word. Because this is high-test fan-service, “In The Beginning Was The Command Line” has become one of our field’s sacred texts, despite very little of it holding up 25 years later.
We should not take Sci-Fi and creative plot devices as predictions for the future. They can be inspirations and motivations for your own creativity, if tempered by realistic expectations and discipline. Neal Stephenson is especially prescient (Certain concepts from Fall; or Dodge in Hell and Anathem are hitting home strongly right now!). He spins vibrant, speculative yarns, mixing concepts, and estimating trajectories. The story referenced he is one that's in particular easy to see what parts did and didn't pan out. (And what Neal's more recent reflections on it say)
I think there is a bit of cultural identity (Which we are genetically inclined to insert in all sorts of places!) going on. There is a certain cyberpunk fun in SSHing a terminal, pipeling stdout/in together, and Viming. I suspect there is a high overlap between people for whom Linux is part of their identity, TUI use is as well. I.e, it's not about a practical weighing of merits; standard identity/tribal-based choices.
FOr use of TUI as a general file browser/command-executor... I've made my own. It's a GUI, and has built-in terminal for executing commands, with a visual file browser. And most importantly: Shortcuts to execute commonly-used workflows, history, bookmarks etc. All of which I feel like are glaring things missing from standard terminals. (PS, Bash etc). And having a terminal as one part of a multi-window program feels like a good use of my screen space!
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...
Found this article to be a bit of a slog, burying the lede until after you’ve sifted through a rambling list of irrelevant vibe coded apps by OP. The actual argument came across in places but I am unpersuaded. Unsure if that’s due to the article structure or the argument’s own merits.
You can't tell someone who doesn't like the command line why it's so awesome.
EDIT
> CLIs have purposes for which they’re irreplaceable. Building a CLI is almost always a good idea. Building a TUI almost never is.
Oh, right. I can see that, but I go the other way: When I have a CLI, don't give me GUIs; give me files. Actually, just give me files and daemons. I'll do the rest, thank you!
TUI are often inferior to GUI from a user perspective, but not necessarily by much.
On the other hand, they are easier to build in a cross platform manner.
Linux is probably the most difficult platform to build GUI for, because of all the fragmentation, X11, Wayland, all the different flavors of GUI toolkits, driver issues, window managers issues, font issues etc.
TUI are a bit like web apps in that regard, using the terminal instead of a browser to abstract the platform.
TUIs work where I do. I don't want to juggle another window unless I need to. Tmux gives me better ways of organizing my work than most display managers. Most of the useful things I do end up calling other shell commands, and it's nice having terminal right there. Ctrl-t / fg are also uniquely powerful.
UIs are also useful for information that is best represented in a UI. keep using those too.
You can bend each to be more similar to the other, and that's good too! Sometimes there is a good use case for that.
Funnily enough I wrote a similar blog about this in the era preceding LLM assistance.
I’m with Tom on a lot of what he says. This is a nice reminder to take another shot at this.
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'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.
Hard disagree. Make more TUIs!
TUIs have downsides like accessibility, poor mouse support, but work really well if you focus on keyboard input. It is a better/faster input mode to begin with, especially for power users, but also for average people; you'd be surprised at how much more user-friendly an arrow-keys driven UI can be vs modern web interfaces.
I've been building my own TUI framework [1] and getting amazing results. Good TUIs are more of a GUI than a dumb text terminal.
If we had a cross-platform usable GUI framework, and more consistency across OSes, the story would be different.
[1] https://github.com/ricardobeat/milktea