[HN Gopher] Ask HN: Interesting TUIs (text user interfaces), may...
___________________________________________________________________
Ask HN: Interesting TUIs (text user interfaces), maybe forgotten
ones?
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).
Author : perihelions
Score : 170 points
Date : 2024-05-06 10:50 UTC (1 days ago)
| hggh wrote:
| Lotus 1-2-3: https://github.com/taviso/123elf
|
| cointop: https://github.com/cointop-sh/cointop
| fragmede wrote:
| Midnight Commander immediately comes to mind, but also Borland's
| C++ compiler.
| azov wrote:
| 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.
| rzzzt wrote:
| 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.
| verdverm wrote:
| 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)
| brudgers wrote:
| 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.'
| solardev wrote:
| 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.
| jmclnx wrote:
| 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.
| sgbeal wrote:
| > I still have a hard time with curses.
|
| FWIW, _everybody_ has a hard time with curses. That's why
| it's (aptly) named "curses!"
| sim7c00 wrote:
| 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
| Izkata wrote:
| 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
| pavlov wrote:
| _> "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.
| zozbot234 wrote:
| 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.
| chasil wrote:
| 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."
| sgbeal wrote:
| > 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/>
| Gormo wrote:
| Also Midnight Commander's integrated editor: `mc -e`.
| mobilio wrote:
| it's mcedit
| kevinsync wrote:
| I'm still using joe on Linux (and macOS) 30 years later!
| rzzzt wrote:
| Fun fact: EDIT.COM and HELP.COM are secretly QBASIC.EXE:
| https://en.wikipedia.org/wiki/QBasic#Contents
| sim7c00 wrote:
| qbasic.exe :D hah. never knew. but that takes me right back
| haha thx
| kevindamm wrote:
| 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
| stuaxo wrote:
| 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).
| davisr wrote:
| > 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.
| RyanHamilton wrote:
| 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.
| kqr wrote:
| 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.
| wannacboatmovie wrote:
| 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.
| joemi wrote:
| 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.
| cpach wrote:
| 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...
| kjs3 wrote:
| 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.
| pelcg wrote:
| 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.
| Y_Y wrote:
| The extra convenient part is that the default installation
| instructions are for everyone's favourite, snap.
| leonim wrote:
| 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...
| neutronicus wrote:
| If you want more Emacs examples, Org-mode and Spacemacs
| (especially in Evil-mode) have a ton of functionality
| kaesve wrote:
| 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.
| justin_oaks wrote:
| Sounds like something comparable to LazyGit.
| https://github.com/jesseduffield/lazygit
| DesiLurker wrote:
| 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.
| 20after4 wrote:
| Absolutely one of the best TUIs for sure.
| addaon wrote:
| 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.
| office_drone wrote:
| 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.
| masfuerte wrote:
| 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
| Gormo wrote:
| 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.
| sgbeal wrote:
| The "htop" app, an alternative to the conventional "top," is a
| nice example of a TUI: <https://htop.dev/>
| Arcuru wrote:
| htop is great, but I've migrated to bottom which has a very
| similar interface with "btm --basic".
|
| [1] https://github.com/ClementTsang/bottom
| em-bee wrote:
| interesting. could you share the advantages of "btm --basic"
| over htop?
| skywal_l wrote:
| 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.
| professoretc wrote:
| 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.
| sedatk wrote:
| Yes, that's mentioned in the README.
| petepete wrote:
| IBM Topview had a certain charm too
|
| https://en.wikipedia.org/wiki/IBM_TopView
| em-bee wrote:
| 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.
| O1111OOO wrote:
| > 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
| browningstreet wrote:
| Qmodem was written in Turbo Pascal. It felt futuristic.
| tetraca wrote:
| 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).
| emchammer wrote:
| QuickBASIC's modernity was just _popping_ out of those 80x25
| character cells. It was as promising of the future as Windows
| 95.
| NoboruWataya wrote:
| 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.
| colordrops wrote:
| 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...
| bashinator wrote:
| `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.
| bee_rider wrote:
| Better than the kdirstat/windirstat family?
| NunoSempere wrote:
| Wow, thanks for the pointer, finding it super useful right
| now to see what's taking so much space in my backups
| sgbeal wrote:
| Another one, which i'm admittedly personally vested in, is fnc, a
| TUI for the Fossil SCM: <https://fnc.bsdbox.org>
| megous wrote:
| 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.
| yoavm wrote:
| 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.
| justin_oaks wrote:
| 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
| emersonrsantos wrote:
| IBM ISPF suite is gorgeous.
| zokier wrote:
| The whole IBM 3270/5250 family is interesting evolutionary line
| in the sense that it is completely separate from the VT100
| style UNIX terminals.
| corytheboyd wrote:
| 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!
| nope96 wrote:
| https://www.ztree.com/ a clone of the old DOS Xtree. Quite the
| learning curve, but very powerful.
| layer8 wrote:
| 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
| justin_oaks wrote:
| 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.
| em-bee wrote:
| and despite having learned about it years ago i still can't
| remember to use it.
| sedatk wrote:
| This just reminded me of my custom TUI-based installer for my
| FidoNet reader (1997):
| https://twitter.com/esesci/status/1617997539688722433/
| DesiLurker wrote:
| 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.
| em-bee wrote:
| 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.
| davekeck wrote:
| I don't know if it "deserves to be known" but I made debase to
| make git editing easier: https://toaster.llc/debase
| em-bee wrote:
| 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
| JoyceBabu wrote:
| 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.
| christophilus wrote:
| That looks great! Also, the site is excellent. I love how the
| animated examples change as you scroll down the site.
| mr_mitm wrote:
| 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.
| justin_oaks wrote:
| Considering how many HTTP requests the web interface takes, I
| can see a dedicated Confluence client being a big win.
| mr_mitm wrote:
| Yes, it's insane. The amount of clicks it takes to get
| anywhere, too.
|
| One of the neatest things of my client is that I can cycle
| through unified diffs of the history of one page with a
| single key stroke. It's not perfect (macros are a problem)
| but good enough for me.
| duckmysick wrote:
| I'm not using Confluence anymore, but I imagine others would
| find your TUI useful. Have you considered publishing it?
| mr_mitm wrote:
| I have, and I did:
| https://github.com/AdrianVollmer/Congruence
|
| I consider it MeWare: written for me, but published for
| others to use because why not? But don't expect a polished
| product.
| justin_oaks wrote:
| 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.
| pdimitar wrote:
| I used it for a while but IMO nowadays csvlens beats it.
|
| https://github.com/YS-L/csvlens
| danielvaughn wrote:
| 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.
| iodbh wrote:
| 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
| hexmiles wrote:
| 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.
| friend_and_foe wrote:
| 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
| leephillips wrote:
| What do you mean when you say that gnuplot is a GUI program?
| friend_and_foe wrote:
| It's a graphical interface as opposed to running inside a
| terminal.
| leephillips wrote:
| There are GUIs available for gnuplot, but it's primarily a
| terminal program, and has a REPL.
| shihanwan1 wrote:
| 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.
| nikisweeting wrote:
| I like https://github.com/Textualize/rich and Textual by the
| same team, they solve a similar need but using Python.
| willm wrote:
| 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)
| joshka wrote:
| 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
| oidar wrote:
| 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.
| flembat wrote:
| 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..
| Rochus wrote:
| > _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.
| bitwize wrote:
| 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.
| morsch wrote:
| Not sure how related it is, but I found this series on the
| AS/400 fascinating:
| https://youtube.com/playlist?list=PL9tkJGALYJ6CzZSPwM-09E5tk...
| rakoo wrote:
| 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.
| leephillips wrote:
| Sounds interesting. Where is it?
| hanniabu wrote:
| Are there any tools to convert a TUI into a GUI?
| neverartful wrote:
| When FoxPro made the transition to being graphical with Visual
| FoxPro, I'm pretty sure it took xbase programs that worked on
| consoles and made them work as a graphical application. Stuff
| like '@ 10, 10 SAY "First name:" that was originally written to
| display the string "First name:" on the 11th row (first one
| starts at 0) and 11th column of the terminal would now be
| translated into proportional pixel units graphically.
| nikisweeting wrote:
| Rich / textual let you stream a terminal pane to a browser over
| a websocket, you could then embed that in a webview, use a PWA,
| or use Electron to display it in app form.
|
| Please let me know if someone actually tries this!
|
| https://github.com/Textualize/rich
| theonemind wrote:
| 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.
| tyingq wrote:
| 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
| kjs3 wrote:
| 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.
| ketralnis wrote:
| 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.
| srik wrote:
| 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.
| brenoafb wrote:
| 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.
| aidenn0 wrote:
| 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.
| hypertexthero wrote:
| I loved discovering keyboard shortcuts for video games like
| Rogue: https://en.wikipedia.org/wiki/Rogue_(video_game)
| mmcgaha wrote:
| The tin news reader and weechat are nice.
| busseio wrote:
| TinyMUSH (which is somewhere between TinyMUD and TinyMUSE if my
| historic memory is correct): https://github.com/TinyMUSH/TinyMUSH
| cmrdporcupine wrote:
| Sure, or MOO.
|
| Even better, a MOO (or any MUD) client in emacs (rmoo.el,
| mud.el etc), which is how I got my start with emacs eons ago.
| Areading314 wrote:
| * Bloomberg terminal
|
| * Vim ;)
| leg100 wrote:
| 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.
| neilv wrote:
| 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.)
| cmrdporcupine wrote:
| 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.
| neilv wrote:
| 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. :)
| cmrdporcupine wrote:
| 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.
| Someone wrote:
| 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.
| frederikvs wrote:
| 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...
| kjs3 wrote:
| 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).
| cmrdporcupine wrote:
| 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.
| uniqueuid wrote:
| 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
| smusamashah wrote:
| 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.
| andoma wrote:
| imtui looks interesting. A text based backend for Dear ImGui.
| Never tested it myself though.
|
| https://github.com/ggerganov/imtui
| tonymet wrote:
| ncdu
|
| dive https://github.com/wagoodman/dive
| every wrote:
| You might want to play around with the lynx browser as well...
|
| https://en.wikipedia.org/wiki/Lynx_(web_browser)
| pQd wrote:
| and elinks as well. it had better handling of page layout.
|
| http://elinks.cz/ + https://github.com/rkd77/elinks
| kitd wrote:
| If you do any work with K8s, k9s is a handy tool.
|
| https://k9scli.io/
| d0mine wrote:
| 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
| kjellsbells wrote:
| 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.
| neelc wrote:
| 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.
| oconnore wrote:
| > 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.
| p_l wrote:
| 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.
| spcebar wrote:
| 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.
| mrgoldenbrown wrote:
| 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.
| dbelford wrote:
| 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.
| abraae wrote:
| 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.
| graemep wrote:
| Mice are the problem, not the rest of the GUI.
|
| Keyboards are just faster once you learn them.
| kjs3 wrote:
| 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.
| frozenlettuce wrote:
| Sogamed old ui is a good inspiration
| https://web.archive.org/web/20030620073042/http://sogamed.co...
| KronisLV wrote:
| ctop is pretty nice, if a bit basic: https://ctop.sh/
|
| There's also k9s: https://k9scli.io/
|
| And of course htop and nano!
| TZubiri wrote:
| ChatGPT
| dv_dt wrote:
| 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.
| neverartful wrote:
| 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.
| gnoack wrote:
| 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-...
| xkriva11 wrote:
| tvterm: A Turbo Vision based terminal emulator:
| https://github.com/magiblot/tvterm
| bennyp101 wrote:
| 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.
| chaosprint wrote:
| 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/
| syngrog66 wrote:
| 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
| weinzierl wrote:
| 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
| tstack wrote:
| 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.
| kickingvegas wrote:
| 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.
| boblob-law wrote:
| SMIT in IBM
| neverartful wrote:
| To nitpick, the TUI version was smitty. The graphical version
| was smit. Both had the same functionality and worked the same
| way.
| imglorp wrote:
| Honorable mention for "tig", a git frontend. Super fast and
| readable.
| kqr wrote:
| 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...
| buescher wrote:
| 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/
| tombert wrote:
| 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.
| perihelions wrote:
| It's unix command names for fast food!
|
| chown MCNUGS, please!
| tombert wrote:
| 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.
| baliex wrote:
| Not forgotten by any means but goaccess is nice and simple to use
|
| https://goaccess.io/
| sayrer wrote:
| Oxide computer has a really interesting one. This probably hits
| all of the big points: https://oxide.computer/podcasts/oxide-and-
| friends/1272104
| readmemyrights wrote:
| 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/
| prab97 wrote:
| 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
| NunoSempere wrote:
| On that note, moc (http://moc.daper.net/) is also pretty nice
| martin1975 wrote:
| Just came to see if anyone here got interested in MS-DOS TSR
| programs as a result of their exposure to Sidekick :).
| iveqy wrote:
| 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 :)
| atum47 wrote:
| 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.
| jonjacky wrote:
| Acme, the combination editor, shell, and window manager.
| Influenced by Oberon, which another comment mentioned.
|
| http://acme.cat-v.org/
| Ringz wrote:
| 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.
| FridgeSeal wrote:
| - 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.
| NunoSempere wrote:
| 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).
| nikisweeting wrote:
| 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)
___________________________________________________________________
(page generated 2024-05-07 23:01 UTC)