HN

Comments (201)

• Menu

  zmmmmm
  I think it's the smoldering ruins of the OS vendor self interest collapsing in on itself.There's not a single good universal UI. The best is the browser and it is reasonably successful but the sandbox makes it specifically unsuitable / high friction for doing things that need local access to files, network, etc. And it is ridiculously high overhead if you just want to run something simple. Then remote access is even more a debacle. Can I access an application running on my windows host from my Mac? can I forward that through a tunneled connection?TUI is a simple, universal protocol that does what you need and is natively remote. Whatever I use locally will seamlessly work over an SSH connection.And it's a big middle finger to the OS vendors who thought locking everyone in by making everything incompatible or ecosystem specific was a winning strategy.
• Menu

  schmorptron
  I think part of it is also that we're able to still LARP as full developers of complex systems while vibe coding by seeing an interface that makes us look like l33t h4xx0rs even though we're just pressing continue 15 times
• Menu

  qudat
  I think if you look purely at the numbers, the real reason TUIs are popular is claude code, everything else is background noise compared to it.What originally got me excited to build TUIs was the concept of delivering apps over the wire via SSH. SSH apps resemble a browser in that way: no local installs required.It's a major reason why I enjoy hacking on https://pico.sh -- deploying the TUI requires zero user involvement.
• Menu

  cassepipe
  > The hardcore, moved to vim or emacs, trading immediate feedback and higher usability for the steepest learning curve I’ve seenThe only hard part about vim is to be forced to strecth the finger up to Escape for what is essentially the most essential function in a modal editor: Going back to command mode. The ideal workflow is do a quick edit and go back to command ("normal") mode instantly. The fact that Escape is used is a historical artifact that needs to be called out.So just remap CapsLock to escape, it system-wide, it's not that hard and it's nice to have Escape there generally. In Linux and MacOS it's just a GUI setting away and in windows you just have to edit (create?) a registry key. Can be done on any machine under a minute.Apart from that I don't see where the learning curve is since you can just start with the basics from vim-tutor and look up for more when you feel you're spending too much time on something. I already felt faster than in any other editor when I just knew the basics. The real problem of vim is that you get used to modal editing very quickly and it feels like the stone age when you don't have it.
• Menu

  giancarlostoro
  Because nobody is investing in native UI development. Electron is proof that if there were a simple to use GUI stack that companies would adopt it.
• Menu

  spankalee
  I really don't get terminal UIs that try to rebuild GUI-like functionality. Don't we think that computer interfaces should get better? We're not limited to a grid of characters to pretend to draw lines and shapes with anymore. You can't even display an image in a terminal without a non-standard terminal like Kitty or iTerm.It's just a shame that we don't have a great cross-platform, streamed, UI system. The web is great in it's own ways, but clearly something could be a lot better for this purpose. Flutter's ok, but not on-demand enough and too married to Dart.
• Menu

  0xbadcafebee
  It's nuts that software developers are allowed to design user interfaces at all. They're incapable of making a user interface that isn't text. It's like if plumbers designed houses, they'd make all the floors slope downward, because that's the easiest way for pipes to run.Oh we need multiple windows we can move around/resize? Let's make them text windows. We want people to be able to quickly select options? Yeah make those text boxes. We want to quickly compose documents with some kinda style/formatting? Yeah they'll need to write more text to format it (but let's not make any apps to easily view the text in formatted mode).
• xmodem
  TUIs suck and the only reason they are seeing a re-surgency of relevance is because everything else sucks more along one or more critical metrics. Given the truly incomprehensible amount of CPU and GPU power we have available, this is truly a blight on our industry.
• Menu

  ohnei
  The TUIs I've looked at seem to be largely NPM dependent? Bizarre that agents apparently don't have time to rewrite themselves in something that isn't a security tire fire. It kind of makes me assume that all this agents taking over stuff is from people working at garbage-pivot-garbage startups that don't really have to worry about any consequences but not being fast enough.
• Menu

  _jackdk_
  The diagnosis for GNU/Linux is better than I expected but I think is still incomplete. Yes, you have two major toolkits (GTK+ and Qt) and many minor ones (most of which wrap one of the majors). Qt is proprietary but also available under a free software licence, but what if you don't want that that complexity? It feels like modern GTK+ is less of a cross-platform toolkit and more of a runtime layer for libaidwaita and the GNOME stack. So if you don't want to conform to GNOME's UI conventions, it's not clear where else to go.Also, the explosion of new languages in recent years means having to write a new set of FFI wrappers around existing libraries, and it's easier to make an idiomatic library for TUI development than wrap all of GTK+ or Qt.
• Menu

  abhinavsharma
  To me it's just that they're great for people who live in a terminal- No distractions from visual content- Extreme efficiency with keyboard- AIs can code them up quickly. It used to be a total pain
• Menu

  mgaunard
  Power users have always preferred the command-line, since expressing what you want to do as a programming language is of course much more powerful and productive than clicking menus.To avoid context-switching from the command-line, many essential UIs were made text-only. Another route would have been to integrate the command-line within graphical applications, but few did it -- the main example that comes to mind is Jupyter.
• pelcg
  There are a lot of TUIs in existence worth looking at if one is interested or curious about them [0], [1], [2][0] https://github.com/rothgar/awesome-tuis[1] https://terminaltrove.com/explore/[2] https://github.com/ibraheemdev/modern-unixEven before Claude Code, I always see htop as the prime example of a good TUI.
• herrherrmann
  There are a lot of points in there that are just generally bad in modern applications – e.g. UI inconsistencies, lack of automation and general configurability (shared ways to handle windows, layouts, keyboard shortcuts, etc.). I think it’s fair to say these things are just hugely lacking in modern operating systems. Linux might come close, but only with lots of tinkering. macOS is clearly lost and degrading now, and Windows was never close to having these qualities.I don’t know if TUIs will be the answer, but it’s an interesting development!
• gbin
  I don't think it is surprising. Loading entire chrome processes for simple super laggy UIs is just unbearable.TUI are snappy, accessible over ssh, small screen friendly, easily embeddable in zellij or other multiplexers, easy to copy paste from... Amazing.
• Menu

  ifh-hn
  I'm pretty sure dismissing flutter is ignoring reality. It, and more so dart, are not popular on HN, but it definitely is a popular and still in development truly cross platform framework.
• sombragris
  I fully agree about the overall downward trend in quality and efficiency of GUI apps, but I also think there's an important factor in the rise of TUI apps:People now have access to good terminal emulators. Back in the day, you had cmd.exe in Windows. Now you have a plethora of Linux/Unix terminal emulators, Terminal.app in MacOS, and Windows Terminal in Windows 10/11. These are quite capable applications able to render good, complex text-based interfaces.
• droidjj
  > The most popular claim is the memory consumption, which to be fair has been decreasing over the last decade, but my main complaint (as I usually drive a 64GB RAM MacBook Pro) is the lack of visual consistency and lack of keyboard-driven workflows.Lucky you. I avoid electron apps because I'm limping along with 16gb.
• moomin
  Using Claude has highlighted, for me, a number of issues with terminal apps like Claude Code. You can’t easily see the status of lots of instances, you can’t easily search for instances, you can’t get one instance to start another instance or send a message from one instance to another and, of course, if you make a slightly mistake in coding a full screen app, you get screen corruption.
• hilti
  I totally agree with the author that Windows GUIs and MacOS GUIs are getting worse with every iteration. For my own side project I used ImGUI and it's working great for my purpose.It's by far not as beautiful rendered as the native OS layers, but easy to navigate and a good foundation for cross platform GUI development. And I got it even approved for the MacOS app store. Here's my write up: https://marchildmann.com/blog/imgui-mac-app-store/
• throwaway27448
  Cuz they're cheap and people don't care. Same reason by electron interfaces are so common
• nickjj
  I do like CLI tools and TUIs but in the article it mentions Gnome style apps don't fit the look. That sounds like a limitation of Omarchy.It's not too bad to theme GTK apps and have them all look a consistent way. For example I use Tokyonight Moon and Gruvbox and they both have GTK themes that look great for Firefox, Thunar, GIMP, LibreOffice and more. I don't use Omarchy but here's a few screenshots https://x.com/nickjanetakis/status/2037125261657883061/photo....Nothing fancy was done on my end, just installed the specific GTK themes. They even support live reloading because GTK's tooling supports it, my dotfiles at https://github.com/nickjj/dotfiles handle all of it for you. I still prefer TUIs but you can have nice looking GUI apps for when you want them.
• jdw64
  Developers often say that TUIs are better. But this is largely a matter of taste. To be honest, outside the programmer class, how many groups of users actually like TUIs? Very few. Linux is lighter, and these days even gaming through tools like Wine/Proton has improved a lot. So why do Windows and GUI-based systems still sell more and get used more widely? Because most people prefer wrapped UIs. They prefer interfaces that visually package the system for them. Electron has real problems: memory usage, deployment bloat, and ecosystem fragmentation. But if you move too far toward TUI-first tools, your market target becomes much smaller. So the real question is: why are TUIs coming back in the AI ecosystem? My answer is: AI FOMO. Seriously, why are AI-integrated IDEs like Cursor and Antigravity becoming popular? Even when AI chat is built into the IDE, the IDE often freezes or slows down. If you just open a terminal, it is much faster. So yes, TUIs are attractive in AI workflows because they are fast, direct, remote-friendly, and easy to automate. But explaining their return only as a failure of GUI is too technical a view. There is also a social and market reason: people want access to AI workflows as quickly as possible, even if the interface is not what ordinary users would normally prefer.
• try-working
  The only reason CLIs and TUIs "came back" is because we're still in the early stages of this paradigm, things are moving fast and building a strong GUI UX takes just as much time as building out the backend functionality. So CLI and TUIs are used because they save time, skips the need for building a time consuming GUI. Also building UI is hard.
• ilaksh
  It's based on trends, momentum and social signaling more than anything, like most things in technology and society. Humans are herd animals.I am affected by it also and have always been fond of TUIs in a nostalgic way.
• arjie
  I make some things GUIs and some things TUIs. The TUIs are easier to work with Claude Code and Codex. We can co-work on many things together because the LLM harness reads TUIs very fast. You can do it with GUIs but that's much slower, and maintaining two separate interfaces into these things isn't worth the trouble.
• osaariki
  TUIs are great for low friction remote work. I do a lot of data processing work on remote VMs with a mix of interactive debugging/eyeballing and bulk jobs. TUIs are a great fit for the sorts of tools I build to support this work. The other UI paradigm I end up reaching for is locally hosted web UIs, as models are really good at one-shotting HTML reports with graphs and tables. Inside VS code those get automatically tunneled to the local machine.
• theanonymousone
  TUIs are extremely more portable, and offer a more uniform UX across platforms.
• kjuulh
  I am conflicted on tuis they are nice, convenient and I dig the aestetic. But they're often not composeable. So even if they're there they dont feel native to the terminal. It is just an app in the terminal and that is okay, but you lose some of the terminal magic
• burnto
  I think there’s also perhaps an organizational explanation.A reasonable TUI can be built without any design or frontend people even looped in.Collaboration and coordination tend to slow down processes and flatten outputs.
• Menu

  ngruhn
  I think the come back is completely driven by Claude Code. Claude Code is a TUI, Claude Code is successful, therefore let's make everything a TUI!I'm pretty sure the success has nothing to do with the TUI though. I personally enjoy it a lot but the productivity boast doesn't come from avoiding the mouse.
• apexalpha
  Shoutout to k9s. Fantastic tool.
• b00ty4breakfast
  the current AI summer has been great for us dorks that prefer TUI/console interfaces. I hope it all sticks around with the inevitable cool-down in LLM hype.
• monkeydust
  Somewhat ironic is that people are using them to create generic web apps like they are going out of fashion.
• xupybd
  Luke Smith was too early on this.
• devmor
  I think most people are missing the forest for the trees.TUIs are popular because once you use a piece of software that doesn't have a poorly-written GUI library full of animations bogging it down, you don't want to go back.It's hard to make a TUI that isn't snappy, no matter how much useless eye-candy it has.
• Menu

  mirekrusin
  servo was recently published on crates – it has potential of becoming new standard; electron model proved to work very well the only downside is monstrous memory usage.
• einpoklum
  The bottom of the post contains an interesting suggestion, for us software developers to read one of three 'basics' books on UI: "Nielsen, Norman or Johnson".Can someone who is more knowledgeable about these help compare and contrast these three texts a bit?
• debarshri
  It was always there. k9s for instance, it started getting noticed recently. With coding agents, it is even easier to build.
• nickdothutton
  My terminal has not been ensh*ttified. I used the Internet for work, for knowledge, more than I use it for entertainment. One of the reasons I like TUIs.
• Menu

  beej71
  The best thing about TUIs is that they're so fast. They launch fast, run fast, and you use them fast. There's a learning curve for the bazillion hotkeys, because all it is is hot keys, but when you have it, you just fly.I've been reverting more and more: mutt (mail), newsboat (RSS), amfora (gemini protocol), gurk (Signal), chawan (web), and even trn (Usenet). My RAM usage is tiny. Everything is quick.GUIs should take a page from the TUI playbook and consider making the app keyboard-first. Nothing is more frustrating than a missing hotkey.
• manyatoms
  TUIs are back because the web got too bloated.
• paddy_m
  I think another factor is that people are rejecting the rounded corners and excessive padding of modern web design, you can't do that in a TUI, so you don't have a designer or standard practice encouraging you to do it. As implemented TUIs have greater information density than GUIs. Make no mistake though, TUIs are a decided step backwards from GUIs. Everything that you can express via text, you can also do in a text area on a GUI app.
• Menu

  slopinthebag
  I think TUI's are popular because they're easier to make than a GUI. They are much more constrained. A TUI is basically a wire frame with some colours, whereas with a GUI the wireframe is only the first step.
• Menu

  tptacek
  The tide is going to turn on this in the second half of 2026. There have always been nerds who just love TUIs, and still read their email in Mutt. But I think the subtext of this article is right, that TUIs are back because of how much of a pain UI development is.But that's changed drastically in the last few months. I spent the weekend doing SwiftUI stuff with Claude, with a lot of success. It's going to get much easier to ship fast, solid, native UIs for things, and native UI is both very fun to build and also attractive to ordinary users.(Fun green field for doing interesting UI work: do native UI for remote server stuff, like an htop UI that uses some dialect of SSH to fetch remote data.)I think modern TUIs are a blip. A big, important blip. But a blip. The age of the Orc is over. The time of the Human Interface Guideline has come.
• nharada
  VB6 was the peak of desktop GUI app development change my mind
• Menu

  bellowsgulch
  A reverse shibboleth for someone who does zero professional design work is taking a screenshot of differing corner radii in macOS.Don’t fall for this.
• Menu

  lispisok
  My cynical take why TUIs are back is because people operating in the terminal became a signal that you were competent and once people figured that out everybody started doing it. The reason people were operating in the terminal is lost of them but hey it makes you look like a 1337 hacker. It's the same thing with side projects of past decades. People who had side projects cared about the craft for more than a paycheck and tended to be more competent. Then every person just trying to land a job suddenly had "side projects". Gotta have those green squares on github.
• pjmlp
  Because now we have a young generation nostalgic of their parents experience in the 1980-90's, and that includes the TUI experiences we were stuck with back in the day.
• Menu

  fg137
  Only for software engineers who are already familiar with terminals. Most non tech people I know and in my company absolutely hate TUI. Even a fraction of software developers who spend most their time outside terminals (especially those that are on Windows and/or use specialized tools/IDEs) prefer to avoid TUIs as well.
• adamnemecek
  They are back because modern languages (Rust, Go) have made it pretty straight forward to build them. Ratatui and such allow you to write a TUI really quickly without needing to deal with VT100 arcana.
• esafak
  Because LLMs operate on text, and their purveyors claim natural language interfaces are the best thing since sliced bread, since that's what they sell.
• frou_dh
  There's something disgusting about the use of characters for graphs/charts on a bitmapped monitor. Trust nerds to find a way to make stuff ugly!
• jrm4
  Nothing inherently special or even superior about TUIs, I think this very simply just speaks to "what happened" which is the fragmentation of the GUI space over the course of Microsoft v Apple v Linux v "The Web."Seems like it could have gone differently. Feels like the time could be ripe for something like a "declarative gui spec."
• TacticalCoder
  I've got a bit of a different on it... It's because TUIs do lend themselves better to automation (it's been mentioned in the thread) and, most importantly, it's because there's less cognitive dissonance between a TUI and how it typically operates and... The way AIs are using command line tools / the terminal (or a REPL, for those using agents hooked to a REPL).In a way AI agents are validating what us old-timers always knew: the CLI and TUIs is the most powerful way. And AI tools didn't choose the most common dev environment: devs using fat IDEs (and btw I was already using IntelliJ IDEA back when some people were still arguing NetBeans was better than IntelliJ) are way more common than those piping Unix commands to achieve even simple tasks. Instead AI tools did choose the most powerful way to work: and that's piping terminal commands and SSH/tmux/TUIs.When the tool itself, like Claude Code CLI, is immediately showing the outputs of piped Unix commands and allowing to run commands from a prompt and is, itself, a TUI, it's validating that it's an extremely powerful way to work.A Claude Code CLI (or similar) TUI in a tmux session is something quite powerful.Then you combine that with the fact that techs like LSP and tree-sitter did at least partially commodotize the IDE and suddenly TUIs (or things very close to it, like GUI Emacs: which can do graphics but is still mostly used as a TUI tool) do look very appealing.Magit is considered by many --even non Emacs user-- as the best Git interface ever. It's text, text and more text.My life is terminals (text), Git and Magit (text), Emacs (GUI but basically text), SSH (text), tmux (text), many text things I forgot and now TUI harnesses.If you're modelizing in Blender or editing movies or creating movies, a GUI makes sense. But if you write code, which is text, all you need is text, text and more text.TUIs are making a comeback because it is all text and AI agents are proof of that.
• j45
  They were never really gone, just maybe introduced to a new audience a little more lately which is great.
• fithisux
  Next one is the NoJS movement and Gemini or even Gopher spaces.JS literally destroyed the software landscape. All the bad practices advertised as best.
• shevy-java
  One huge advantage that the commandline + TUIs have is ... speed.I get more things done, in most cases, than via a GUI. In a way a TUI is a GUI of course, but with the focus on keyboard use and inputting instructions/commands. Most GUIs seem to be centered around keyboard AND mouse and then try to make things convenient here for those operations, such as drag-and-drop via the mouse.
• krelas
  Hate to be this guy but it’s Xerox PARC, not Park.
• Menu

  dzonga
  ahh the classic - see one anecdote - then create a narrative that the world is changing.if TUIs were truly back - as DHH would like you to believe - his money maker - Basecamp - would be available as a TUI, Salesforce, Workday, Bloomberg etc would be available as TUIs. Though Bloomberg is the closest to a TUI.but let's continue to delude ourselves.
• refulgentis
  TL;DR, not from the article: Because Claude Code was a small team experiment done months after Claude Sonnet 3.7 had support for file editing; a bunch of companies had to fast follow; and the path of least resistance / collaborative work between PM and dev and design is copying, and companies are companies, they prefer money and competition over patiently waiting for X00 people to decide on a vision and deliver it.I think it's important to note this because it's not great. Either I'm having a fever dream, or, someone will GUI this stuff and it'll be a gamechanger.
• personjerry
  > TUIs are BackCitation needed?
• maptime
  [dead]
• wonderwhyer
  [dead]
• dostick
  TUIs are terrible UX. - Please select this text with your mouse. Are you scrolling where are you it’s all like legos.Bad UX has been normalised so far that people write whole articles set in this anti-world, “why TUIs are back”..The whole situation is like if we invented flying cars, but to get to the parking, we must ride horses because regular cars are not good enough now that we have flying ones, and horses are cheaper and you can ride them without a licence.
• Menu

  gorjusborg
  The real reason TUIs are back is not one reason, but a host of reasons.The biggest current reason is fashion. Tools like Claude Code did it, and while they actually had good reasons to run in the terminal, the tools' popularity and wildly different look, especially to non-terminal-native users became a signal of some positive sort.I don't believe that any of the rationale posed in the article is a popular reason developers are using.