I noticed people who manifest resistance to change regarding adoption of AI have impulsive reactions on Reddit (and similar forums) by naming your work slop if any vibe coding was involved or finding any trace of relationship between AI and your code. For me vibe coding becomes slowly synonym of slop and the other way around due to such feedback.
Same time I wonder how much affordability (precisely the non-affordability) of the subscriptions creates a vicious cycle. I think with 20$/month you cannot get good insight of the scale agents can help you to solve complex problems. If you do not try and learn by doing you cannot have a good evaluation and healthy opinion about the added value, you may end up with a random negative opinion and will end up just generating hate.
Wonder why people fail to see the creative ideas behind 'vibe coded' projects. At the end a great idea written with help of AI can be still cleaned up if it really has added value.

Myself I am extremely irritated by "honest": it is used way to often and as you know it is pointless. Wonder how and why...

(Words, phrases, anything that is recurrent and extremely irritating)

How about naming them "Claude Cacophony"

Have a look at the demos on github discussions page. The videos should present enough well the capabilities of the new terminal emulator.

Modern applications can produce incredibly rich information, yet terminal applications are still largely limited to a character grid.

For scientific computing, data analysis, engineering, monitoring, and development, this often means switching between the terminal and another application just to see a plot, diagram, image, or structured result.

Termolution is a new community exploring whether the terminal can evolve beyond that limitation.

The goal is to discuss ideas around richer terminal content, visualization, interaction, protocols, and workflows — while preserving the things that make terminal-based computing powerful: composability, scripting, remote access, and keyboard-driven workflows.

We're interested in questions like:

• Should plots and visualizations be first-class terminal output?
• Can rich content coexist with traditional text output?
• Could applications communicate semantic information instead of only characters?
• How could terminals support interactive visualization without becoming traditional GUIs?

If you're interested in the intersection of visualization, computing, and terminal workflows, we'd love to hear your ideas.

👉 r/Termolution**:** https://np.reddit.com/r/Termolution/

A lot of scientific computing still has a very terminal-centric workflow:

run simulation → inspect output → generate data → plot → open another application

The terminal is excellent for running experiments, pipelines, scripts, remote jobs, and inspecting results. But when the output becomes visual or structured, we usually have to leave that workflow.

I'm interested in whether the terminal itself could evolve without losing the things that make CLI workflows useful.

For example, imagine:

• A simulation producing an interactive plot directly in the terminal
• Matrices and large tables rendered in a navigable form
• Images and scientific diagrams displayed inline
• Logs with structured, collapsible sections
• Interactive parameter/result exploration
• Rich output that can still be piped, redirected, logged, or accessed over SSH
• Textual fallbacks for environments that don't support rich rendering

The interesting question isn't "should the terminal become a GUI?"

It's:

Can we make terminal applications capable of representing scientific information in its natural form, while retaining the composability and simplicity of CLI workflows?

I've started r/Termolution to explore this broader question: what should the application ↔ terminal interface look like if we designed it today?

I'm also building Yetty as a reference implementation for experimenting with some of these ideas.

I'm particularly interested in the scientific-computing perspective:

Where does your current terminal workflow force you to switch to another application, and would eliminating that context switch actually be useful?

Gemini CLI is pushing AI coding further into the terminal, but we're still using an interface fundamentally designed around a stream of text.

An AI coding agent can understand codebases, inspect files, run commands, analyze logs, generate diffs, and work with structured information. Yet much of that interaction still ends up as plain terminal output.

What if the terminal itself evolved to take advantage of what AI coding agents can do?

Imagine:

• Rich and structured output
• Collapsible command results
• Interactive diffs and logs
• Tables, graphs and visualizations
• Semantic rather than purely textual output
• Better agent ↔ human interaction
• New protocols designed for modern terminal applications
• A terminal that can understand more than just characters and escape sequences

I created r/Termolution to explore these ideas.

It's not about a particular terminal emulator. The goal is to discuss and experiment with what the terminal should become as AI agents like Gemini CLI become a fundamental part of software development.

If you use Gemini CLI, what do you wish your terminal could do that it can't do today?

👉 r/Termolution**:** https://www.reddit.com/r/Termolution/

C is still one of the languages most closely associated with terminals: shells, compilers, debuggers, system tools, TUI applications, editors, monitoring tools, and countless Unix utilities.

Yet the interface those programs use to communicate with a terminal is still remarkably primitive.

A C program essentially writes bytes to a stream and emits escape sequences. The terminal interprets those bytes and turns them into characters and a grid of cells.

That model is incredibly durable—but is it still the right abstraction?

Imagine a modern terminal API/protocol where a C program could natively communicate things like:

• Structured data rather than serialized text
• Tables and trees
• Images and graphics
• Interactive widgets
• Hyperlinks and semantic regions
• Rich diagnostics and source locations
• Progress/status information
• Machine-readable output alongside human-readable output
• Capability negotiation between application and terminal

This could potentially be designed as a low-level, language-independent protocol, with a small C API making it easy for existing Unix/C applications to use.

The interesting part, to me, isn't making terminals prettier. It's reconsidering the fundamental application ↔ terminal interface.

What would a terminal protocol designed from scratch today look like?

I've started r/Termolution to explore this question with people interested in the low-level side of terminal computing.

👉 r/Termolution**:** https://www.reddit.com/r/Termolution/

For C programmers specifically: if you could redesign the terminal API from scratch, what would you change first?

Gemini CLI is pushing AI coding further into the terminal, but we're still using an interface fundamentally designed around a stream of text.

An AI coding agent can understand codebases, inspect files, run commands, analyze logs, generate diffs, and work with structured information. Yet much of that interaction still ends up as plain terminal output.

What if the terminal itself evolved to take advantage of what AI coding agents can do?

Imagine:

• Rich and structured output
• Collapsible command results
• Interactive diffs and logs
• Tables, graphs and visualizations
• Semantic rather than purely textual output
• Better agent ↔ human interaction
• New protocols designed for modern terminal applications
• A terminal that can understand more than just characters and escape sequences

I created r/Termolution to explore these ideas.

It's not about a particular terminal emulator. The goal is to discuss and experiment with what the terminal should become as AI agents like Gemini CLI become a fundamental part of software development.

If you use Gemini CLI, what do you wish your terminal could do that it can't do today?

👉 r/Termolution**:** https://www.reddit.com/r/Termolution/

ChatGPT/Codex and other AI coding agents are becoming increasingly capable, but they still interact with developers largely through an interface designed decades ago: the terminal.

An AI coding agent can generate structured information, inspect large codebases, run commands, analyze logs, produce diffs, and reason about complex workflows — yet much of that ultimately gets flattened into a stream of text.

It feels like we're leaving a lot on the table.

What would a terminal designed specifically for AI-assisted development look like?

Things like:

• Rich and structured output
• Interactive/collapsible command results
• Better visualization of diffs, logs and data
• Semantic rather than purely textual output
• Richer agent ↔ human interaction
• New terminal protocols designed for modern applications
• Better ways for agents to communicate context and intent

I created r/Termolution to explore these ideas and discuss what the next generation of terminal emulators could look like.

The goal isn't to promote a particular terminal. It's to bring together developers who think the terminal can—and should—evolve.

👉 r/Termolution**:** https://www.reddit.com/r/Termolution/

If you're working with ChatGPT/Codex or other coding agents: what do you wish your terminal could do that it can't do today?

Hi guys! I just created a new subreddit to discuss ideas/projects related to the potential evolution of the terminal emulator: r/termolution (terminal evolution). It does not intend to compete with this subreddit, obviously, but some of you may be interested in how workflows could be improved by improving protocols, rendering etc.

Hi guys! I just created a new subreddit to discuss ideas/projects related to the potential evolution of the terminal emulator: r/termolution (terminal evolution). It does not intend to compete with this subreddit, obviously, but some of you may be interested in how workflows could be improved by improving protocols, rendering etc.

Hi, happy to present to the community the challenging work and solution for the objective we had: Build an OS like environment that feels like a UNIX environment on top of webasm, where apps can run multi-process, multi-threaded. For several reasons we did not want to use WASI, instead we decided to work against FreeBSD like libc. There is lot of story to be said, in case there is interest. The tool was written for the yetty terminal app (https://github.com/zokrezyl/yetty), so that simple programs can be written in WASM and run in any environment where yetty runs: https://github.com/zokrezyl/yos. The intention is also to embedd yos into yetty, so that the user can run plugins inside the terminal.

Are you using Artificial Intelligence in your daily coding activity?

Have been implementing the last two years in my spare time Yetty terminal. It is the result of decades of observations, frustrations, imagination and bunch of other 'tions'. Among others the thought was, why do I need to leave the terminal, thus focus, to just view a pdf file, a plot, a CAD drawing, an animation etc. Or search for alternatives on a different platform for a pdf viewer or svg viewer. Or find even more complicated workarrounds when I login to a remote that does not have graphical tools, but I could render stuff on my local terminal remotely. That is Yetty: Am very curious about your opinion. Features are endless:
* you can render UI, rich text with shapes using SDF vector graphics and MSDF fonts
* we implemented a remote dawn rendering, thus you can remotely render to a virtual Dawn Webgpu surface
* we implemented an efficient remote rendering also for IMGUI.

Github: https://github.com/zokrezyl/yetty
Demo: https://yetty.dev

Hope you enjoy it

Hi, while I have difficulties to find a good motto for the work I have been taking care the last 2 years, but with ideas I have been collecting for decades, Yetty itself in in early beta version.

Born from frustrations related to constant context switch and Ideas I gathered over the last few decades. Why should I switch to another app just to view a pdf file, see the plot of a complex math function or audio buffer or a sequence diagram of a complex workflow. All this even with a remote connection to your home server or a server in the cloude. All these are now in yetty. Please do both yourself and me a favour and have a look at it. Your opinion would be more than helpfull to drive the future of Yetty. You have a live demo at https://yetty.dev. The demo gives you an idea of what you can do with YETTY. The Ygreeter app is started automatically when the terminal is started. The source code lives at https://github.com/zokrezyl/yetty . Thank you

PS: it uses extensively Webgpu

Have been working the last good couple of months on a new terminal. Born from frustrations related to constant context switch and Ideas I gathered over the last few decades. Why should I switch to another app just to view a pdf file, see the plot of a complex math function or audio buffer or a sequence diagram of a complex workflow. All these are now in yetty. Please do both yourself and me a favour and have a look at it. Your opinion would be more than helpfull to drive the future of Yetty. You have a live demo at https://yetty.dev and source code at https://github.com/zokrezyl/yetty . Thank you