Ask HN: Interesting TUIs (text user interfaces), maybe forgotten ones?

Lotus 1-2-3: https://github.com/taviso/123elf

cointop: https://github.com/cointop-sh/cointop

Midnight Commander immediately comes to mind, but also Borland's C++ compiler.

I recently built a TUI for exploring and developing CUE, JSON, Yaml.

Large inspiration for the overall UX comes from the Bloomberg terminal, where every function is reachable with four letter shortcut from the command box. It was really the command box that I liked. I've also built a sort of "flex" panel component for the layout so you can create as many panels as you like.

https://docs.hofstadter.io/getting-started/hof-tui/

https://github.com/hofstadter-io/hof/tree/_dev/lib/tui

This was built on the tview/tcell stack in Go. There is also the Charm.sh stack that takes a different approach but is generally prettier and more polished (having a company behind it)

The text interface into AutoCAD was pretty amazing...and like Emacs, backed by a Lisp. We'd run it on dual displays, one SVGA and one Hercules just for commands. The experience was very 'lingustic.'

In stark contrast to most GNU/*nix tools, I really liked MS-DOS's edit.com text editor. Unlike emacs or vim or even nano, it didn't have a bunch of invisible shortcut keys, just a Windows-like drop-down menu system (but rendered in DOS).

You could easily browse through the menu hierarchy, but still memorize certain shortcuts that you often use (just like Windows). In later versions you could even use the mouse to select things if you wanted to. It didn't try to force any one particular method onto you, but let you use the input you're most comfortable with.

So many CLI tools are incredibly idiomatic and require you to do something in a very particular way with no on screen hints. Even the help screen is normally hidden behind some key combo. TUI or not, that seems unnecessarily elitist.

I think some of the old telnet MUDs or BBS games are nice to learn from, whether they used helpful text prompts (you are here, this is what you can do) or just rendered graphical menus in ASCII with colors. For some reason I still don't quite understand, games still seem to have more UI focus than productivity apps. Maybe cuz they tend to target the general public instead of B2B users?

Another pattern I really like: In more modern GUI IDEs and editors like Sublime or Jetbrains or VScode, you can usually launch a floating command input bar that will search through available files, commands, settings, etc. That lets you quickly find the thing you want without knowing the key combo for it (like format code, or forking a branch, or turning off word wrap). It would be cool to have a LLM layer in there that could parse natural language (instead of a basic keyword search) and execute commands based on that.

  $ cat rgbdemo.sh
  #!/bin/sh

  alias p=printf

   N=$(p \\033) N="$N[" x=30

   for a in Bl R G Y B M C W  # Black Red Green Yellow Blue Magenta Cyan White
   do eval $a='$N'"'"$((     x))"m'" \
          b$a='$N'"'"$((60 + x))"m'" \
       ${a}bg='$N'"'"$((10 + x))"m'" \
      b${a}bg='$N'"'"$((70 + x))"m'" # bX=bright Xbg=background bXbg=brgt bgnd
      x=$(( x + 1 ))
   done                       # https://en.wikipedia.org/wiki/ANSI_escape_code

   N=$N'0m'

  echo "I am $Wbg$R red, $G green, $B and blue $N on a white background."

WordPerfect is an interesting example: https://lock.cmpxchg8b.com/wordperfect.html

WordStar is another one, used by George RR Martin et al: https://arstechnica.com/information-technology/2017/03/words...

The other day I found many TUI tools on a site called Terminal Trove:

https://terminaltrove.com/

And it also features a great list of them here that many might not have heard of.

https://terminaltrove.com/list/

For example trippy and nvtop look very nice for TUIs and other 'top' based tools they have listed there.

https://terminaltrove.com/categories/top/

https://terminaltrove.com/trippy/

https://terminaltrove.com/nvtop/

There's screenshots and install instructions that's also convenient.

If you want more Emacs examples, Org-mode and Spacemacs (especially in Evil-mode) have a ton of functionality

https://github.com/jonas/tig is one of the first things I install on a new dev machine. It's a really nice UI for staging files or hunks. Since it's just a companion to the git CLI, it feels much more focused than full-blown git GUIs, and doesn't do anything magical.

It's hard to not mention ColorForth here as a primarily-text-based UI, although it ran in graphical mode and did its own text rendering. There were a few language-based innovations that tied closely in to the UI, including the use of color tags on pre-tokenized source code to both select display color, but also to select semantic category of the symbol (e.g. execute at compile time like a macro, execute at run time like a function call, define a new symbol). Probably more interesting is its use of a modified dvorak keyboard layout (later with qwerty support as well), with a consistent onscreen display of the keyboard mapping, indicating what each press will do at any time. I can see this concept generalizing to something like vi where the key-to-meaning mapping is equally dynamic and modal. Lots of other info at https://www.greenarraychips.com/home/documents/greg/cf-humin... and elsewhere.

As someone who writes software for moderately boring business operations, I've been wondering making terminal-based apps with lots of keyboard shortcuts would lead to a more productive end user than writing a web app.

I've been looking at https://github.com/gui-cs/Terminal.Gui but haven't tried it yet.

The "htop" app, an alternative to the conventional "top," is a nice example of a TUI: <https://htop.dev/>

Well you have the MS-DOS era Borland tools.

Someone took the time to rewrite it as a cross-platform open source library: https://github.com/magiblot/tvision

Edit: Not a rewrite, but a port. See comments below.

QuickBASIC or even Visual Basic 1 immediately come to mind. They have good, discoverable navigation and documentation.

I have no idea where you'd be able to find it since it's a proprietary product but InfoLease 9 had one of my favorites TUIs from a long gone era. You could navigate through and edit complicated contract information extremely quickly through a series of fixed number based menus and views. Once I got the hang of it I could blaze through entering tons and tons of data without any effort. I suppose a lot of BBSes had a kind-of similar interface but without the field validation and documentation (you could write ? virtually anywhere to get quick documentation about what you were editing or what something was intended for, and fields were validated in this really "perfect" way where it never felt like you lost time if you fat-fingered something).

These certainly aren't forgotten, but I like:

* `ranger` file manager: https://ranger.github.io/

* `ncdu` for visualising disk usage: https://dev.yorhel.nl/ncdu

* `htop` process monitor: https://htop.dev/

I just find them very intuitive, and information-dense while not being overwhelming.

Another one, which i'm admittedly personally vested in, is fnc, a TUI for the Fossil SCM: <https://fnc.bsdbox.org>

Last few weekends I worked on a FPGA based Linux VT subset compatible tty display implementation for my HW projects.

Something that can be used to present some simple TUI on a largish LCD based on a simple 1-wire UART interface in a semi-standardized, performant and cheap way (good quality IPS displays are ~ 6-10 EUR, and tang nano is 10-20 EUR, depending on model).

https://megous.com/dl/tmp/tty-fpga.mp4

It also implements an efficient "scrolling" output mode, so it can simply be connected to anything that produces debug output on UART, too. Use cases are pretty flexible. Smallest Microchip PIC MCU can easily present a reasonably nice UI. :)

It can also accept input over the Tang Nano's USB UART directly from the connected PC (which is what's on the video).

At 3 Mbaud, it's possible to keep updating the content of whole screen at 50 FPS from a simple MCU, over a single wire at easily manageable interface frequencies. Anyhting less, like incremental changes to subset of screen content via ANSI escape sequences pretty much runs at 60FPS/display's refresh rate.

It's based on Tang Nano 9k currently, but it should fit even Tang Nano 1k, which is a bit cheaper.

quite a few great examples on this thread. I'll add lazygit (https://github.com/jesseduffield/lazygit) for doing git stuff, and fx (https://github.com/antonmedv/fx) for working with JSONs.

IBM ISPF suite is gorgeous.

lazygit is excellent imo. every ui with keyboard shortcuts needs an action menu showing the keyboard shortcuts. You can execute commands from this menu, but it teaches you the keyboard shortcuts over time too. especially important for a tui, where it’s mostly/completely keyboard controls.

This one is more a layer 8 issue perhaps, but ideally there is some sort of guard rail that makes it so that if I accidentally start typing a message I think is going into slack, but I still have the tui focused, doesn’t execute a ton of very hard to reverse actions. Perhaps a good undo/redo stack is enough here, but some sort of vim like modality could work even better. It doesn’t happen often, but if it’s something like k9s the blast radius is… pretty big!

https://www.ztree.com/ a clone of the old DOS Xtree. Quite the learning curve, but very powerful.

Not particularly high-level, but representing common TUI designs and usage patterns on Unix: Slrn, Mutt, Ncdu.

https://en.wikipedia.org/wiki/Slrn

https://en.wikipedia.org/wiki/Mutt_(email_client)

https://en.wikipedia.org/wiki/Ncdu

This just reminded me of my custom TUI-based installer for my FidoNet reader (1997): https://twitter.com/esesci/status/1617997539688722433/

I miss Borland TurboC++. loved the simple drop down based TUI. the only thing I wish it has today would be good integrated symbol browsing and debugger. pair that with a tmux session and you are golden.

I don't know if it "deserves to be known" but I made debase to make git editing easier: https://toaster.llc/debase