Hacker News new | past | comments | ask | show | jobs | submit login
Ask HN: Interesting TUIs (text user interfaces), maybe forgotten ones?
322 points by perihelions 65 days ago | hide | past | favorite | 294 comments
I use relatively few TUI's, and don't know much about them—about what good, convenient UX flows in TUI's can look like. I want to write some in Emacs. Do you have particularly nice examples of TUI's that deserve to be known and imitated? I know there's a lot of abandoned programs from the pre-GUI era that refined TUI's to a high level.

(I'm only familiar with a handful of modern ones in Emacs—Magit, the SLIME inspector, dired, as well as the terminal TUI from the Linux tool perf).




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.


I would add another site to the list: https://inconsolation.wordpress.com/

You can find reviews of hundreds of CLI And TUI programs, some great, others barely known and clearly forgotten. The last review is from 2015. Some reviews are very short, others are more involved.

The site is a blog with a tagline "Adventures with lightweight and minimalist software for Linux". The author K.Mandla is opinionated and has certain preferences for such programs like [1].

I have not looked at the site in years, but if you are willing to explore, this could be a fun option to find a variety of these tools.

[1]: https://inconsolation.wordpress.com/2015/01/19/wpe-and-we-so...


In the same TUI spirit:

https://github.com/cosmos72/twin

A text mode environment and window manager, with terminal emulation, VNC-style sessions and viewers, and networked clients.

Disclaimer: I'm the author


The extra convenient part is that the default installation instructions are for everyone's favourite, snap.


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.


Back in the old days, the primary users of many mainframe UIs were the data entry team (almost universally female).

Sitting in large offices with rows of desks and a huge clock on the front wall, they weren't interacting with customers, they were transcribing from sales sheets, order forms, application forms, etc. prepared by someone else.

There was no great need for user friendliness, because the only users were in house, and they performed the same data entry hundreds of times every day.

The only need was for speed.

The arrival of the PC started changing everything, as people got familiar with the mouse and GUI.

Somehow mouse-based GUIs became the default for everything, which made a lot of sense as at the same time data entry was pushed out to the users themselves and intermediary data entry staff disappeared.

But if you want a fast, simple way to quickly perform common transactions even on very small screens, old school TUIs have a lot to learn from.


Mice are the problem, not the rest of the GUI.

Keyboards are just faster once you learn them.


It's part of it but not all of it. Today's modern UIs won't buffer keystrokes as you move between UI contexts. You often have to wait for a bit of UI to load/appear before you can continue, or else your premature keystroke will be eaten or apply to the wrong window. This kills your throughput because you have to look at the screen and wait to recognize something happening. Even if you have all the keystrokes memorized, the UI still makes you wait.

In a traditional TUI you can type at full speed and the system will process the keystrokes as it is able, with no keystrokes being lost. If a keystroke calls up a new screen, then the very next keystroke will apply to that screen. Competent users could be several screens ahead of the computer, because the system doesn't make them wait for the UI to appear before accepting the keystrokes that will apply to that UI.


>Competent users could be several screens ahead of the computer

Reminds me of https://en.wikipedia.org/wiki/Therac-25


This works if you have one app with a completely dedicated computer. But that's a limitation on the popular systems. If you have an automatic focus switch to new windows, like Windows/Mac pretty much enforces, you can't buffer input. An incoming call to your VoIP system would be dropped/redirected, because you were typing the right thing at the time.


No, Windows goes out of its way not to allow a popup window from a background application to take focus. Instead, it blinks the taskbar icon. An incoming call should not start eating the keystrokes you were sending to the active application. Focus stealing isn't totally solved as an issue, but it's certainly regarded as a problem to be solved and not the desired behavior.


That's nowhere close to my experience. Things that steal focus constantly: 1password losing SSO token, UAC for an application's backup, 3CX call coming in, every random thing in vscode, ...

It's not something windows does or can disallow. You just focus the window in the code and that's it.


https://danluu.com/keyboard-v-mouse/ - "Unlike claims by either keyboard or mouse advocates, when I do experiments myself, the results are mixed. Some tasks are substantially faster if I use the keyboard and some are substantially faster if I use the mouse. Moreover, most of the results are easily predictable (when the results are similar, the prediction is that it would be hard to predict)."


Mice + keyboards are good for versatility. When you need more than data entry or non-tabular (images, video) data entry or processing, having a mouse is key.


A mouse is not itself a problem, although most functions should be operable by keyboard. When selecting objects and points on the screen, the mouse is helpful. It is best to have both, although I would think that a keyboard alone is generally better than a mouse alone.


You're 100% correct. Keyboard is not better than mouse, both are good tools which complement each other.


True. I should have qualified that as applying to particular tasks.


While I prefer to use a keyboard, it is not true that keyboard are universally faster. Even text navigation can be significantly faster with a mouse if done right, especially if you start to go into button chords.

What works best is heavily task dependent, and also needs to account for cognitive load and training requirements. Stations with few primary tasks taking limited input (e.g., product lookup forms and customer purchase forms) lend themselves heavily to a keyboard driven UI, but many others either do not. In that area, it ends up just being a strong personal preference guiding what seems best.


> and boy are they fast with them

My girlfriend works in a bank and she does virtually everything in a TUI.

She hates it, but I've seen her using it and she's blazing fast and I can't, as a frontend developer, imagine how a full blown application would be better.


I've been transitioning many mobile apps I rely on to TUI-based alternatives or creating custom apps for personal purposes. Honestly, our obsession with eye candy has led us astray. Consider this: navigating old.reddit.com is significantly faster than browsing www.reddit.com. While there's a time and place for visually appealing designs, when it comes to conveying information efficiently, every non-informative element on the screen can hinder performance. I think we all intuitively know this - UI design is trending towards minimalism at the moment.


Why does she hate it if she is so efficient with it?


It's ugly to look at and took her a long time to learn.

Copy pasting is also troublesome, and that one is a common scenario to copy/paste from emails.


Cyril-shift-v doesn’t work? Or is it some weird terminal app like the old Microsoft one?


UI inefficiencies give time for the mind to relax?

On my side I'd much rather have the efficient UI but I can imagine people getting tired if their mind is working 100% all the time.


What I've seen on Costco scanners looks identical to the menus in Koerber/Highjump's "Advantage Platform". If they're anything like us they are just running a telnet client on a ruggedized Android decvice. Once you use the system for a bit you build muscle memory and don't even need the menu text most of the time.


The AS400/OS400-like interfaces always seem like they should be more popular super-user interfaces. They seem best at navigating tree-like data but most OS level interfaces feel tree-like these days. I think the affordances work a little better than vim-keys sometimes. A vim-mode option or command palette would be straightforward.

But it would require people to use full size extended keyboard (function F rows, numpads, etc). Which shrinks the user base quite a bit.


The navigation cues are a huge point. So many cli tools today run on cmdline flags, and it’s so frustrating to have to look them up each time. There must be a better idiom then —help or full curses applications.


I've seen those at Costco stores also.

Whereas in indie coffee shops they use a Square tablet and in Apple stores the store people just use iPhones with special cases. Best Buy or Walgreens uses POS tablets with a relatively ugly GUI.

Legacy apps never die. Charles Schwab might use mainframes while Robinhood won't but Schwab won't move off because it's too hard for an established firm. Same with Costco TUIs.


> Legacy apps never die

I think it's a mistake to frame this as legacy vs. new. There are real benefits to the approach taken by these TUI applications and it would behoove modern app designers to learn from them.

It's perhaps the case that those coffee shops will someday adopt a TUI once they reach a level of sophistication. As an example: I believe Starbucks uses a TUI for order processing.


I remember around 2010 seeing ads about how KLM/AF did a huge upgrade of their passenger handling system - and how they explicitly went with TN3270 talking to z/TPF application as the new main interface for agents to use.

At least at the time, it sounded like they made a completely new application... and explicitly went with this stack.

Now, before you point to Amadeus still being command oriented just like that, modern Amadeus is accessed over GUI client - even if you're going to use all console commands.

Meanwhile when I had to reschedule a flight due to a volcano exploding and grounding all planes, I got to see what the KLM/AF local agent did. Fullscreen red-on-black TN3270 session. Took only a moment to handle my case and throw in a few extras.


But there are no benefits, you can replicate everything in terms of user interaction identically in a more readable/better looking GUI app, so efficiency is maintained


Sure you can, but it's rare to see a GUI app built keyboard first and specifically optimized for the productivity of power users. The list of apps that do this successfully is a tiny fraction of the total.

- Excel

- 3D modeling tools

- Adobe Creative apps

- Programming IDEs

- ?

Also, if you are focused on that metric: the productivity of the power user, then in many cases adopting a more modern GUI framework will not necessarily make it easier to achieve that goal (and in some cases may make it harder).


TUI apps aren't optimized for the productivity of power users, and by the same token, replacing a GUI app with a legacy TUI framework will not necessarily make it easier while almost definitely will make it harder since some advanced productive UI patterns simply don't get implemented in TUIs - they might not've been invented/known at the time this legacy framework was created

Thus there is no innate framework benefit, only downside, so it doesn't make sense to handicap yourself tying to this legacy


why would a gui app be more readable for reading text? The only inate difference I can think of is the ability to vary fonts and rendering based on what you are rendering more.

And that can be a nice improvement to e. g show your code at a normal size but pop a tooltip up with smaller text, or have the linter/errors tab be a smaller font.

But that's a difference and not necessarily an improvement, because having a consistent font and fixed width text can make things more predictable and faster to interact with as you don't have to scan around as much.


Don't get it, is linter in smaller font an improvement or not (as it's somehow slower)?

> fixed width text can make things more predictable and faster to interact with as you don't have to scan around as much.

In what way does "i" not looking as wide as "w" force any scan speed deterioration?


Someday the COBOL programmers are going to cross the sea to the undying lands and there's going to be a reckoning for companies that have kept legacy apps around this long.


Before Apple switched to the iPhone for their POS system they used iMacs with a very ugly app. I think it was called iPOS. I know as a customer I wasn’t supposed to see it, but I was surprised Apple used something like that, considering Jobs always talking about how even the inside of something that no one ever sees should still be beautiful.


My favourite is how what most people think of "apple store" in Poland the Macs that run sales will actually run windows with BootCamp and run some run of the mill POS/ERP software.


I wonder what they'll do when they will have to switch to ARM-based macs without BootCamp support. Also, do you mean Apple resellers that market themselves as actual Apple Stores? I don't think there is an actual Apple store in Poland yet


There's a "blessed" reseller that runs "closest thing to Apple Store", and that's running under the brand "iStore"


Genuine Parts (large US based auto parts retail) is similar. The folks working there are working on turbo muscle memory and navigate the system impressively quickly.


Way back in the mid 90s I helped convert one of the largest auto salvage yards from dumb terminals (Wyse) to NT machines using terminal emulation. The sales folks went from having been limited to physical desk space or multiple terminals to multiplexing serial over Ethernet.

These folks were fast in the TUI but extending them to 2-4x the workspace was an insane productivity booster. This yard ended up being bought out in part to how we managed to extend email and virtual terminal capabilities and was the basis for the footprint of the LKQ brand at the time. I'm not sure how any web app could compete. TUIs are amazing workflow enablers.


I'm 35 and DOS applications in Windows machines were a common sight in India. They gave way to GUIs that can cram so much data in a 1024*768 black and white screen that I hate most webapps running on my 5k perfect color accuracy screen and can be quickly navigated by a loud mechanical keyboard.


From the best of my recollection, Lowe's runs Linux internally, Costco Is IBM.

Did some work for Lowe's Home improvement and their PXE booting thin clients in the early 2000's.


I’ve always wondered about this. I get that a keyboard driven text interface can be extremely fast for an experienced user. However, when I think about a lot of the places I see them, they are retail jobs with what I can only assume is high turnover. The text interface has to have a much higher learning curve, which I would think would only pay off for jobs people work in for a long time.


Some of these jobs you simply need to be fast or find something else to do. When you're new, your supervisor is near by, and you learn how to do the easy things, and ask the super for help with exceptions.

If you spend a couple 8 hour days doing returns or checking people into flights or whatever, you'll get good at the regular stuff and the usual exceptions. Or you won't and maybe there's something else you can do.

Most of the time, the real tricks are knowing how to move to the other fields when it's not obviously tab, and what the button is to get into the exception menu. And then learning the layouts to scan the page for what you need.

On a mouse driven system you can usually click into the fields you need, but if you need to, it's usually gonna be slow.


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

What magic makes TUI faster than GUI?

TUI just use glyphs to render the interface. AFAIK that's not faster that a proper graphics engine.

Keyboard shortcuts are not exclusive to TUI.

Maybe if we would stop hyping UI gimmicks and put more focus on fundamentals, there wouldn't be so many bad GUI apps.


It's not keyboard shortcuts, it's pure keyboard input; an important distinction to make, as with modern GUI interfaces, keyboard input is often an afterthought.


Just like TUIs can accept mouse input, GUIs can be operated without one.

The only difference is that TUIs are worse at displaying... text (and graphics)


I fully agree. I made a TUI client/server framework loosely modeled around the concepts of CSS/HTML. One of my core design decisions was keyboard only input.


I agree. I wish there was a common way to toggle keyboard navigation hints in GUIs. Like F1 is often help, F2 rename etc.


Yep. Many long-time Lowes employees will remember specific GENESIS screens to drop into by their numeric shortcuts and whip through the system.

While they've modernized a front-end to GENESIS (see their current POS deployment), there's still an option to dump the system back into a TUI for advanced features (the Alt+F12 option).

https://i.redd.it/to1k7tbsq9b51.jpg


If one were to start a project from scratch today, with the goal of having such a hyper-efficient TUI, similar to the Lowes/Costco ones, to be accessible via SSH/Telnet/locally... are there frameworks out there to use? Would my best bet still be ncurses? Are there simpler alternatives?


TurboVision: https://github.com/magiblot/tvision

Charva - http://www.pitman.co.za/projects/charva/index.html

AbsTK - https://gobolinux.org/abstk/


The `rich` module for Python is remarkably complete and lets you code at a very high level - even has CSS. Rich's sibling, Textual[1] is designed for building TUIs.

[1] https://github.com/Textualize/textual


charm.sh is probably what you're looking for


Thanks for posting this. Learning that Charm exists just made me so happy. I can't wait to build something.


I’ve thought about this a lot. I’d use the default system GUI but build in an optional command line.


There is bubbletea for go


I once worked in a phone survey company and they definitely used something similar. It was probably linked to a mainframe.


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.


Fun fact: EDIT.COM and HELP.COM are secretly QBASIC.EXE: https://en.wikipedia.org/wiki/QBasic#Contents


Doesn't get more integrated as far as integrated development environments go when your editor is your language interpreter.


qbasic.exe :D hah. never knew. but that takes me right back haha thx


I can't think about QBasic without thinking about that game with primates throwing bananas across a city at each other. Like a simpler version of Scorched Earth.

https://en.wikipedia.org/wiki/Gorillas_(video_game)

also Money, and REMLINE


No love for NIBBLES.BAS? I played that way more than Gorillas. And Scorched Earth -- that's a name I haven't heard for a long time.


Modding that game was my first experience with programming (and introducing bugs, but I repeat myself)


I'm also a fan of the TUI from Qbasic, it also appeared in Microsoft Works for DOS, Microsoft Word for DOS and probably other places.

The UI was refered to as COW character oriented windows. It would be good if it could be open sourced, for historical reference.

There were other interesting TUIs, the one in Defrag in DOS, and the Antivirus would change characters on the fly to generate a mouse cursor.

The TUI in DOSSHELL.exe would use customise some characters to draw icons.

Maybe Scott Hanselman could be persuaded to work on open sourcing all the COW apps.

(Honarable mention for EDIT in DOS7, which appears to be a rewrite, supporting long filenames).

In the modern era, there is YEdit from the author of YCmd, which implements a similar looking UI, in Windows http://www.malsmith.net/edit/

Some other TUIs of note included the ones in Wordperfect, Norton Utilities, and of course TurboVision (though the last has implementations in modern environments).


Happily Yedit is supposed to make its debut in Windows in the near future. At least according to a thread at github.

Someone linked: https://news.ycombinator.com/item?id=40293624


Not only that, I found it much easier to create TUIs on DOS than on a UN*X system. I still have a hard time with curses. Zortech c on DOS had a small set of screen functions, disp_*().

These are enhanced printf(), scanf(), getc() type functions by adding cursor positioning on an 80x25 screen. Pretty basic but you could create nice applications with these basic functions in Zortech c.

Granted, on DOS the screen size did not change as it does in UN*X, making TUIs easier.

On the systems (minis) I worked on decades ago, TUIs were far easier then anything I have seen since.


> "easier to create TUIs on DOS than on a UN*X system"

That's because DOS (well, the IBM PC really) had a memory-mapped text mode display buffer instead of terminal emulation.

So much easier to fill a screen rapidly and do partial updates, scrolling, moving windows etc. when you can just do pointer arithmetic and memcpy.


> I still have a hard time with curses.

FWIW, _everybody_ has a hard time with curses. That's why it's (aptly) named "curses!"


haha never put 1 and 2 together. i guess these days its either something CSS or curses. cursed style sheets? :') maybe someone can do everyone a solid and make a GUI to design TUIs ? hahah


CSS used to support the "tty" media type for terminal output (like for the lynx browser).

https://developer.mozilla.org/en-US/docs/Web/CSS/@media


MS-DOS also supported the 80x43 or 80x50 screen modes for extra information density. On later hardware you would have SVGA-based or VESA-based text modes with even more density, though by that time DOS itself had mostly fallen out of use.


I seem to remember one 132 wide, but since the resolution didn’t change (much?) it was near unreadable.


I still run my (Unix) terminals sized to 80x43 by default.


If you loaded ANSI.SYS in your config.sys, then the procedure is exactly the same.

I think this will demonstrate color with ANSI.SYS and/or VT-color:

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


> 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 might like "joe", which was inspired by WordStar: <https://joe-editor.sourceforge.io/>


Also Midnight Commander's integrated editor: `mc -e`.


it's mcedit


Yes, that works too.


I'm still using joe on Linux (and macOS) 30 years later!


To me, Borland Turbo Pascal / Turbo C are the apex of IDEs.


really? the apex? that's an interesting perspective, to me.

there have been lots and lots of advancements in IDEs since then, are none of those advancements useful to you? not everyone needs or wants a lot of those things, i'm sure, but they have utility which the Turbo* console IDEs lacked.


Not really, considering the tradeoffs in intrusiveness/speed they carry.


Regarding the shortcut navigation, I use an extension called which-key[0] on Emacs for that. I believe there is a similar package with the same name for vim / nvim too.

[0] https://github.com/justbur/emacs-which-key


https://os.ghalkes.nl/tilde/index.html

Tilde is a great EDIT.COM/Borland style IDE clone for Linux. It even has mouse support via remote Terminal.


> In stark contrast to most GNU/*nix tools

That's ridiculous! The only invisible things in Emacs deserve to be so. For everything else, there is a menu bar which is also visible in terminal `emacs -nw` mode. Just add `(xterm-mouse-mode t)` to ~/.emacs to make sure the mouse works properly. Very pointy, very clicky, and nice pretty menus that tell you the shortcut of each function.


To enable the helpful mouse interface, run with this mode and add this to your hidden config file. What's a mode? How do I edit the config file until I fix my editor? This is such a unix answer.


To be fair if you're trying to start Emacs in a terminal instead of letting Emacs control its output on its own you've already gone off the beaten path.

The thing you want (the helpful mouse interface) is the Emacs default. The funny command-line flag is what makes it weird. Just don't use that flag.


But then it's not a TUI anymore, which is the whole point of this exercise.


"TUI" is "text(ual) user interface", not "terminal user interface". If the UI is (primarily?) made of text (which it is in Emacs' GUI mode) then it doesn't need to be in the terminal.


I really wish edit.com still existed for Windows and was built in. Every now and then I need to do some stuff on a Windows machine and find myself wishing for a simple terminal editor.


A Microsoft employee recently (~6 months) opened a Github issue to discuss a command line editor for Windows: https://github.com/microsoft/terminal/discussions/16440

> "Thank you so much to everyone for engaging with this feature exploration! Your passion has generated a ton of excitement in our own team, and I’m happy to share our proposed direction, which is that we will work with Malcolm Smith (malxau), the maintainer of Yedit, to ship Edit in Windows! We plan to do this by forking the Yedit code to a new OSS repo on GitHub, under Microsoft (like terminal or powertoys)."

YEdit being an MIT licensed open-source recreation of the MS-DOS 5 editor, by a Microsoft employee: http://www.malsmith.net/edit/


That's great news! Thanks!


Yeah, the Unix tools' unfriendliness comes from their history of being developed for a literal teletype, i.e. the computer's output would come out on a roll of paper, not a screen. In that environment you want to be very conservative with your output and can't really show a help screen. At least Vim tells you a couple of basic commands to get started with on its splash screen - ":q" to exit, ":help" for help. It still suffers from really poor discoverability and the fact that if you don't get you have to type a colon first, but interpret it as part of the help phrase and just press "q" on its own, you enter macro recording mode. Or bring up the history with "q:". Thinking about it, it should be pretty easy to add a menu bar showing the GUI entries, but experienced users obviously have zero incentive to do 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


That’s a great name btw. :)


I've been looking for an openapi TUI all my life <3


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.


Some alternatives:

* `vifm` file manager, more powerful and performant than ranger, for those who lean towards vim keybindings: https://vifm.info/gallery.shtml

* `btop` process monitor, for those who like eye candy: https://github.com/aristocratos/btop?tab=readme-ov-file#main...


`ncdu` is the single best tool I've ever found for tracking down high-disk-usage directories deep in the filesystem. Run it with the `-x` flag to prevent it from crossing mounts.


Wow, thanks for the pointer, finding it super useful right now to see what's taking so much space in my backups


Better than the kdirstat/windirstat family?


it works in the terminal on a headless server


That’s a plus!


A very good alternative to ranger is lf https://github.com/gokcehan/lf

It's a lot faster in all aspects, has mostly the same features and is pretty much a standalone binary.

edit: an even more minimal alteranative is nnn https://github.com/jarun/nnn


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.


IBM Topview had a certain charm too

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


TurboVision was distributed as source with some of the Borland tools, and later open-sourced, I think. So it's not a rewrite, just a port to non-DOS terminals.


Yes, that's mentioned in the README.


FreePascal comes with an TUI IDE in the Borland tradition (not to mention Lazarus): https://en.wikipedia.org/wiki/Free_Pascal#/media/File:FPIDE_...


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

I just now came across the following related to Turbo Vision:

> TuiCss is a library focused to create web applications using an interface based on ASCII table, like the old MS-DOS applications. ...... The base of this project is Turbo Vision Framework, but some other frameworks were also checked to introduce some features to TuiCss, like curses, ncurses, Newt, etc.

https://www.npmjs.com/package/tuicss


Qmodem was written in Turbo Pascal. It felt futuristic.


this has very strong nostalgia vibes. that's where i learned pascal and C programming.

what i would like to see is a gui layer that wraps turbo vision such that i can have apps that work in the terminal and in a GUI. ideally so that the app binaries directly work in both without any recompile or change of code.


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.


I used it for a while but IMO nowadays csvlens beats it.

https://github.com/YS-L/csvlens


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.


Sounds like something comparable to LazyGit. https://github.com/jesseduffield/lazygit


yes I do too. I do wish its ui navigation was a bit more 'humane'. more often than not I end up switching to next commit instead of next page.


Absolutely one of the best TUIs for sure.


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


I am using lazygit, which I find really easy to use once you get the hang of it. Debase may not be as powerful as lazygit, but looks much more easier to get started. Great work.


that looks amazing actually. of course it deserves to be known.

i like the conflict resolver, but one thing i didn't see is the ability to outright edit a commit. that is something i'd like to use occasionally


I love this. Perhaps consider updating the GitHub repo with links, gifs, tags, and a README. It might get some more exposure.


That looks great! Also, the site is excellent. I love how the animated examples change as you scroll down the site.


+1 Rare to see a modern looking website that actually works well. Increases trust in the actual tool and makes me want to try it out.


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 used the TUI WordPerfect for SCO Unix/Xenix on various serial terminals and telnet/ssh connections for years. I still miss it for heads-down cranking out text.


Ah, yes. "WordPerfect 1.0 for UNIX" was the primary use of my upper school's 45 orange-plasma Wyse dumb-terminals! Not too shabby.

Sometimes a terminal would desync while you were typing up a storm, spewing control codes onto the screen. Many re-re-learned the need for frequent saves.

The WordPerfect spellchecker's short list of suggestions was typical of word processors, even decades later. A few of us knew to press the magic key to drop into a shell and use the mini's speller, which appeared to dump the whole wordlist, instantly sorted by similarity, one screen at a time. We could usually hop back into WordPerfect before anyone in charge asked why we weren't either at the system login screen or using WP. I never found another speller that worked like that.

They never did get the upgrade cards for those terminals, to turn them into smart-terminals. PC 386s with Win3.11 were the next big investment.


Available on Linux still...

https://github.com/taviso/wpunix


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 sure how related it is, but I found this series on the AS/400 fascinating: https://youtube.com/playlist?list=PL9tkJGALYJ6CzZSPwM-09E5tk...


The AS/400 (aka IBM i) appears to be of a different lineage, derived from the late-70s IBM System/38 minicomputers.

Nevertheless, it sports many IBM-isms in its design, including integrating database functionality directly into the operating system, making database tables and files almost coterminous with record-level file access being the primary mode of access; and the use of block-oriented, rather than character-oriented terminals (the IBM 5250).

Interestingly unique to IBM i among IBM operating systems is the pervasive use of object orientation throughout its system APIs; there are no pointers, everything is an object over which some operations are permitted and others forbidden. While the mainframe series retained darn-near-perfect backwards compatibility through system-level emulation of old architectures on top of new architectures, IBM i's solution to this problem is different: TIMI (Technology Independent Machine Interface), a kernel-level abstract machine to which all IBM i applications are targeted. No programmer access to the underlying machine code is provided. Rather, the first time the kernel loads a TIMI executable, it AOT-compiles it to whatever the underlying CPU architecture it is. This enables seamless CPU architecture changes with perfect backwards compatibility for application code; this already happened in the 90s as the AS/400 line migrated from a System/38-based architecture to PowerPC.


Compared to ISPF, some people also loved XEDIT or Roscoe for their ability to integrate adhoc scripting with TUI.


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


QuickBASIC's modernity was just popping out of those 80x25 character cells. It was as promising of the future as Windows 95.


Visual Basic for DOS is AWESOME. I briefly used it last year to make a Wordle clone for Dos.

The 3D buttons in a TUI, event-based programming in DOS, the rich help system… just awesome.


An interface that UI designers of today should pay closer attention to. Same for Delphi in GUI land.


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.


I used to use aerc, though mutt is more powerful. Might switch to neomutt. Sc-im is great, however may be really confusing sometimes.


Do you have examples for things that don’t work with aerc but with mutt? Since I found the template functions in aerc, for an easy example:

fs = :filter -H<space>subject:"{{.SubjectBase}}" <Enter>

To filter mails with the same subject. And additional the possibility to pipe everything through the shell, I don’t know what mutt can do that aerc can’t.


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


> This still exists in blackbox framework oberon/f

The Blackbox framework has a Windows GUI and is quite different from the Oberon System v1 and v2. Starting with v3 and the active object system (AOS), the Oberon System had also a GUI, even with a window manager. But Wirth went back to the original TUI in his FPGA based Project Oberon System (see https://www.projectoberon.net/); here is a version or this system which runs on all platforms: https://github.com/rochus-keller/OberonSystem.


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


Also xtree, ztree etc.


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.


It's unix command names for fast food!

chown MCNUGS, please!


I can't remember all of them, but the abbreviations sort of became a running joke amongst me and my coworkers; specifically we would use them for nicknames of managers we didn't like.

None of them were vulgar or anything, but for example we had taken to calling one of the managers "McNugs" because he stole a bunch of chicken nuggets (like literally a whole box, not just one or two from the line), tried to claim that the workers did it, and we actually needed to get the security footage to exonerate us, and surprisingly he wasn't fired for it. We all started calling him McNugs, which he absolutely hated, but I think he was afraid to do anything about it because he was already on thin ice for trying to frame us.

I might have them written down somewhere, I'll have to look.


Is the inventory tracked so closely that you can detect a missing box of McNugs?


Sort of; by "box", I mean it was like a 40-50lbs crate full of McNuggets. I didn't mean like six nugget box.

They noticed because we ran out of them during a rush hour and the owner of the franchise was confused because we should have had another box.


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


I find menuconfig to be a not-very-great TUI (too much stuff per page for my taste), but the GDB tui is really nice/functional (tho also idiosyncratic).


I recall `make nconfig` being much friendlier.


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


Smit was always love/hate. It's very powerful, effective and well thought out, and if I didn't already have years of 'regular' unix experience, I would have liked it much, much better. But it screamed "this is what happens when mainframe folks are handed a unix". And the first thing I was told in my first AIX admin class was "Just accept it up front and learn to love smit. Do not try to go behind smits back. Do not think you know better than smit does.". Wasn't usually wrong.


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


For those who are familiar with using the *nix du command, ncdu is like a nice step up. Finding what is using your disk space naturally requires repeatedly descending into directories and checking what is using up most space. So having TUI for it makes a lot of sense.

Thanks for listing it.


ncdu also has the really cool feature of being able to dump its internal scan state to stdout and having a flag to load that state, which means you can pipe SSH output from ncdu on a server into a local file. Then you can inspect what's taking up space on a VPS without having to log in on it.

It's especially great if the server is out of disk space and/or the server is under too heavy a load to keep an SSH connection going; you can investigate what's clogging up space (usually logfiles gone awry) and clean up accordingly.

It's one of the default utilities I have installed on my servers for a very good reason and it's helped out countless times over the past few years for hobby servers of mine (aka the ones where "scaling it up" isn't an option because the budget is constrained by it being a hobby).


and despite having learned about it years ago i still can't remember to use it.


du -h|sort -h goes a really long way


ncdu is the next step when you've got as far as you can with `du -h | sort -n`


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.


That's not what is commonly meant by "TUI". But as you mentioned, these old UNIX tools were really meant to be used with output printed to paper, which formed part of their "user interface": With CRT terminals, they actually become less usable, since anything that scrolls off the screen gets lost (even today in a terminal window, there is usually a limit to how far you can scroll back).

And I feel like all those UNIX lovers going on and on about how efficient command line tools are don't get this at all. For a command like "replace 'foo' with 'bar' in lines 1237-1451" to make sense, you either need superhuman memory, or a printout nearby. And if you don't use it every day, you'll also need to look up the exact syntax for that command.

PCs running MS-DOS might have been less powerful than UNIX machines, but they got really good, discoverable text user interfaces that took advantage of the hardware available, and could access that hardware in the most direct way. The best that is available now on Linux are really just pale imitations, and have to go through layers of terminal libraries and ugly hacks, like connecting to the X server in order to get the state of modifier keys that the terminal doesn't send.


> you either need superhuman memory, or a printout nearby. And if you don't use it every day, you'll also need to look up the exact syntax for that command.

This is how I feel about emacs. Sure it contains the world, but you have to memorize the map to get anywhere interesting. I do like emacs and I do use it daily, but my command repertoire is under a dozen in number.


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


Does k9s work with k3s without issues?


I don't see why not, in my experience it works perfectly fine as long as you have a working kubeconfig


Try lazydocker as well


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.


Indeed! FoxPro was a joy to develop with. You could create something useful in very little time, it looked nice, and it ran very fast. Too bad it's completely gone.


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.


I'm old enough to have used green screen CICS apps in a bank. The things that really helped productivity were:

* Information dense screens (despite having only 80x25 characters)

* Responsiveness

* Reliable type-ahead when the responsiveness wasn't quite good enough


Those used to be common features of websites until 5-10 years ago too. And I'm assuming that you mean 'responsiveness' in the sense of 'application responds immediately to user input' rather than the misnomer usage common in web development.


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 was wondering if the canon cat leap stuff could be hoisted into emacs. I don't actually understand the Canon Cat, but from what I saw it didn't seem that far off from some of the way emacs is used.


Start with just a local key binding that makes the button hack into isearch implementation, and 10 minutes demonstrated proof-of-concept later, you keep going, and by the end of the weekend, you've recreated the Canon Cat in Emacs. :)


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.


lazydocker [0] is by the same author as lazygit. I'm thoroughly familiar with the Docker CLI, but sometimes it's just easier to use a GUI or TUI for some things. In particular, I use lazydocker for cleaning up volumes or images that may no longer be needed.

[0] https://github.com/jesseduffield/lazydocker


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


> Besides a real Cray you can sit on

Yes! It's very surprising how small it was. Images back in the day gave the impression of a hulking monolith.


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 believe Norton Commander was the original product (for MS DOS), Midnight Commander is its open-source cross-platform clone. FAR Manager is another notable TUI clone of NC.

Windows Commander/Total Commander are also NC clones, but implemented as GUI instead of TUI.

NC was one of the most convenient UIs for managing files, it’s a pity none of the major operating systems adopted this style for their default file managers.


Volkov Commander should get an honorable mention here, it is a tiny reimplementation of the NC interface. On the FAR Manager level of complexity DOS Navigator is also notable.


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


htop is great, but I've migrated to bottom which has a very similar interface with "btm --basic".

[1] https://github.com/ClementTsang/bottom


interesting. could you share the advantages of "btm --basic" over htop?


Not the OP, but the graphs over time are a nice touch.


btm --basic doesn't show graphs. but that is the point because when i saw the graphs i felt that while that is nice, that's not a replacement for top/htop. it's something different. btm --basic however looks very similar to htop. so similar that i didn't see the benefit.


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.


this comment has you covered: turbovision: https://news.ycombinator.com/item?id=40277039 there is a terminal UI written to use it too. probably replaces tmux even.


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


What do you mean when you say that gnuplot is a GUI program?


It's a graphical interface as opposed to running inside a terminal.


There are GUIs available for gnuplot, but it’s primarily a terminal program, and has a REPL.


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/


Also very small


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.


I like https://github.com/Textualize/rich and Textual by the same team, they solve a similar need but using Python.


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.


Sounds interesting. Where is it?


Oops sorry I forgot it: https://sr.ht/~rakoo/omail/


Thanks!


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


On that note, moc (http://moc.daper.net/) is also pretty nice


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.


The whole IBM 3270/5250 family is interesting evolutionary line in the sense that it is completely separate from the VT100 style UNIX terminals.


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.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: