- No distractions from visual content

- Extreme efficiency with keyboard

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

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

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

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'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.

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.

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.

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

Don’t fall for this.

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.

The only hard part about vim is to be forced to strecth the finger up to Escape for what is essentially the most essential functin in 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 it's Escape is a historical artifact that needs not be.

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 learn more when you feel you're spending 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.

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.

Citation needed?

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

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.

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.

https://github.com/rothgar/awesome-tuis

https://terminaltrove.com/explore/

https://github.com/ibraheemdev/modern-unix

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

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.

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.

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