What originally got me excited to build TUIs was the concept of delivering apps over the wire via SSH. SSH apps resemble a browser in that way: no local installs required.

It's a major reason why I enjoy hacking on https://pico.sh -- deploying the TUI requires zero user involvement.

The only hard part about vim is to be forced to strecth the finger up to Escape for what is essentially the most essential function in a modal editor: Going back to command mode. The ideal workflow is do a quick edit and go back to command ("normal") mode instantly. The fact that Escape is used is a historical artifact that needs to be called out.

So just remap CapsLock to escape, it system-wide, it's not that hard and it's nice to have Escape there generally. In Linux and MacOS it's just a GUI setting away and in windows you just have to edit (create?) a registry key. Can be done on any machine under a minute.

Apart from that I don't see where the learning curve is since you can just start with the basics from vim-tutor and look up for more when you feel you're spending too much time on something. I already felt faster than in any other editor when I just knew the basics. The real problem of vim is that you get used to modal editing very quickly and it feels like the stone age when you don't have it.

There's not a single good universal UI. The best is the browser and it is reasonably successful but the sandbox makes it specifically unsuitable / high friction for doing things that need local access to files, network, etc. And it is ridiculously high overhead if you just want to run something simple. Then remote access is even more a debacle. Can I access an application running on my windows host from my Mac? can I forward that through a tunneled connection?

TUI is a simple, universal protocol that does what you need and is natively remote. Whatever I use locally will seamlessly work over an SSH connection.

And it's a big middle finger to the OS vendors who thought locking everyone in by making everything incompatible or ecosystem specific was a winning strategy.

I live on the CLI, I have one a hotkey away, but please, technology has advanced significantly since the terminal was the only option, and we have far better options for building UIs now.

It's just a shame that we don't have a great cross-platform, streamed, UI system. The web is great in it's own ways, but clearly something could be a lot better for this purpose. Flutter's ok, but not on-demand enough and too married to Dart.

With that background, most TUIs are really two steps back compared to a decent GUI. (Wild west navigation/hotekeys, broken copy and paste, lack of integration with the environment, just to name a few.)

The core of the problem is IMHO, that we really lack a decent cross platform GUI platform, which is really integrated into a programming language or part of the standard library.

Outside of Swing (which lacks access to a native browser element), we have Tk (no browser component, no drag'n'drop, at least from Tkinter), wxWidgets (seems that the community is very small and especially its bindings needed to be resurrected at least once), Qt with the ever looming possibility that it will get deshittified to make more money (... and no, KDE is not that important and I doubt the KDE community could take care of a fork long term).

Which leaves us with Electron or the other variants of 'browser component + JavaScript/CSS and callbacks to a local server, which is a really bad programming model (ignoring the memory/runtime overhead for even trivial applications).

The problem is, to build a decent cross platform gui toolkit, one needs a lot of funding and a lot of people (usability, accessibility, design, documentation, testing...). The open source community didn't manage to pull this off (GTK is by now for all practical purposes Linux only) and there is no modern contender for Qt or Swing (with their own problems).

TUIs are no solution to the core problem (and it would be absolutely possible to have a GUI toolkit with a TUI renderer for perhaps 80% of GUI needs), but I understand every developer who chooses TUIs for cross platform UIs given the alternatives.

- No distractions from visual content

- Extreme efficiency with keyboard

- AIs can code them up quickly. It used to be a total pain

Oh we need multiple windows we can move around/resize? Let's make them text windows. We want people to be able to quickly select options? Yeah make those text boxes. We want to quickly compose documents with some kinda style/formatting? Yeah they'll need to write more text to format it (but let's not make any apps to easily view the text in formatted mode).

I don’t know if TUIs will be the answer, but it’s an interesting development!

Also, the explosion of new languages in recent years means having to write a new set of FFI wrappers around existing libraries, and it's easier to make an idiomatic library for TUI development than wrap all of GTK+ or Qt.

I don’t need pretty buttons, I need usability and readability. Without having a 50” display!

To avoid context-switching from the command-line, many essential UIs were made text-only. Another route would have been to integrate the command-line within graphical applications, but few did it -- the main example that comes to mind is Jupyter.

[0] https://github.com/rothgar/awesome-tuis

[1] https://terminaltrove.com/explore/

[2] https://github.com/ibraheemdev/modern-unix

Even before Claude Code, I always see htop as the prime example of a good TUI.

We made our machines 100x faster and instead of running compute locally we just made 100x slower client software.

For me what makes a software usable in the long run (after initial learn) is shortcuts and keyboard navigability. Old GUI frameworks had built-in features for this (app-wide shortcuts, underlined letters, etc.). The web has haphazardly copied one of them (“accesskey” attribute), but now this has been completely forgotten. None of the major websites have accesskeys, even for the most frequently used element like the search bar. There are no shortcuts for frequently used functions such as “like”, “reply”, what have you. It's like developers have universally forgotten that the keyboard exists and what it can do.

TUIs don't solve that.

So we created tooling we know on the CLI.

Every person here that thinks its AI that caused the resurgence of CLI tools is a vibe coder who just entered the scene this year.

Lucky you. I avoid electron apps because I'm limping along with 16gb.

People now have access to good terminal emulators. Back in the day, you had cmd.exe in Windows. Now you have a plethora of Linux/Unix terminal emulators, Terminal.app in MacOS, and Windows Terminal in Windows 10/11. These are quite capable applications able to render good, complex text-based interfaces.

Embracing constraints and "how it works" used to be at the core of their software ethos.

The current implementation isn't command-line, but a re-implemented GUI in disguise, awkward and even more buggy. Why should I use that over a GUI? I would prefer Electron over those TUI unless I have to SSH.

TUI are snappy, accessible over ssh, small screen friendly, easily embeddable in zellij or other multiplexers, easy to copy paste from... Amazing.

For the past few weeks I've been wrapping up Booba [1], which is developer tooling to combine BubbleTea and Ghostty in WASM deployments (using ghostty-web).

It provides for some interesting deployment patterns both locally, over network, and embedded in a web page. It's intended to be very easy to adopt; at the simplest, one just changes `tea.NewProgram` to `booba.NewProgram`.

I used Booba to make a demo page [2] for our NTCharts TUI library published to GitHub Pages. The repo READMEs have GIFs... this page is all embedded WASM.

There's also new Kitty-Graphics-supported widgets in there (picture, chartpicture); I updated Booba and Ghostty-Web to support it. Still getting the kinks out.

[1] https://github.com/NimbleMarkets/go-booba

[2] https://nimblemarkets.github.io/ntcharts/demos/heatpicture-p...

It's not too bad to theme GTK apps and have them all look a consistent way. For example I use Tokyonight Moon and Gruvbox and they both have GTK themes that look great for Firefox, Thunar, GIMP, LibreOffice and more. I don't use Omarchy but here's a few screenshots https://x.com/nickjanetakis/status/2037125261657883061/photo....

Nothing fancy was done on my end, just installed the specific GTK themes. They even support live reloading because GTK's tooling supports it, my dotfiles at https://github.com/nickjj/dotfiles handle all of it for you. I still prefer TUIs but you can have nice looking GUI apps for when you want them.

I get more things done, in most cases, than via a GUI. In a way a TUI is a GUI of course, but with the focus on keyboard use and inputting instructions/commands. Most GUIs seem to be centered around keyboard AND mouse and then try to make things convenient here for those operations, such as drag-and-drop via the mouse.

I would say the optimal UI is a Keyboard driven normal Desktop app. An app that can take full advantage of graphics elements of a desktop app but is lightning fast to interact with thanks to that it's keyboard driven. Very few people build apps like that though. Sure there are keyboard hints in many apps but they are usually not 100% guaranteed to cover all cases and are sometimes an afterthought.

In a way AI agents are validating what us old-timers always knew: the CLI and TUIs is the most powerful way. And AI tools didn't choose the most common dev environment: devs using fat IDEs (and btw I was already using IntelliJ IDEA back when some people were still arguing NetBeans was better than IntelliJ) are way more common than those piping Unix commands to achieve even simple tasks. Instead AI tools did choose the most powerful way to work: and that's piping terminal commands and SSH/tmux/TUIs.

When the tool itself, like Claude Code CLI, is immediately showing the outputs of piped Unix commands and allowing to run commands from a prompt and is, itself, a TUI, it's validating that it's an extremely powerful way to work.

A Claude Code CLI (or similar) TUI in a tmux session is something quite powerful.

Then you combine that with the fact that techs like LSP and tree-sitter did at least partially commodotize the IDE and suddenly TUIs (or things very close to it, like GUI Emacs: which can do graphics but is still mostly used as a TUI tool) do look very appealing.

Magit is considered by many --even non Emacs user-- as the best Git interface ever. It's text, text and more text.

My life is terminals (text), Git and Magit (text), Emacs (GUI but basically text), SSH (text), tmux (text), many text things I forgot and now TUI harnesses.

If you're modelizing in Blender or editing movies or creating movies, a GUI makes sense. But if you write code, which is text, all you need is text, text and more text.

TUIs are making a comeback because it is all text and AI agents are proof of that.

Even in the PC world, the move from DOS based TUI programs to windows GUI in applications like POS was not without some user trauma and insatisfaction.

If you have python installed, you can start a web server with a couple lines of shell script. Is there any really good truly lightweight webserver? (Something under 256KB)

I was vibe coding a layer on top of textual last week that allows me to plug in both interactive and information display Python functions into a TUI grid. Really simple stuff, with textual doing the heavy lifting.

It's by far not as beautiful rendered as the native OS layers, but easy to navigate and a good foundation for cross platform GUI development. And I got it even approved for the MacOS app store. Here's my write up: https://marchildmann.com/blog/imgui-mac-app-store/

A reasonable TUI can be built without any design or frontend people even looped in.

Collaboration and coordination tend to slow down processes and flatten outputs.

I think this is the primary reason. I feel like whether or not there are good native libraries things were bound to converge into cross-platform preferencing since it's cheaper to produce and maintain.

Seems like it could have gone differently. Feels like the time could be ripe for something like a "declarative gui spec."

I don't know about everyone else, but the code I reviewed as a Junior was high quality code I was expected to learn from. That's entirely different from doing code review on whatever CC outputs.

TUIs are popular because once you use a piece of software that doesn't have a poorly-written GUI library full of animations bogging it down, you don't want to go back.

It's hard to make a TUI that isn't snappy, no matter how much useless eye-candy it has.

I'm pretty sure the success has nothing to do with the TUI though. I personally enjoy it a lot but the productivity boast doesn't come from avoiding the mouse.

Can someone who is more knowledgeable about these help compare and contrast these three texts a bit?

I am affected by it also and have always been fond of TUIs in a nostalgic way.

JS literally destroyed the software landscape. All the bad practices advertised as best.

The biggest current reason is fashion. Tools like Claude Code did it, and while they actually had good reasons to run in the terminal, the tools' popularity and wildly different look, especially to non-terminal-native users became a signal of some positive sort.

I don't believe that any of the rationale posed in the article is a popular reason developers are using.

Failing projects over bad UI teaches fear, not design. Good interfaces come from iteration and feedback - which is exactly what user-centered design is about

Dumb question and slightly off topic, but is there a reason why so many AI tools are CLIs … as opposed to just an API or another interface?

I feel like I’m missing the obvious in why there feels like an explosion of CLI tools lately, related to AI.

But that's changed drastically in the last few months. I spent the weekend doing SwiftUI stuff with Claude, with a lot of success. It's going to get much easier to ship fast, solid, native UIs for things, and native UI is both very fun to build and also attractive to ordinary users.

(Fun green field for doing interesting UI work: do native UI for remote server stuff, like an htop UI that uses some dialect of SSH to fetch remote data.)

I think modern TUIs are a blip. A big, important blip. But a blip. The age of the Orc is over. The time of the Human Interface Guideline has come.

I think it's important to note this because it's not great. Either I'm having a fever dream, or, someone will GUI this stuff and it'll be a gamechanger.

Interact as needed, matrix screen saver when idle to prevent burn in.

I don’t see terminal apps as heavy at all…

How to make them a wallpaper thats interactive I wonder…?

Funny if I just search it… PlashApp by Sinde, Set to Termix docker and BOOM :)

Don’t fall for this.

For people who don't know this version of TUI, it's the ole, "Press 1 for X, Press 2 for Y" kind of interfaces that you use over a phone. Think voicemail text-to-speech and automated speech recognition.

I've been reverting more and more: mutt (mail), newsboat (RSS), amfora (gemini protocol), gurk (Signal), chawan (web), and even trn (Usenet). My RAM usage is tiny. Everything is quick.

GUIs should take a page from the TUI playbook and consider making the app keyboard-first. Nothing is more frustrating than a missing hotkey.

if TUIs were truly back - as DHH would like you to believe - his money maker - Basecamp - would be available as a TUI, Salesforce, Workday, Bloomberg etc would be available as TUIs. Though Bloomberg is the closest to a TUI.

but let's continue to delude ourselves.

Citation needed?