The UX actually matters, and TUIs are generally built for effectiveness and power (lazygit being an excellent example). But once you start adding mouse clickable tabs, buttons, checkboxes etc. you left the UX for TUIs behind and applied the UX expected for GUIs, it has become a GUI larping as a TUI.
Hard disagree. Borland TurboVision [0] was one of the greatest TUI toolkits of the DOS era, had all of these:
> Turbo Vision applications replicate the look and feel of these IDEs, including edit controls, list boxes, check boxes, radio buttons and menus, all of which have built-in mouse support.
Well, I can’t remember if it had tabs.
But hey, if the screen is drawn 24 x 80 with extended ascii, it's TUI. And man, loved the "absolute" keyword in turbo pascal. Instant screen writes when writing to a 2 dimensional array.
You can be effective and powerful in any kind of interface, Just like you can be ineffective and weak in any kind of interface. People like TUIs because they're cool, and work over SSH.
What do you mean by this? I have never heard these terms before. I can launch and interact with a GUI from a text application, or a text application from a GUI.
Beyond this, without remote X properly configured, again, most don't and probably shouldn't.. you aren't running remote gui applications over an SSH session. Richer TUIs were pretty common in ye old days of DOS and other OSes before rich GUIs become the norm. DOSShell, Edit.com, etc. The IDEs of days past and Word Perfect even. These all interacted with Mice and were considered the norm. The features that allow this over a remote terminal today are pretty great IMO, the harder part is properly handling window sizes/resizes, etc.
With graphical extensions, there are even nice app explorers with image previews via TUI. It pushes the boundaries. For that matter, I often wonder what could have come with RIPscrip/RIPTerm if the leap to web didn't happen the way it did...
I think the single hardest part of TUI is dealing with wide characters and secondary fonts for color emojii that don't quite render in 2 spaces completely in a lot of termianls... it makes the line drawing harder too.
A terminal is an OS construct mostly. It will, with permissions, allow you to do anything the OS can do, including shutdown, or serve more data. It's the default mode of operating the system.
The opposite is not true. The default mode of operating a web browser will not let you create a terminal access or do anything new with the machine.
Insofar as the previous is false - because it website has flaws that allow code execution, shell escapes, or remote package installations, it's worth pointing out that these are usually possible because your web server is running as a user on a system, effectively with system access via similar interfaces as the shell.
This is like saying you can operate a car from the truck - yeah maybe through some weird gymnastics, but the trunk is for transfer, and the drivers seat is for operating.
You're off base with your talk of terminals being "OS constructs" or whatever, I think it's because you're not being precise with what exactly you're talking about. "The terminal" is a combination of a terminal emulator, which is a userspace program which interprets control sequences that tell it which characters to render where. The terminal emulator is connected to a psuedoterminal, which is a pair of files for IPC with some special semantics, notably canonical mode. Importantly, in none of this is anything for controlling the system.
For controlling the system, you need some other program besides a terminal. A shell. A shell isn't part of the terminal, nor part of the operating system except in a broader sense of the term. And it doesn't have special abilities to control the system, anything the shell can do, a TUI or web interface, or any other kind of interface can be made to do.
Anyway, you ssh into a computer and start a TUI. The TUI doesn't render anything, it just sends you text and escape codes. The terminal emulator on your computer interprets this stream of escape codes and text, as a web browser interprets html, and renders it locally.
Text interfaces and text based sessions have a definition, as do graphical interfaces, as does web interfaces. They're separate and well defined even if there's some minor blurring at the edges or you can emulate one inside another.
With a web app, you can slice and dice processing between local and remote by running JS locally. Most processing usually happens remotely though, and only the display and command logic is run in the browser.
Is it pixel or vector mapped, designed to run in a graphics terminal? GUI.
Of course strictly speaking TUI is a subset of possible graphical user interfaces, but the term GUI was coined to denote interfaces other than the already-ubiquitous text terminal interfaces.
TUIs have since absorbed GUI interface elements like buttons, checkboxes, and even pointer input, which I think is causing the terminology complaint here. Classical TUIs like Norton Commander are more about keyboard input and navigation. But being text-mapped is the identifying feature of a TUI, I think most people accept.
My point is that it’s not a given that having one means you have the other.
TUIs are wonderful for the first case.
Your terminal windows (whether that's "Terminal" or "cmd.exe" or anything else) are still fundamentally graphical programs that emulate such a text session.
- https://en.wikipedia.org/wiki/Linux_console - https://en.wikipedia.org/wiki/Windowing_system#Display_serve...
No. All you've done is make a low-resolution GUI.
A GUI that is built with Text, and intended to be used in a Terminal, is what a TUI is, colloquially AND definitionally.
What do you think qualifies as a TUI?
Of course you can use the primitives of TUI, especially with mouse support, to reproduce a large amount (if not all) of the standard GUI interaction paradigms.
But it's bizarre, and missing the point from a UX perspective.
As an extreme example, we can imagine a program that displays the borders of a 40x15 "window" in the middle of a console, with box-drawing characters, putting a "close box" in an upper corner, with text like "File Edit Help" in the top left. We can imagine it responding to a click on the "File" text by popping out a "menu"; we can imagine a drag starting from the "title bar" causing the window position to be update (and the entire terminal window redrawn).
A lot of those kinds of functions, ironically enough, might make sense for a TUI editor implemented as a TUI (except the "windows" might just be understood as panels where the ultimate program displays parts of its output). But as an emulation of GUI windows, it'd be a strange, impractical novelty.
Even in your example, it's pretty clear cut. If the window is built with text and served in a terminal emulator, it's a TUI. If you build it with a graphical framework that now needs X11 or whatever, it's a GUI.
This is just needlessly pedantic.
The issue is not the text. It's the WIMP interface.
It's a GUI that works over SSH. There is a very valid use case for that.
But if this thing requires you to just tab a lot through lots of pointless and rarely used fields to get to a "button" so you can activate it, because it's really all designed to be used with a mouse, then it's a bad text-based UI.
There are some incredibly good text-based UIs around, some going back to mainframe stuff from the 70s. Most of them are optimised for speed of control via keyboard rather than for looking pretty. Almost none of them would be quicker to use with a mouse.
How about those text games that used ASCII art and you typed in commands like "look" and "go north"?
I would say using text mode is the primary requirement for a TUI. The other requirement being some kind of human-machine connection, IE a User Interface.
Well, except:
> a 1:1 representation of the concept within character cells.
TUI is build from text, and living within its constraints and what it's engine (usually the terminal) allows. GUI is build from graphics, and has basically a pixel perfect control of its own. This is a very notable difference, especially at the time when these terms were coined.
> TUIs are generally built for effectiveness and power
No, this is a result of different architectures and their constraints.
> But once you start adding mouse clickable tabs, buttons, checkboxes etc. you
TUI and mouse are predating the GUI (more or less). We had them already 40-50 years ago at the dawn of interfaces. We are now just moving back to them for practical reasons.
It clearly cannot. Have you even tested it?
I guess the headline and website was enough to get all these upvotes. Quite disappointing as someone in the early stages of making a TUI tutorial myself.
100 percent agree. I personally love what the openTUI folks have been up to. As weird as this might be to say, we're still in the early, early stage of TUI adoption.
Zellij among is a great example, I can do everything with my keyboard, but every now and them I'm already with the mouse and just click a tab or pane, no functionality lost, just added, why the need to make a cutoff philosophical/semantic hard argument?
I admit I don't always pay the most attention to it, as the UI components I tend to use do a good enough job of this. But I'm usually pretty consistent with it.
enter ~C -L 8080:localhost:80(Ultimately unhelpful though because I use mosh everywhere these days and that doesn't appear to have anything fancy like this.)
Technically, you don't have to press enter if you've not typed anything (try it in a new SSH session - as soon as you are logged in, type ~? to get the SSH help output), but since the comment was about doing this during an active session without ending it, I figured noting that pressing enter first to be sure you're on a new line wouldn't hurt
For navigation between windows I have this:
bind -n S-Left select-pane -L
bind -n S-Right select-pane -R
bind -n S-Up select-pane -U
bind -n S-Down select-pane -D
# Control shift arrow to resize panes
bind -n S-C-Left resize-pane -L 5
bind -n S-C-Down resize-pane -D 5
bind -n S-C-Up resize-pane -U 5
bind -n S-C-Right resize-pane -R 5
# Shift arrow to switch windows
bind -n M-S-Left previous-window
bind -n M-S-Right next-window
bind -n S-Home previous-window
bind -n S-End next-window
# No delay for escape key press
set -sg escape-time 0
set-option -g repeat-time 0(I think terminal-based GUIs are neat just for fluidity of use- you can pop one open during a terminal session and close it without switching to mouse or shifting your attention away from the terminal. They can also be a nice addon to a primarily CLI utility without introducing big dependencies)
Then colour my suprise when it popped up on my screen right there. Slow as molasses but still. Wow. Magic.
It's a shame Wayland dropped this. Yes I know there's waypipe but it's not the same.
It... really isn't. Like you said, remote X was barely usable even over an entirely local network. Most applications these days are also not designed for it, using loads of bitmap graphics instead of efficient, low-level primitives. So you end up being just one tiny step away from simply streaming a video of your windows. We have better tools for doing things remotely these days, there's a reason approximately no one has used remote X after the mid-90s. It's a neat party trick, but I don't blame the Wayland authors for not wanting to support it.
In the 80s/90s this wasn't feasible due to network latency and bandwidth, but it's pretty common now to do exactly this, with VNC and other remote desktop protocols.
In the time when wayland was invented it made sense because we did everything purely local. But now it's as outdated as X11 was in 2010.
And yes I still use it a lot. It works well. Networks have become a lot better and even most cloud compute I use is geographically nearby.
What made it slow back then was that I only had a 128kbit uplink at home. And the uni had 2 mbit for the whole computer science building :)
People complained of no forwarding in Wayland when it was invented.
For example, the remote mail client usecase I was replying to is simply done with a webmail client today.
But this doesn't work on your phone, or on a Windows or macOS device, right? That's what I meant by flexible, X forwarding fits a pretty narrow set of usecases, while on the other hand keeping programs on the clients and data centrally located on a server allows for a whole lot more options for how to interface with that data.
(To be clear, nothing wrong with X forwarding! It's a cool tech and I'm glad you have a use for it! I'm just arguing that it's fine for Wayland to not try to support that kind of thing, because we've got other ways of working remotely now.)
Most recently I used X forwarding to manage some LVM disks. I usually like using cli, but for me it's just easier to deal with disks with a GUI. Shy of setting up a full remote desktop, which I've had a lot of trouble with getting to work reliably, what's a better option here for an arbitrary disk program?
There is not a web tool for every use. And web tools are not better for every use.
The main advantage of x forwarding for me was when I'd randomly need it and had nothing set up ahead of time. Hopefully it starts getting installed in distros by default eventually.
Unfortunately, they are often artificially differentiated by the style of the UX interaction: TUIs promote the keyboard actions, and GUIs prefer mouse without corresponding keyboard shortcuts. Unfortunately for GUIs, their designers are often so enamored with WIMP that they omit the keyboard shortcuts or make them awkward. I hate it when, even if the ACTION button is available by keyboard traversal at all, it requires some unknown number of widget traversals instead of being one tab away.
Since the keyboard is almost always used for the textual data, it makes sense to me to always enable it for command execution. Well designed GUIs and TUIs provide both WIMP and keyboard UX, which sadly is not the norm today, so here's my vote to make them larp for each other more.
TIL that VIM is not cease being TUI the moment I type :set mouse=a.
Hot taking, LARPing and teenage angst (caused by generational gap with those has been using TUI since 1980s) is on your side.
Sadly the project is not really in a usable state at the moment. The documentation is incomplete riddled with errors, the code has some pretty glaring bugs, and it's close to abandoned. It's a shame because you can do some really amazing stuff with it.
If it requires graphics login, even if it uses character layouts - GUI
IMHO the T/G is not for the display elements, it's for the type of session.
"This is dumb" - gets downvoted to oblivion. "This is nonsensical + a bunch of absolutely bs reasoning" - second most upvoted comment atm.
HN tolerates the appearance of quality discourse over the actual thing, and dealing with this dissonance in most comment sections is exhausting.
I think TUIs are neat, I guess. But I think these things have abused the concept extensively. They don't actually interact well with the rest of a Unix environment.
UIUIUI
That's literally what TUI's looked like starting from the late 1980s and throughout the 1990s... You have a pointing device, might as well make use of it to enhance discoverability.
They all have very different structure to what a typical GUI look like. E.g. a focus on condensing more information in few text cells, and usually not displaying anything extraneous, typically rarely using dialogs etc.
There are notable exceptions to that, sure, but as I noted that is exactly what I have no interest in.
For the rest, I typically use a browser.
> Design once, generate production-ready code for your framework of choice. Switch targets without touching your design. Alpha notice: Code export is not functional yet. We're actively working on it — check back soon.
In other words, it isn't at all usable right now. You can't produce a TUI with it, not even a limited one.
You can build great things using AI agents, and you can build trash.
Your ideological opposition to that is not shared by as wide a percentage of developers as you may think based on some highly self selected online corners.
I too remember running `rails new MyGreatApp` and having hoop dreams of being the next billionaire entrepreneur, but a boilerplate app is a boilerplate app.
I know this position is wrong, but it feels hard to spend my time on something that someone else might not have spent the time to create
Your ideological opposition to that is not shared by as wide a percentage of developers as you may think based on some highly self selected online corners.
If 30% of devs love openclaw, I'm not re-examining my informed opinion, I am forming a new one about that 30% cohort.
>can't wait to see where it goes!
Fall into this toxic positivity nonsense at your own peril.
Let's imagine one do. What do you think can actually happen that is so negative? Toxic TUI will hunt you in dreams?
Gatekeeper blocks the app immediately. You'll see either "TUIStudio cannot be opened because it is from an unidentified developer" or "TUIStudio is damaged and can't be opened" on newer macOS after quarantine flags the binary.
To get past it: right-click the .app → Open → Open anyway — or go to System Settings → Privacy & Security → "Open Anyway".
Neat concept though if it ends up working.
You seem to be implicitly trusting the creator of the app, which is a mistake.
It completely misses the reason people like current TUIs.
I find the search [2] also helpful.
I would have expected a TUI editor to be itself a TUI.
It's funny, when you're using a claude code terminal inside vscode to use a "TUI", you're actually using a web application.
Also wheres the Linux version? You've Mac, windows, and docker. When someone says terminal to me I default to Linux.
Also if TUIs are so great, why isn't this a TUI app?
A lot of the recent TUI apps are really not old-school in any way. Not all apps need the feature-set of a browser engine. And compared to native mac/linux desktop apps, TUIs get cross-platform support by default.
> Also if TUIs are so great, why isn't this a TUI app?
We all know the answer to this
It created a replica CLI that behaved the way the real thing would, for quick prototyping and design feedback. The next step [2] would have been generating backend for different languages/libraries to create the actual CLI.
I lost the original sample "buddy" files but we did use it for prototyping a new Chef Workstation cli. Copies still haunt the Internet [3]
[1] defunct, https://github.com/marcparadise/clibuddy
[2] had I continued to need it
[3] https://github.com/gridgentoo/chef-workstation/blob/master/d...
I'd much rather terminals emulator provide a webview directly, and maybe use https://webtui.ironclad.sh/ if you really want the look.
I think it makes more sense for a cli to offer a mini webserver instead.
Think `fish_config`, but opened in the terminal directly [0].
[0]: like https://iterm2.com/browser-plugin.html
Interesting. In what ways? I haven't heard anyone express this concern before.
Web browsers offer the DOM to tools such as screen readers (OSs offer their own accessibility sdks). Someday perhaps the TUI application could talk to the terminal emulator that would itself talk to the accessibility sdk of the OS and that info would somehow then be accessible.
There was a beginning of discussion at bubble tea[0] about this for example.
Just `bun run dev`
That being said, I could see a niche market for a designer persona who is used to building in tools like figma.
Agents aren't picky with UI, so most effort will always be spent designing for humans, even if they are not the primary consumers.
On the other hand, for this work as they describe, it needs to be a complete UI framework across a bunch of languages and built on top of a bunch of existing frameworks. That seems... ambitious. Building one UI framework for one language is plenty hard enough.
Browsers are ubiquitous and I can just tell ai to build a web page. I can't really see a use case other than novelty.
I do agree Unicode is better than code pages, or doing alt + num pad codes.
also
> Gatekeeper blocks the app immediately. You'll see either "TUIStudio cannot be opened because it is from an unidentified developer" or "TUIStudio is damaged and can't be opened" on newer macOS after quarantine flags the binary. To get past it: right-click the .app → Open → Open anyway — or go to System Settings → Privacy & Security → "Open Anyway".
From their github it appears all the code is llm-generated
Something like this could genuinely help for the layout/positioning phase, even if you still hand-write the interaction logic. The debate about whether these are "real TUIs" kind of misses the point imo. Textual and Ratatui already blur that line with mouse support and rich widgets. The ship sailed on pure keyboard-only text interfaces a while ago.
What I'd actually want from a tool like this is to export to multiple TUI frameworks. Right now you're locked into one ecosystem and the code export isn't even working yet, which makes the whole thing feel premature.
This is really cool though.
I mean yes, code editor are great for this but a lot of the TUIs I see are so slow it begs the question why they exist to begin. CLIs are supposed to be remixable and scriptable.
I think a better architecture would be to generally keep CLIs work like CLIs and have separate processes that add terminal rendering functionalities for those that need / want it but in general it is an anti-pattern to start from this as default.
But I wish we'd just make fast GUIs instead of giving up and building TUIs instead.
Ah yes, it says clearly that on the github page. Still, if its works, I am then impressed by the LLM.
Edit: It does, in fact, NOT work for code export. Level of impressiveness massively dropped.
Probably a bad omen of things to come for the internet.
VB's back, tell a friend.
I don't think there is utf8 characters that allow for drawing on the outside of the cell, (happy to be wrong)
┌ (U+250C), ┐ (U+2510), └ (U+2514), ┘ (U+2518) <-- these 4 draw in the middle of the cell.
｢ (U+FF62), ⌟, (U+231F), <-- these are two that cover part of the outside, but not the other corners.
｢┐└｣
Can anyone tells me how to get those 'corner of cell' characters, including uprights and horizontals ?
I launched https://github.com/alganet/tuish yesterday (pure shell backend).
Exporting to pure shell could be a killer feature, especially for smaller and ad-hoc apps (no dependencies, no compilation, etc).
The fact that even the preview isn't a TUI is just lame. Keyboard controls are also non-functional right now.
(I know, I know, port forwarding should work for a web app.)
Another thing that gives the TUI concept an edge is the lack of formatting options: no way to make a font too tiny or too huge, very little leeway in implementing common controls, any excessive whitespace looks jarring, etc. Icons are limited to the common emoji.
All this makes you concentrate on providing functionality first.
One of the most original ideas I have seen on HackerNews in the past few years.
Another W from the web developers mafia
The only reason I can think of is what I said before [0] given that the web was destroyed by the same web developers, then so was the desktop (with Electron) and now of all places terminals are now getting destroyed with infinite slop like this.
This nonsense will continue and accelerate until it reaches hardware.
Also, how does this handle terminal resizing? Are there options to anchor elements to the left/right etc, or will narrowing the terminal window just make everything fall off the side, or worse, all the text wraps?
https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/...
> controls
> If this attribute is present, the browser will offer controls to allow the user to control video playback, including volume, seeking, and pause/resume playback.
Edit: I misunderstood, you are asking
> how they'd managed to hide the video context menu
Not sure, but it works in FF for me
That is what HN is for!