14 ms·

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

• andyzweb 3y ago
  UMENU https://www.troubleshooters.com/umenu/index.htm https://www.troubleshooters.com/umenu/index.htm
• templon 2y ago
  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-system/ http://pascal.hansotten.com/ucsd-p-system/cp-m-and-ucsd-p-sy... As for more modern stuff, I like using ncdu and htop.
• hggh 3y ago
  Lotus 1-2-3: https://github.com/taviso/123elf https://github.com/taviso/123elf cointop: https://github.com/cointop-sh/cointop https://github.com/cointop-sh/cointop
• fragmede 3y ago
  Midnight Commander immediately comes to mind, but also Borland's C++ compiler.
  • azov 3y ago
    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 3y ago
      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.
      • deleted 3y ago
        [deleted]
• verdverm 3y ago
  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://docs.hofstadter.io/getting-started/hof-tui/ https://github.com/hofstadter-io/hof/tree/_dev/lib/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 3y ago
  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 3y ago
  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 3y ago
    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 3y ago
      > I still have a hard time with curses. FWIW, _everybody_ has a hard time with curses. That's why it's (aptly) named "curses!"
• cpach 3y ago
  WordPerfect is an interesting example: https://lock.cmpxchg8b.com/wordperfect.html https://lock.cmpxchg8b.com/wordperfect.html WordStar is another one, used by George RR Martin et al: https://arstechnica.com/information-technology/2017/03/wordstar-a-writers-word-processor/ https://arstechnica.com/information-technology/2017/03/words...
  • kjs3 3y ago
    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.
    • shrubble 3y ago
      Available on Linux still... https://github.com/taviso/wpunix https://github.com/taviso/wpunix
    • IIsi50MHz 2y ago
      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.
• pelcg 3y ago
  The other day I found many TUI tools on a site called Terminal Trove: https://terminaltrove.com/ https://terminaltrove.com/ And it also features a great list of them here that many might not have heard of. https://terminaltrove.com/list/ 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/categories/top/ https://terminaltrove.com/trippy/ https://terminaltrove.com/trippy/ https://terminaltrove.com/nvtop/ https://terminaltrove.com/nvtop/ There's screenshots and install instructions that's also convenient.
  • Y_Y 3y ago
    The extra convenient part is that the default installation instructions are for everyone's favourite, snap.
  • leonim 3y ago
    I would add another site to the list: https://inconsolation.wordpress.com/ 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-someones-been-reading-my-mind/ https://inconsolation.wordpress.com/2015/01/19/wpe-and-we-so...
  • cosmos0072 3y ago
    In the same TUI spirit: https://github.com/cosmos72/twin 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
• neutronicus 3y ago
  If you want more Emacs examples, Org-mode and Spacemacs (especially in Evil-mode) have a ton of functionality
• kaesve 3y ago
  https://github.com/jonas/tig 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 3y ago
    Sounds like something comparable to LazyGit. https://github.com/jesseduffield/lazygit https://github.com/jesseduffield/lazygit
  • DesiLurker 3y ago
    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 3y ago
    Absolutely one of the best TUIs for sure.
• addaon 3y ago
  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-humint.htm https://www.greenarraychips.com/home/documents/greg/cf-humin... and elsewhere.
• office_drone 3y ago
  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 https://github.com/gui-cs/Terminal.Gui but haven't tried it yet.
  • masfuerte 3y ago
    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 3y ago
      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 3y ago
  The "htop" app, an alternative to the conventional "top," is a nice example of a TUI: <https://htop.dev/ https://htop.dev/>
  • Arcuru 3y ago
    htop is great, but I've migrated to bottom which has a very similar interface with "btm --basic". [1] https://github.com/ClementTsang/bottom https://github.com/ClementTsang/bottom
    • em-bee 3y ago
      interesting. could you share the advantages of "btm --basic" over htop?
      • christophilus 3y ago
        Not the OP, but the graphs over time are a nice touch.
        • em-bee 3y ago
          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.
• skywal_l 3y ago
  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 https://github.com/magiblot/tvision Edit: Not a rewrite, but a port. See comments below.
  • professoretc 3y ago
    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 3y ago
      Yes, that's mentioned in the README.
  • petepete 3y ago
    IBM Topview had a certain charm too https://en.wikipedia.org/wiki/IBM_TopView https://en.wikipedia.org/wiki/IBM_TopView
  • em-bee 3y ago
    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 3y ago
    > Someone took the time to rewrite [port] it as a cross-platform open source library: https://github.com/magiblot/tvision 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 https://www.npmjs.com/package/tuicss
• tetraca 3y ago
  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 3y ago
    QuickBASIC's modernity was just popping out of those 80x25 character cells. It was as promising of the future as Windows 95.
  • gattilorenz 3y ago
    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.
    • ykonstant 3y ago
      An interface that UI designers of today should pay closer attention to. Same for Delphi in GUI land.
• NoboruWataya 3y ago
  These certainly aren't forgotten, but I like: * `ranger` file manager: https://ranger.github.io/ https://ranger.github.io/ * `ncdu` for visualising disk usage: https://dev.yorhel.nl/ncdu https://dev.yorhel.nl/ncdu * `htop` process monitor: https://htop.dev/ https://htop.dev/ I just find them very intuitive, and information-dense while not being overwhelming.
  • colordrops 3y ago
    Some alternatives: * `vifm` file manager, more powerful and performant than ranger, for those who lean towards vim keybindings: https://vifm.info/gallery.shtml https://vifm.info/gallery.shtml * `btop` process monitor, for those who like eye candy: https://github.com/aristocratos/btop?tab=readme-ov-file#main-ui-showing-details-for-a-selected-process https://github.com/aristocratos/btop?tab=readme-ov-file#main...
  • bashinator 3y ago
    `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 3y ago
      Better than the kdirstat/windirstat family?
      • TheSmiddy 3y ago
        it works in the terminal on a headless server
        • bee_rider 3y ago
          That’s a plus!
    • NunoSempere 3y ago
      Wow, thanks for the pointer, finding it super useful right now to see what's taking so much space in my backups
• sgbeal 3y ago
  Another one, which i'm admittedly personally vested in, is fnc, a TUI for the Fossil SCM: <https://fnc.bsdbox.org https://fnc.bsdbox.org>
• megous 3y ago
  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 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 3y ago
  quite a few great examples on this thread. I'll add lazygit (https://github.com/jesseduffield/lazygit https://github.com/jesseduffield/lazygit) for doing git stuff, and fx (https://github.com/antonmedv/fx https://github.com/antonmedv/fx) for working with JSONs.
  • justin_oaks 3y ago
    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 https://github.com/jesseduffield/lazydocker
• corytheboyd 3y ago
  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!
• emersonrsantos 3y ago
  IBM ISPF suite is gorgeous.
  • zokier 3y ago
    The whole IBM 3270/5250 family is interesting evolutionary line in the sense that it is completely separate from the VT100 style UNIX terminals.
• nope96 3y ago
  https://www.ztree.com/ https://www.ztree.com/ a clone of the old DOS Xtree. Quite the learning curve, but very powerful.
• layer8 3y ago
  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/Slrn https://en.wikipedia.org/wiki/Mutt_(email_client) https://en.wikipedia.org/wiki/Mutt_(email_client) https://en.wikipedia.org/wiki/Ncdu https://en.wikipedia.org/wiki/Ncdu
  • justin_oaks 3y ago
    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 3y ago
      and despite having learned about it years ago i still can't remember to use it.
    • loulouxiv 3y ago
      du -h|sort -h goes a really long way
      • cdchn 3y ago
        ncdu is the next step when you've got as far as you can with `du -h | sort -n`
    • noirscape 3y ago
      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).
• sedatk 3y ago
  This just reminded me of my custom TUI-based installer for my FidoNet reader (1997): https://twitter.com/esesci/status/1617997539688722433/ https://twitter.com/esesci/status/1617997539688722433/
• DesiLurker 3y ago
  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 3y ago
    this comment has you covered: turbovision: https://news.ycombinator.com/item?id=40277039 https://news.ycombinator.com/item?id=40277039 there is a terminal UI written to use it too. probably replaces tmux even.
• davekeck 3y ago
  I don't know if it "deserves to be known" but I made debase to make git editing easier: https://toaster.llc/debase https://toaster.llc/debase
  • em-bee 3y ago
    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 3y ago
    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 3y ago
    That looks great! Also, the site is excellent. I love how the animated examples change as you scroll down the site.
    • k4rli 3y ago
      +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.
  • wonger_ 3y ago
    I love this. Perhaps consider updating the GitHub repo with links, gifs, tags, and a README. It might get some more exposure.
• mr_mitm 3y ago
  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 3y ago
    Considering how many HTTP requests the web interface takes, I can see a dedicated Confluence client being a big win.
    • mr_mitm 3y ago
      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 3y ago
    I'm not using Confluence anymore, but I imagine others would find your TUI useful. Have you considered publishing it?
    • mr_mitm 3y ago
      I have, and I did: https://github.com/AdrianVollmer/Congruence 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.
      • duckmysick 2y ago
        Thanks, that's awesome. Love the MeWare term, I'm going to add it to my vocabulary.
• justin_oaks 3y ago
  I recently had a coworker point out VisiData: https://www.visidata.org/ 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 3y ago
    I used it for a while but IMO nowadays csvlens beats it. https://github.com/YS-L/csvlens https://github.com/YS-L/csvlens
• danielvaughn 3y ago
  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 3y ago
  I absolutely love visidata : https://www.visidata.org 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 3y ago
  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 3y ago
  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 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/rothgar/awesome-tuis https://github.com/toolleeo/cli-apps https://github.com/toolleeo/cli-apps
  • leephillips 3y ago
    What do you mean when you say that gnuplot is a GUI program?
    • friend_and_foe 3y ago
      It's a graphical interface as opposed to running inside a terminal.
      • leephillips 3y ago
        There are GUIs available for gnuplot, but it’s primarily a terminal program, and has a REPL.
• shihanwan1 3y ago
  I have used this https://github.com/vadimdemedes/ink/ 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 3y ago
    I like https://github.com/Textualize/rich https://github.com/Textualize/rich and Textual by the same team, they solve a similar need but using Python.
• willm 3y ago
  Elia is a really nice TUI interface to LLMS (https://github.com/darrenburns/elia https://github.com/darrenburns/elia) Toolong is a log file viewer / tailer (https://github.com/Textualize/toolong https://github.com/Textualize/toolong)
• joshka 3y ago
  I'm a maintainer of Ratatui (a rust TUI crate). Here's a few links https://ratatui.rs/showcase/apps/ https://ratatui.rs/showcase/apps/ https://github.com/ratatui-org/awesome-ratatui https://github.com/ratatui-org/awesome-ratatui https://discord.com/channels/1070692720437383208/1072906183104528434 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 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 https://github.com/zaghaghi/openapi-tui Also, not ratatui, but worth a look: https://github.com/rothgar/awesome-tuis https://github.com/rothgar/awesome-tuis
  • nickpsecurity 3y ago
    That’s a great name btw. :)
  • Quiark 3y ago
    I've been looking for an openapi TUI all my life <3
• oidar 3y ago
  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 3y ago
  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 3y ago
    > 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/); https://www.projectoberon.net/); here is a version or this system which runs on all platforms: https://github.com/rochus-keller/OberonSystem https://github.com/rochus-keller/OberonSystem.
• bitwize 3y ago
  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 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 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 3y ago
    Not sure how related it is, but I found this series on the AS/400 fascinating: https://youtube.com/playlist?list=PL9tkJGALYJ6CzZSPwM-09E5tkfvBn3KR5 https://youtube.com/playlist?list=PL9tkJGALYJ6CzZSPwM-09E5tk...
    • bitwize 3y ago
      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.
• rakoo 3y ago
  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 3y ago
    Sounds interesting. Where is it?
    • rakoo 3y ago
      Oops sorry I forgot it: https://sr.ht/~rakoo/omail/ https://sr.ht/~rakoo/omail/
      • leephillips 3y ago
        Thanks!
• hanniabu 3y ago
  Are there any tools to convert a TUI into a GUI?
  • neverartful 3y ago
    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 3y ago
    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 https://github.com/Textualize/rich
• theonemind 3y ago
  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 3y ago
  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 http://img1.51cto.com/attachment/201204/133704226.jpg
  • kjs3 3y ago
    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 3y ago
  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 3y ago
  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.
  • rep_lodsb 3y ago
    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.
    • euroderf 3y ago
      > 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.
• brenoafb 3y ago
  Not what's commonly understood as TUI, but I love Acme from plan9 https://www.youtube.com/watch?v=dP1xVpMPn8M 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 3y ago
  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 https://www.ebay.com/itm/276317392496 It was a neat way of surfacing lots of commands without taking up any screen-space.
• hypertexthero 3y ago
  I loved discovering keyboard shortcuts for video games like Rogue: https://en.wikipedia.org/wiki/Rogue_(video_game) https://en.wikipedia.org/wiki/Rogue_(video_game)
• mmcgaha 3y ago
  The tin news reader and weechat are nice.
• busseio 3y ago
  TinyMUSH (which is somewhere between TinyMUD and TinyMUSE if my historic memory is correct): https://github.com/TinyMUSH/TinyMUSH https://github.com/TinyMUSH/TinyMUSH
  • cmrdporcupine 3y ago
    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 3y ago
  * Bloomberg terminal * Vim ;)
• leg100 3y ago
  I've built a TUI for terraform: https://github.com/leg100/pug 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 3y ago
  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 3y ago
    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 3y ago
      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 3y ago
  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 3y ago
  Framework (https://en.wikipedia.org/wiki/Framework_(office_suite) 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/ 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 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 3y ago
  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 https://en.wikipedia.org/wiki/Menuconfig [1] https://sourceware.org/gdb/current/onlinedocs/gdb.html/TUI.html https://sourceware.org/gdb/current/onlinedocs/gdb.html/TUI.h...
  • kjs3 3y ago
    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).
    • bqmjjx0kac 3y ago
      I recall `make nconfig` being much friendlier.
• cmrdporcupine 3y ago
  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 3y ago
  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 https://en.wikipedia.org/wiki/Teletext [2] https://en.wikipedia.org/wiki/Minitel https://en.wikipedia.org/wiki/Minitel
• smusamashah 3y ago
  There is Text-based Desktop Environment https://github.com/directvt/vtm 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 3y ago
  imtui looks interesting. A text based backend for Dear ImGui. Never tested it myself though. https://github.com/ggerganov/imtui https://github.com/ggerganov/imtui
• deleted 3y ago
  [deleted]
• tonymet 3y ago
  ncdu dive https://github.com/wagoodman/dive https://github.com/wagoodman/dive
• every 3y ago
  You might want to play around with the lynx browser as well... https://en.wikipedia.org/wiki/Lynx_(web_browser) https://en.wikipedia.org/wiki/Lynx_(web_browser)
  • pQd 3y ago
    and elinks as well. it had better handling of page layout. http://elinks.cz/ http://elinks.cz/ + https://github.com/rkd77/elinks https://github.com/rkd77/elinks
• kitd 3y ago
  If you do any work with K8s, k9s is a handy tool. https://k9scli.io/ https://k9scli.io/
• d0mine 3y ago
  Examples of building blocks for UI in Emacs: - transient (notable app: magit) - hydra (another menuing package for emacs) https://youtu.be/_qZliI1BKzI https://youtu.be/_qZliI1BKzI - minibuffer helper packages: vertico, orderless, embark, etc https://youtu.be/d3aaxOqwHhI https://youtu.be/d3aaxOqwHhI
• kjellsbells 3y ago
  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 3y ago
    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 3y ago
      > 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 3y ago
        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.
• imglorp 3y ago
  Honorable mention for "tig", a git frontend. Super fast and readable.
• frozenlettuce 3y ago
  Sogamed old ui is a good inspiration https://web.archive.org/web/20030620073042/http://sogamed.com/ https://web.archive.org/web/20030620073042/http://sogamed.co...
• KronisLV 3y ago
  ctop is pretty nice, if a bit basic: https://ctop.sh/ https://ctop.sh/ There's also k9s: https://k9scli.io/ https://k9scli.io/ And of course htop and nano!
• TZubiri 3y ago
  ChatGPT
• dv_dt 3y ago
  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 3y ago
    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 3y ago
  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-men.html https://www.unix-ag.uni-kl.de/~guenther/unix-tools-for-real-...
• xkriva11 3y ago
  tvterm: A Turbo Vision based terminal emulator: https://github.com/magiblot/tvterm https://github.com/magiblot/tvterm
• bennyp101 3y ago
  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 3y ago
  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 https://github.com/chaosprint/asak [2] https://ratatui.rs/ https://ratatui.rs/
• syngrog66 3y ago
  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 https://github.com/mkramlich/slartboz-pub
• weinzierl 3y ago
  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 https://www.deutsches-museum.de/en
  • euroderf 3y ago
    > 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.
• tstack 3y ago
  The Logfile Navigator (https://lnav.org 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 3y ago
  Recently I've been making Transient-based porcelains for some venerable Emacs packages. - For calc, there is Casual https://github.com/kickingvegas/casual https://github.com/kickingvegas/casual - For isearch, there is cc-isearch-menu https://github.com/kickingvegas/cc-isearch-menu https://github.com/kickingvegas/cc-isearch-menu - For Dired, there is Casual Dired https://github.com/kickingvegas/casual-dired https://github.com/kickingvegas/casual-dired All can be run in a TTY to get that TUI experience.
• boblob-law 3y ago
  SMIT in IBM
  • neverartful 3y ago
    To nitpick, the TUI version was smitty. The graphical version was smit. Both had the same functionality and worked the same way.
• horacemorace 3y ago
  [dead]
• kqr 3y ago
  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_file_managers.shtml https://softpanorama.org/Articles/introduction_to_orthodox_f...
  • nailer 3y ago
    Also xtree, ztree etc.
• buescher 3y ago
  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/ https://www.pa3fwm.nl/software/puff/
• tombert 3y ago
  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 3y ago
    It's unix command names for fast food! chown MCNUGS, please!
    • tombert 3y ago
      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.
      • bqmjjx0kac 3y ago
        Is the inventory tracked so closely that you can detect a missing box of McNugs?
        • tombert 3y ago
          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.
• baliex 3y ago
  Not forgotten by any means but goaccess is nice and simple to use https://goaccess.io/ https://goaccess.io/
• sayrer 3y ago
  Oxide computer has a really interesting one. This probably hits all of the big points: https://oxide.computer/podcasts/oxide-and-friends/1272104 https://oxide.computer/podcasts/oxide-and-friends/1272104
  • cdchn 3y ago
    Thats a whole lot of text to try to ferret out what "really interesting one" you're talking about.
• readmemyrights 3y ago
  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/ 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/ https://www.nongnu.org/nmh/ [1]: https://github.com/leahneukirchen/mblaze https://github.com/leahneukirchen/mblaze [2]: https://leo-arch.github.io/clifm/ https://leo-arch.github.io/clifm/ [3]: https://edbrowse.org/ https://edbrowse.org/
• prab97 3y ago
  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://rybczak.net/ncmpcpp https://wiki.archlinux.org/title/ncmpcpp https://wiki.archlinux.org/title/ncmpcpp
  • NunoSempere 3y ago
    On that note, moc (http://moc.daper.net/ http://moc.daper.net/) is also pretty nice
• martin1975 3y ago
  Just came to see if anyone here got interested in MS-DOS TSR programs as a result of their exposure to Sidekick :).
• iveqy 3y ago
  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 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 3y ago
  How about this software I wrote back in college to manage beauty parlors? https://github.com/victorqribeiro/beautyhair 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 3y ago
  Acme, the combination editor, shell, and window manager. Influenced by Oberon, which another comment mentioned. http://acme.cat-v.org/ http://acme.cat-v.org/
• Ringz 3y ago
  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.
  • visil 3y ago
    I used to use aerc, though mutt is more powerful. Might switch to neomutt. Sc-im is great, however may be really confusing sometimes.
    • Ringz 3y ago
      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.
• FridgeSeal 3y ago
  - 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.
  • sgt 3y ago
    Does k9s work with k3s without issues?
    • piperswe 3y ago
      I don't see why not, in my experience it works perfectly fine as long as you have a working kubeconfig
  • rep_movsd 3y ago
    Try lazydocker as well
• NunoSempere 3y ago
  Some which I use: lf, neomutt, moc/mocp, newsboat, fzf. Screenshots for some: https://nunosempere.com/blog/2023/03/27/soothing-software/ 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 https://github.com/YS-L/csvlens), lynx (elinks, links).
• nikisweeting 3y ago
  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 https://docs.sweeting.me/s/system-monitoring-tools There's also this list: https://github.com/rothgar/awesome-tuis 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)
• pgib 3y ago
  DESQview for DOS was an amazing way to add some multi-tasking capabilities into an otherwise limited environment. https://en.wikipedia.org/wiki/DESQview https://en.wikipedia.org/wiki/DESQview
  • cdchn 3y ago
    DESQview was pivotal for running multi-line BBSes.
• cdchn 3y ago
  Going even deeper I've been trying to find good examples of the aesthetic of the "light bar menus" from the Renegade/Final era of BBSes. I've found it to be unexpectedly difficult!
• y04nn 3y ago
  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)
• beretguy 3y ago
  Git gui in terminal https://github.com/extrawurst/gitui https://github.com/extrawurst/gitui
• qiakai 3y ago
  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/ https://www.x-cmd.com/
  • qiakai 3y ago
    Also very small
• deleted 3y ago
  [deleted]
• lijunhao 3y ago
  x-cmd come with a TUI library and many mod (mostly cli) in x-cmd are powered by this library. You can see the demo in the website.
• Modified3019 3y ago
  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.
• falqun 3y ago
  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.
• peterhull90 3y ago
  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 https://en.wikipedia.org/wiki/ALL-IN-1
• joouha 3y ago
  Euporie is the most complex TUI application I have built: https://github.com/joouha/euporie 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.).
• AbuAssar 3y ago
  midnight commander
• opan 3y ago
  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.
• Quiark 3y ago
  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 https://github.com/alisoss/pcfand
• ptmcg 3y ago
  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/ https://pypi.org/project/logmerger/ Github: https://github.com/ptmcg/logmerger https://github.com/ptmcg/logmerger (screenshots in README)
• capr 2y ago
  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 https://github.com/capr/chordclopedia