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

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 are in the US, pick a slow day and chat to the customer service people at Lowes or Costco. Both stores use TUI interfaces for their instore service apps, and boy are they fast with them. They reserve GUI things for the self service point of sale systems and keep the TUI for cases where speed matters. I suspect that these apps might once have been mainframe hosted (in other words, screen-oriented, with the PC terminal doing local processing and not sending the request to the server until the user hits Send) but of course those days are long gone and I imagine that at worst they are running on a TN3270 emulator and more likely they just expose a remote app in a browser or RDP session.

Some things I observe from watching these apps is that navigation clues are always present, keymappings are static from screen to screen (F1 is always help, say), and the UI is such that the user is always in control of the application state.

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.

I'm a maintainer of Ratatui (a rust TUI crate). Here's a few links

https://ratatui.rs/showcase/apps/

https://github.com/ratatui-org/awesome-ratatui

https://discord.com/channels/1070692720437383208/10729061831... (made with ratatui channel on our discord server)

We encourage our users to use https://github.com/charmbracelet/vhs to build out demos that look neat.

My particular favorite of the bunch (from a look and feel perspective) is https://github.com/zaghaghi/openapi-tui

Also, not ratatui, but worth a look: https://github.com/rothgar/awesome-tuis

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.

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.

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.

I recently had a coworker point out VisiData: https://www.visidata.org/

It has a huge number of data formats it can visualize, but I haven't taken the time to go through them all. What I do know is that it is great for viewing CSVs in a terminal. Even if I don't use it for anything else, that alone merits an install from me.

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.

I absolutely love visidata : https://www.visidata.org

It’s a data exploration tool packed with features, but my regular use case is to just pipe some json into it to get a table view; it lets you easily explode nested fields into separate columns which I find tremendously helpful when digging

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

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

I've been faffing about with mainframe stuff lately using Hercules. So I'm going to nominate ISPF on mainframes.

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

Because the IBM mainframe world was late to the time-sharing party (ISPF was based on TSO, the Time-Sharing Option for System/360 and System/370, because the default mode for mainframes was batch processing from punched cards), and because IBM's 3270 terminal used screen-at-a-time updates instead of character-at-a-time, sending interrupts to the CPU only when Enter or a PF key was pressed, ISPF feels clunky and foreign compared to modern TUIs. But it really had a nice design, providing a vast improvement in UI to the mainframe in the form of a menu-driven interface, with a common API that application developers can use to take advantage of the same interface features as the system provides. There are even comprehensive help screens. Here's a demo of ISPF in action:

https://www.youtube.com/watch?v=IWVD2yM3tsY

This interface, or something like it, is what my mom used during her early days as a customer service rep for a large insurance company back in the 90s. You tab between fields, mash Enter to send the whole form, or hit an F key to take various actions. She became quick and efficient at entering or updating customer data. Then they switched to an all-new, all-shiny J2EE app with a browser front end, and she was completely at sixes and sevens. She may as well have turned into a large insect like Gregor Samsa, because the new UI made her less productive, she was punished for it, and she was not allowed to train with the new UI.

We think of mainframes as old and stodgy, but really what they were built to do they were great at: accepting and processing large amounts of business data and transactions. The workflow for that use case was incredibly streamlined, and modern software businesses could learn a lot from how the mainframe did things.

Not what's commonly understood as TUI, but I love Acme from plan9

https://www.youtube.com/watch?v=dP1xVpMPn8M

The entire UI is composed of text. You can place arbitrary commands anywhere on the screen. Interaction with other programs is natural and seamless. You're also not confined to the ANSI-terminal model. Perhaps most shockingly, Acme uses the mouse a lot.

I find that there's a lot of confusion between text-based, CLI, and ANSI sequences. That's unfortunate.

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

I use aerc as my goto email client every day.

bandwhich: Terminal bandwidth utilization tool sc-im: A very capable terminal based spreadsheet program. bpytop: Linux/OSX/FreeBSD resource monitor broot: New way to see and navigate directory trees daff: provides efficient table comparison and alignment, supporting formats like CSV and SQLite, making it essential for data analysis and synchronization tasks. It's indispensable for those requiring accurate data comparisons in analysis, development, or data integration projects.

The original Oberon tiled interface where commands and menus are text that you run, that generate more text. This still exists in blackbox framework oberon/f which embeds text commands in documents. Personally I like the workspace like text UI more than terminals and repls. In a workspace commands are retained, and output persists, they don't fly away but remain on the virtual screens..

Framework (https://en.wikipedia.org/wiki/Framework_(office_suite)) was amazing.

It has been converted to be a Windows app and still is for sale, it seems doesn’t try hard to sell stuff (“For pricing information call or email us”), but its site (https://framework.com/) and doesn’t do the product justice, to be kind.

I couldn’t find a good demo either. https://youtu.be/RKR42Gmrydo?si=ILGJFiY33cFmcZ-o will have to do, but doesn’t show at all how easy it was to write small programs manipulating frames.

I'm surprised I'd had to scroll so far down to find orthodox file managers mentioned (Norton commander, midnight commander, etc.)

Bezroukov has written about the type of TUI he calls "orthodox interfaces" and he does it more justice than I can: https://softpanorama.org/Articles/introduction_to_orthodox_f...

I'm getting kind of old by tech standards (33), but when I was 16 (2007) I worked at a McDonalds franchise as a cashier, and their screens were TUI-based.

I actually really hated it, because there was a six character limit meaning that most stuff had to be abbreviated. A double cheeseburger was "DBLCHZ", McNuggets were "MCNUGS", Fillets of Fish were "FIOFIS". I got used to it eventually, but learning was a huge pain because you're at the whim of figuring the abbreviation of whomever programmed the machine.

Still, it's better than a lot of other fast food kiosks that I heard people use, where they didn't even have words, just pictures, which I think I'd hate even more.

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

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

The Logfile Navigator (https://lnav.org) is a log file viewer/merger/tailer for the terminal. It has some advanced UX features, like showing previews of operations and displaying context sensitive help. For example, the preview for filtering out logs by regex is to highlight the lines that will be hidden in red. This can make crafting the right regex a bit easier since the preview updates as you type. lnav also has some simple bar charting abilities, so you can visualize the results of SQL queries made against the log messages.

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!

Linux's `make menuconfig` [0] and GDB's TUI interface [1] are the first ones that come to mind. Both are very powerful once you get to know them a bit, and are still valuable tools today.

[0] https://en.wikipedia.org/wiki/Menuconfig

[1] https://sourceware.org/gdb/current/onlinedocs/gdb.html/TUI.h...

While there were many things I didn't like about the AIX "smit" sysadmin tool, the UI in the tty version was pretty smooth for the time period.

An example: http://img1.51cto.com/attachment/201204/133704226.jpg

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

GFA Basic on the Atari ST was great. Had code folding and autocomplete/intelligent syntax before most. Compact two-line menu at the top listing the currently-relevant keybindings.

WordStar and WordPerfect both were also fantastic things from that era that took advantage of the terminal environment.

Also, many IBM 3270 "green screen" apps in banks, stores, airlines, etc. were actually extremely well thought through. In the 90s they would get maligned and replaced with "better" Windows client-server GUIs, but usually the GUI was in the end inferior in terms of workflow and reliability.

When I was a minimum wage employee at Canadian Tire early 90s, the green-screen terminal-based inventory system was odd and unorthodox but actually very quick to work with and with decent design.

As a sound and music computing person, I rarely used tui before although I use cli tools often, e.g. SoX. I usually use Audacity to record on Mac. But then I realized I wanted a tool that could quickly open and record inspiration, and that's when TUI came into play: I decided to write my own custom tool called asak (audio Swiss Army Knife) [1]

This way I can quickly record on Mac, with some interaction, and of course, since this is Rust and ratatui [2], this tool should also be cross-platform.

[1] https://github.com/chaosprint/asak

[2] https://ratatui.rs/

Recently I've been making Transient-based porcelains for some venerable Emacs packages. - For calc, there is Casual https://github.com/kickingvegas/casual - For isearch, there is cc-isearch-menu https://github.com/kickingvegas/cc-isearch-menu - For Dired, there is Casual Dired https://github.com/kickingvegas/casual-dired

All can be run in a TTY to get that TUI experience.

I maintain a list of all my favorites here (the ones with rainbows have TUIs or pretty colors):

https://docs.sweeting.me/s/system-monitoring-tools

There's also this list: https://github.com/rothgar/awesome-tuis

In particular ones I haven't seen mentioned already are:

pudb (gdb for python), glances (better htop), memray, fdisk, ctop (htop for docker), dissy (dissasembler), fzf (file browser), micro (like nano meets Sublime Text), hexyl (hex viewer)

Most people probably already know ranger and vim. If you like those, stig is a fantastic frontend for the Transmission bittorrent client. Has both tui and cli. I mostly use the tui, but sometimes cli is useful for e.g. `sleep 15m && stig start stopped`.

The tui controls are quite intuitive if you know vim, and a lot of them are basically abbreviations, like ts for torrent start/stop, tm for torrent move (setting path), tn for torrent name (rename top level dir/file of the torrent), td for torrent delete. The command mode in the tui is also quite flexible. You use :add to add a torrent by url or file path, and you can specify -s to add in stopped state and -p to specify the path for all those torrents, but those args can go before or after the torrents. Depending if I have the path or torrent on my clipboard first I'll write out the command differently. Often I use primary selection to grab a torrent url from my IRC client and then my clipboard manager of sorts to slap a path on my clipboard and paste both in quick succession.

I keep it running in tmux on my server and can add torrents from my phone or PC over ssh. It can connect to remote Transmission sessions, but my distro doesn't package it so I just run it on the same server as Transmission. In the past I used other frontends for Transmission and Deluge, but none are nearly as good as stig.

Some which I use: lf, neomutt, moc/mocp, newsboat, fzf. Screenshots for some: https://nunosempere.com/blog/2023/03/27/soothing-software/

to a lesser extent: btop, htop (but I find the shortcuts confusing), csvlens (https://github.com/YS-L/csvlens), lynx (elinks, links).

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

From the pre-GUI era, one favorite would be Ken Thompson's text editor "ed". It's built with a print output in mind and it doesn't show you the text itself by default. You'd have to target a line range and specify an action such as replacement or even to print it out to screen or paper; using the now famous g/re/p pattern. The minimalism is really cool. ed is still around as a vital part of the vim text editor to this day actually.

- Lazygit: has completely replaced how I do all git things now. Fantastic interface, nice and speedy, easy to learn.

- K9s: replaced my use of kubectl and the K8s dashboard. Lets you go from browse —> action on a resource so much faster than kubectl.

- btop: it’s like top, but way prettier.

The PUFF microwave simulator is a favorite of mine and quick enough for what it is. Not a modern UX flow though.

https://www.pa3fwm.nl/software/puff/

VBDOS, Visual Basic for MS-DOS, was incredible at quickly whipping together a TUI. The tool itself was a pretty slick TUI but I used it for writing all sorts of TUI tools for everything from doing my homework for me to editing game config files.

Examples of building blocks for UI in Emacs: - transient (notable app: magit) - hydra (another menuing package for emacs) https://youtu.be/_qZliI1BKzI - minibuffer helper packages: vertico, orderless, embark, etc https://youtu.be/d3aaxOqwHhI

I don’t know if you can find it running anywhere, but the fox pro database (before the Microsoft acquisition and turning “Visual”) was really easy to use.

You could build a relational database and lookup and entry forms for an app all in a tui.

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.

These are neither pretty nor good examples ... but teletext [1] and the french minitel [2] surely were interesting

[1] https://en.wikipedia.org/wiki/Teletext

[2] https://en.wikipedia.org/wiki/Minitel

Also... In terms of writing TUIs inside emacs ala magit, etc. it couldn't hurt to go look at the similar tools inside classic Lisp machines and older emacs (zmacs, etc) variants. Or even Oberon/Lilith or Perq or other machines of that era.

Definitely, the buffer-based metaphor rocks, and that way of working with things was kind of lost outside of emacs.

Elia is a really nice TUI interface to LLMS (https://github.com/darrenburns/elia)

Toolong is a log file viewer / tailer (https://github.com/Textualize/toolong)

Where Emacs helps you with such homages is if you want the powerful programming environment for doing it, or the rich support for text buffers. (Or if you're doing it for practical use, for people who want to use Emacs.)

But if Emacs isn't a requirement, you might have an easier time doing many TUI things in Python or Rust, with one of their fancy libraries. Emacs can be made to emulate things like cursor-addressing, but the underlying representation, and the features layered upon it, aren't designed for that, and you have to fight them.

(BTW, after seeing the Canon Cat again on HN the other day, and realizing that the pointer buttons on a TrackPoint keyboard are just sitting there, waiting to be Leap keys, I had the thought of implementing that.)

I used to really like dCOM , Directory Commander, by Dave Frailey / DAC Microsystems.

It mostly used single letter commands modelessly on the keyboard, if I recall, like 'd' to delete files, I think, probably with a confirmation like 'y/n' after you hit 'd'. It was written in ASM. I'm not 100% sure, I just remember how amazingly fast and frictionless it felt after getting used to it.

it was dual-pane. it was probably influenced by other commander/shells, like the Norton Commander, but when I got good with this, it was so fast. It was like using vim purely in edit (not insert) mode the friction of switching modes for managing your files. And you could use the mouse.

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.

Where I live we have a big science museum[1]. Besides a real Cray you can sit on, it had some public experiments with TUIs done in Borland's TurboVision. I loved that as a kid in the late 80s and early 90s. For me it was how the future looked back then.

Over the decades I went to the museum often and the future turned into the past. It's only recently when the museum got a new director and a huge renovation when the old machines with the blue CRT monitors disappeared. I wonder what happened to them...

[1] https://www.deutsches-museum.de/en

Acme, the combination editor, shell, and window manager. Influenced by Oberon, which another comment mentioned.

http://acme.cat-v.org/

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

I like TUI applications, they allow me to stay in the the terminal in tmux which make everything easy and fast. Here is a list of what I use and I can think of right now:

- neomutt (email client)

- ncspot (Rust Spotify client)

- glirc (Haskell IRC client)

- newsboat (RSS reader)

- calcurse (calendar)

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

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.

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

I personally love TUI software, you don't have to worry about GUI toolkits, mouse focused interaction, you can run them remotely over SSH, they're often composable, and composability is much easier, and who doesn't like the hackerman aesthetic?

Some things I don't like about modern TUIs is developers getting away from the purpose of them, portability. Often you'll find really beautiful TUIs that require installation of custom fonts for icons and other overcomplicated stuff like that. They can be nice, but generally they sacrifice the practical benefit to a significant degree.

One I discovered yesterday, not really a TUI, more of a shell but still, extremely powerful, is kalc https://github.com/bgkillas/kalc which is a complete scientific and graphing calculator in the terminal. It depends on gnuplot for graphing, which is unfortunate since it is a GUI program, but there we go with composability again! It's fine and works and does what it needs to, so not really a big deal I guess.

I also use Helix editor and sc-im daily.

To find more:

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

https://github.com/toolleeo/cli-apps

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

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.

This does not necessarily deserve to be imitated, but it is an experience that definitely stood out in my memory in how unusual it was: the dsmc backup utility. The tool boggled me enough at the time that I wrote about it on my weblog:

https://www.unix-ag.uni-kl.de/~guenther/unix-tools-for-real-...

I'm actually developing this as a ERP system. It has been featured here a few years ago, and old demo can be found here: https://www.youtube.com/watch?v=W3kpD7om_aQ

The goal is to have a fully distributed multi UI ERP system, with TUI, web, android, ios, etc. all native. It's moving forward every year :)

I'm the author/maintainer for logmerger, a side-by-side log file viewer built using the Python `textual` TUI framework. Side-by-side view merges log files into a single vertical timeline (an inline view can also be selected). `textual` implements horizontal/vertical scroll control and mouse actions, so viewing 3 or 4 log files side-by side is not difficult. Auto-detects various common timestamp formats, plus PCAP file support (to merge network packet captures with your client and/or server logs).

PyPI: https://pypi.org/project/logmerger/ Github: https://github.com/ptmcg/logmerger (screenshots in README)

I'm partial to the UCSD p-system interface, mostly because it's the first TUI I was ever exposed to. You can see screenshots here:

http://pascal.hansotten.com/ucsd-p-system/cp-m-and-ucsd-p-sy...

As for more modern stuff, I like using ncdu and htop.

I've built a TUI for terraform:

https://github.com/leg100/pug

It's built using Go and the bubbletea library. It's been a breath of fresh air compared to building a web app, simpler and faster to develop and test. And of course far more responsive than a web app could ever be.

I recommend x-cmd, which uses shell and awk to implement many tui interactive tools (gh, gt, theme, cd, ls, hn, etc.), and is also a package manager that supports the download of many tui software. Very user-friendly.

https://www.x-cmd.com/

I have used this https://github.com/vadimdemedes/ink/ for TUI design, it's "React" for TUI.

It's pretty good but I had to add a bit of sub-process parallelization since I have a long running process in the background.

Shameless plug: I built my own MUA with ~300 lines of shell glue and the fantastic mblaze for mail handling and fzf for navigating, displaying and doing custom actions. Thanks to fzf I can declare shortcuts that will do whatever I need to do with the given email (reply, filter with the same subject, open attachments, whatever it is I need)

Don't look too closely at the specific code, it is all custom to my own use and that's my point: thanks to fzf it is trivial to build powerful TUIs with minimal code, so minimal in fact that you, the user, can do it yourself. Configuration is unneeded because your own actions are the configuration.

In an old warehouse/fabrication job I had back in the late 2000s, I used some TUI based inventory/work order management system on a Windows NT computer isolated from the internet. The singular software it ran was called QIS-II… I think, I’m not clear any more.

It looked like your typical 16 color monospaced DOS TUI and was definitely intuitive to start with, but for the set of things I had to do, it was fast and fluid to use once one developed fluency with it’s layout and controls. I actually kind of miss it.

How about this music chord formation program with a virtual six-string guitar fret that I wrote back in 1999? https://github.com/capr/chordclopedia

One could mention the PC-FAND database system (sort of like MS Access) that is fully TUI and runs in MSDOS, the Czech UCTO accounting software uses it to this day (supports Windows 10 via FreeDOS).

PC-FAND is now on github... I think you should be good with Google Translate https://github.com/alisoss/pcfand

Slartboz is my real-time action adventure Rogue-like set in Normerika 2100 CE after democracy collapse and climate catastrophe. Written in Golang. Uses ncurses for visuals and VLC for sound and music. I try to push the bounds on whats possible and what you'd expect from a Terminal-based TUI game.

https://github.com/mkramlich/slartboz-pub

Back in the days when most PC users lacked a mouse, people would make things to put over the F1-F12 keys (since those shortcuts tended to not be mnemonic) with what each key did with various modifiers. e.g. https://www.ebay.com/itm/276317392496

It was a neat way of surfacing lots of commands without taking up any screen-space.

When I started my first job in 1995, the old hands were still using DEC ALL-IN-1 [0] from terminals on their desks but it was in the process of being phased out (for Microsoft Mail or something on Windows for Workgroups), so I never got to use it myself.

[0]: https://en.wikipedia.org/wiki/ALL-IN-1

Not forgotten by any means but goaccess is nice and simple to use

https://goaccess.io/

ncmpcpp is a TUI based music player for your audio file collection. It's actually a frontend to the mpd (music player daemon)

https://rybczak.net/ncmpcpp https://wiki.archlinux.org/title/ncmpcpp

I am not that mutch of TUI interface user myself but I can recommend taking a look into ranger. Its a file manager with vi-like key binds that I enjoy because its for me a way faster way to explore in the terminal. It cuts the whole ls - cat - less - vim - cd workflow to a couple of keypresses and nice customizable previews in the terminal while browsing.

There is Text-based Desktop Environment https://github.com/directvt/vtm

It gives a graphical interactive environment in terminal. Has some premade interfaces like spreadsheet, notepad and few others.

It used to have a site where you could just connect via ssh and see interact with it in all its glory.

IBM ISPF suite is gorgeous.

Euporie is the most complex TUI application I have built:

https://github.com/joouha/euporie

It consists of a TUI editor (and interactive REPL) for Jupyter notebooks, and supports displaying rich output in the terminal (images, LaTeX, HTML, interactive widgets, etc.).

I think AutoCAD qualifies as a text user interface - or at least it used to. You could really whip through some work if you knew the commands well instead of having to click, point and drag right click etc. I really wish more programs had that kind of interface. I think it would work well in modern graphics programs, DAWs, and video editing.

They don't usually count as TUIs, but there are some great CLI programs, even for interactive use. Perhaps the classic example beyond the usual is the MH mail handling system, which is still maintained as nmh [0]. Instead of a single monolith like thunderbird, mutt, or mailx, it consists of multiple commands that list mails, show them, let you compose new ones, etc, and keeps all intermediate state on the filesystem which makes it very easy to back up or do anything with using the usual file management commands. Mblaze [1] is a more modern implementation of a similar concept that uses amildirs, and it's how I interact with my emails these days.

There are also programs that function more similar to "monoliths" but still act like a shell or repl as far as accepting commands and executing them. Clifm [2] is one example, it's the only file manager I seriously tried using before giving up and returning to ls and friends. If you have vi or any of its discendents odds are you can run them in "ex" mode where you use them similar to the good old ed. Speaking of ed, edbrowse [3] is a browser with an ed-like interface that can also read mail (and no I'm not making it up. An interesting thing about it (well, at least one of them) is that one can define "functions" which are pretty similar to functions in sh. For example, this is a function to search something on searx:

``` function+gg { db0 b https://searx.be/ /<>/ i=~0 db1 /start search/i i2* /h1/ } ```

While this can certainly be done in a conventional browser using userscripts or such, I'd argue that this sort of function is easier to write because most of it is something you were doing already, and now you're just putting it in a shorthand, where in a userscript you'd probably have to use a lot of getElementById()s to do it, which besides being more verbose is very different to how you think about the problem.

[0]: https://www.nongnu.org/nmh/ [1]: https://github.com/leahneukirchen/mblaze [2]: https://leo-arch.github.io/clifm/ [3]: https://edbrowse.org/

Don't know how interesting it is, but I used the David Readme Compiler a lot in the past to create simple executable readme to accompany software and as a small knowledge base.

It created a simple dialog-based menu that allow to explore topic and search through them (and edit and print). I think it used Turbo-Vision, but I may be misremembering.

Just came to see if anyone here got interested in MS-DOS TSR programs as a result of their exposure to Sidekick :).

I worked somewhere about 18 years ago that was a TUI for the call center staff, and it kinda made sense. A few keystrokes and the info you needed was there, no "fluff" or clicking around the place, just type in what the customer said, tab, and done.

I wouldn't be surprised if it was still in use now.

How about this software I wrote back in college to manage beauty parlors?

https://github.com/victorqribeiro/beautyhair

The text is in PT but I guess you can understand it. I loved writing those CLI applications in Java back then.

Oxide computer has a really interesting one. This probably hits all of the big points: https://oxide.computer/podcasts/oxide-and-friends/1272104

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

Sogamed old ui is a good inspiration https://web.archive.org/web/20030620073042/http://sogamed.co...

DESQview for DOS was an amazing way to add some multi-tasking capabilities into an otherwise limited environment. https://en.wikipedia.org/wiki/DESQview

I loved discovering keyboard shortcuts for video games like Rogue: https://en.wikipedia.org/wiki/Rogue_(video_game)

TinyMUSH (which is somewhere between TinyMUD and TinyMUSE if my historic memory is correct): https://github.com/TinyMUSH/TinyMUSH

Going even deeper I've been trying to find good examples of the aesthetic of the "light bar menus" from the Renegade/Final era of BBSes. I've found it to be unexpectedly difficult!

You might want to play around with the lynx browser as well...

https://en.wikipedia.org/wiki/Lynx_(web_browser)

I use vim, mutt, tig, newsboat, jless (if that counts) pretty much daily. Also a TUI Confluence client which I wrote and which I am the only user of as far as I know. Navigating Confluence becomes a breeze.

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

UMENU https://www.troubleshooters.com/umenu/index.htm

I'd also be interested. I'm currently developing a kind-of-a-tui that is essentially "Vim but for UI designers" and really could use some inspiration.

Git gui in terminal

https://github.com/extrawurst/gitui

Are there any tools to convert a TUI into a GUI?

If you do any work with K8s, k9s is a handy tool.

https://k9scli.io/

The tin news reader and weechat are nice.

ctop is pretty nice, if a bit basic: https://ctop.sh/

There's also k9s: https://k9scli.io/

And of course htop and nano!

Honorable mention for "tig", a git frontend. Super fast and readable.

* Bloomberg terminal

* Vim ;)

imtui looks interesting. A text based backend for Dear ImGui. Never tested it myself though.

https://github.com/ggerganov/imtui

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)

tvterm: A Turbo Vision based terminal emulator: https://github.com/magiblot/tvterm

x-cmd come with a TUI library and many mod (mostly cli) in x-cmd are powered by this library. You can see the demo in the website.

ncdu

dive https://github.com/wagoodman/dive

SMIT in IBM

midnight commander

ChatGPT