I love claude code but am fatigued by the pure chat interface for all types of agent work. Even the GUIs these days are just better styling over the same chat interface.

I built tart (tartifacts) as a tiny way for agents to create and update persistent terminal dashboards instead of narrating everything at you.

A tart is basically:

- a manifest

- a script that fetches live state

- a script that renders it

Install: `uv tool install tartifacts`

Then tell your agent to use `tart --skill`.

Works nicely with tmux/herdr (agent chats in one pane, dashboards live in another).

Github - https://github.com/tg1482/tart

Some months ago I came across christ-cli on Reddit, a TUI that lets you read the Bible directly in your terminal. I loved the concept. I looked around for something similar for Muslims and found nothing, so I decided to build it myself.

The result is qari-cli, a terminal scripture library written in Rust. It has fourteen shelves: the Quran, Tawrat, Zabur, Injil, Tanakh and Greek NT, plus eight hadith books including Bukhari and Muslim. There's a three-column reader, search, and a pipe-friendly CLI, and it also does prayer times.

qari-cli: https://github.com/HyperZx2O/qari-cli
Inspired by christ-cli: https://github.com/whoisyurii/christ-cli

Tau is built for the same race as every other agent harness: being the one people trust with real, complex, multi-step workflows. But most harnesses stop at the tools. They run in the terminal and still treat it like a plain text log, just dumping text at you. They ignore everything the TUI ecosystem can do today. I didn't want that. When an agent is doing a lot on your behalf, you should be able to see what it's seeing and follow what it's thinking without leaving the terminal. So images the agent works with show up inline, as real pixels on terminals that support it (Kitty, iTerm2, Sixel) and as Unicode art everywhere else. When the model explains an architecture or a flow, it gets drawn as an actual diagram right in the reply instead of a wall of Mermaid source. It all runs on a custom React/Ink renderer, with sharp and sixel for images and grok-mermaid for diagrams. Modern terminals can do a lot, and an agent should use it.

https://github.com/AbdoKnbGit/tau

We just shipped a terminal for Linux, macOS and Windows. Apache-2.0, one file to install: https://starling.build/terminal.html

Speed. Ten workloads at steady state, matched fonts and verified grids, measured against the fastest terminal on each platform:
• Linux: 1.38x the ghostty nightly
• macOS: 1.28x ghostty
• Windows: 1.41x Windows Terminal

Efficiency, which matters more for TUIs. All of that on about half the CPU — 0.44x to 0.53x of the other terminal across the three platforms. Memory is flat no matter how much has scrolled past: on Windows we measure 73 MB against Windows Terminal’s 1,026 MB for identical work.

For full-screen apps specifically: alt screen is 1.06x ghostty on Linux and 1.87x Windows Terminal, and DOOM-Fire — which repaints every cell every frame — runs at ~1,600 fps on Linux.

Side-by-side videos, charts, and the raw per-leg data are on that page.

And you can build your own on the same widget. The terminal ships in our SDK, so a working terminal app is about twenty lines of Swift — emulator, PTY, scrollback, selection, fonts and glyph atlas all inside the widget:

import ExampleHost
import Flutter

let session = TerminalSession()
session.startShell()

runExampleApp(title: "Terminal", width: 940, height: 620) {
TerminalView(session: session)
}

Happy to answer questions.

I built Rove, a TUI for running coding agent CLIs.

One design choice I care about is making the UI disposable. The actual Claude Code, Codex, and shell sessions are hosted separately, so closing Rove or dropping an SSH connection does not stop the work. When you reopen it, the tasks and sessions are still there.

Each managed task also gets its own branch and worktree, so multiple agents do not have to share one checkout.

GitHub: https://github.com/Sma1lboy/rove

I would love feedback on the TUI, especially the navigation and how much session state should stay visible.

Full disclosure: this was built with Claude Code, not hand-written. I wanted to see what a first real "let the AI drive" project would actually look like, and picked something small and personal rather than anything serious. It ended up genuinely useful, which I wasn't expecting going in.

The problem it solves: I'd installed something like 40 terminal tools over the past year or so via Homebrew and could maybe name six of them from memory. `brew list` doesn't help — it's just names.

brew-launcher shows the same list but with what each tool actually does, its version, its size — and fuzzy search matches on the description too, so typing part of what a tool does finds it even if you can't remember its name. It's deliberately just a launcher, not another package manager — taproom and fzf-brew already do install/uninstall well.

A few things it grew along the way: categories and favorites, a details pane that's instant because it's precomputed rather than a live `brew info` call, presets that launch a group of tools together in one tmux session, color themes, mouse support. One zsh file, no daemon.

macOS + Linux. brew install ltdan-88/brew-launcher/brew-launcher

https://github.com/ltdan-88/brew-launcher

Would genuinely like feedback — both on whether the tool itself is useful, and honestly on how it reads that it was AI-built, since that's new territory for me too.

I am one the very rare who likes Claude Code TUI Design, and I don't like OpenCode for some reason.

What do you think about OpenCode as a terminal user interface ?

You can check it out here:

https://github.com/amsdias/Keet

Compatible with Windows, MacOS and Linux, pre built binaries available on the release page of the github repo, around 4MB.

• Multi-format support: MP3, FLAC, WAV, OGG, AAC/M4A, ALAC, AIFF

• Low CPU usage: <0.5% total system CPU (release mode)

• Synced lyrics: Embedded LRC lyrics + automatic fetching from LRCLIB (~3M songs), with adjustable sync offset

• Parametric EQ: Built-in presets (Flat, Bass Boost, Treble Boost, Vocal, Loudness) + can create custom JSON presets

• Audio effects: Reverb, chorus, delay with built-in environment presets + can create custom JSON presets

• Gapless playback: Sample-accurate track transitions with continuous audio stream

• ReplayGain: Loudness normalization with peak-based clipping prevention (--rg-mode track|album|off)

• Crossfade: Smooth equal-power crossfade between tracks (--crossfade)

• Pre/post-fader metering: Toggle between raw signal and volume-adjusted visualization

• Media controls: AirPods stalk controls, Bluetooth headphone buttons, keyboard media keys (macOS/Windows/Linux)

• Real-time visualizations: VU meter, horizontal/vertical spectrum analyzer synced to playback, toggleable bars/dots style

• Metadata display: Reads artist/title from ID3, Vorbis, and MP4 tags

• Format-colored icons: File type indicated by icon color (green=MP3, cyan=FLAC, yellow=WAV, etc.)

• Output device selection: --device selects by name, --list-devices enumerates

• Exclusive mode: Per-track sample rate matching, macOS hog mode for bit-perfect playback (--exclusive)

• Headphone crossfeed: Meier-style frequency-dependent crossfeed with three presets (Light/Medium/Strong)

• Balance control: Stereo balance with [/] keys (5% steps, -100 to +100)

• Clipping indicator: Persistent dot that turns red when signal exceeds 0dBFS, with peak safety limiter

• Smart audio processing: Automatic sample rate switching (macOS), Bluetooth detection, conditional resampling, seamless device switching

• Volume control: Adjustable 0-150% with per-sample gain

• Playlist features: Shuffle, repeat, recursive folder scanning, playlist view with search, M3U import/export, folder rescan, multiple source paths with deduplication

• Resume playback: Save and restore last session (track, position, volume, EQ, effects, crossfeed, balance, device, exclusive) automatically

• HQ resampler mode: Optional --quality flag for audiophile-grade resampling

• Resilient playback: Silently skips missing/corrupt files, recovers from device disconnection (including USB DAC unplug)

• Terminal-safe UI: Output adapts to terminal width, handles terminal resize gracefully

• Process stats: Lightweight CPU/memory monitoring via direct platform syscalls (toggle with I)

I got tired of chezmoi's templating complexity - I just wanted to see what changed in my configs and sync them easily. So I vibed in one evening doti, a TUI dotfiles manager in Rust.

I had an idea a long time ago to improve my config management experience, but I wanted something super simple and tailored to my needs, without tons of extra features. I wanted something that would just work, so I could keep my configs updated easily.

I used chezmoi for a while, but the workflow always felt a bit awkward. Every time I edited something, I had to re-add the file, remove it from chezmoi, or make sure I edited it the “correct” chezmoi way. Chezmoi does support workflows like edit, add, re-add, and merge, but that overhead was exactly what I was trying to avoid.

How it works: you keep a home/ directory in your git repo that mirrors your $HOME.
doti shows you what's synced, what differs, and what's missing - with inline diffs right in the terminal.

Key features:
- Copy-based sync (no symlinks) - apply, pull, or backup + apply
- Inline diff viewing between repo and system versions
- Untracked file browser with lazy-loaded directory tree
- Built-in secret scanning (AWS keys, GitHub tokens, API keys, etc.)
- Vim-style keybindings, tree view with collapsible dirs
- Built on Arch BTW

I mostly lurk on Reddit and never really post. Honestly, sharing this was a bit scary stepping out of my comfort zone. But I figured it's time to start putting my work out there and connecting with people. Would love to hear your thoughts or feedback.

GitHub: https://github.com/volcmen/doti

Hi, Everyone!

I've been spending way too much time jumping between Claude Code, Codex, OpenCode, and a bunch of other coding agents lately.

At some point, I realized I was spending almost as much time managing sessions, configs, and skills as actually using the agents lol.

Since I basically live in the terminal and love lazygit, I figured... why not build something similar for AI coding agents?

So I made lazyagents :)

It's a TUI written in Go that brings sessions, skills, usage, and agent configurations into one place. It supports Claude Code, Codex, Gemini CLI, OpenCode, and a few others.

The idea isn't to replace any of these tools. I just wanted a nicer way to work with all of them without constantly digging through directories and switching between terminals.

It's open source, still evolving, and there's a bunch of stuff I want to improve.

Anyway, figured some fellow terminal nerds might enjoy it!

Would love some feedback, especially on the UI, navigation, and overall experience. If you've got ideas for making it feel more at home in the terminal, I'm all ears.

GitHub: https://github.com/rogeriojunior31/lazyagents
Docs: https://rogeriojunior31.github.io/docs/lazyagents/

Hi,

I have been working for now some months on a custom tool that I used on a daily basis in order to get things done when working with agents.

I started this project because no agent orchestrator existed before.

Thurbox is a TUI but also has a very useful CLI that can help you setup the custom workflow you need.

Hardwork is handle by `tmux`, thurbox is a layer that build on top of that. Unlike concurrents we do not try to reimplement some kind of custom tmux-ish leading to tons of bugs.

I use this daily, but thurbox is still in v0.x.x version, I try to avoid breaking changes but some features might be removed or added...

Feel free to check it out: https://github.com/Thurbeen/thurbox

Website: https://thurbox.thurbeen.eu/

Hey everyone!

I wanted to share Limoni (https://github.com/thebanri/limoni), an open-source Terminal User Interface (TUI) engine written in pure Go.

When building data-heavy terminal tools or high-frequency dashboards in Go, developers often run into GC stutter or allocation bottlenecks. Limoni was designed from scratch to combine Go's concurrency model (goroutines and channels) with Rust-like raw rendering speed.

Key Highlights:

• Zero-Allocation Hot Path (0 B/op): Critical frame diffing and drawing loops produce zero heap allocations, completely eliminating GC lag during animations and heavy interactions.

• Sub-Microsecond Diffing: Uses a flat 1D contiguous cell grid that calculates dirty regions and emits minimal ANSI escape sequences in under 0.85 microseconds per frame.

• Virtual Viewport Paging: Easily renders and scrolls tables or lists with 1,000,000+ rows at 120+ FPS with zero off-screen memory overhead.

• 3D Mesh & Vector Graphics: Built-in software rasterizer supporting .obj, .stl, and .ply 3D models directly in your terminal with Gouraud and Lambertian shaders.

• Rich Widget Suite: Responsive Flexbox layouts, TreeView file explorer, live image previews (Kitty, Sixel, iTerm2, Half-block), fuzzy-search Command Palette (Ctrl+P), mouse draggable/resizable modals, and form controls.

• Elm Architecture & Bubble Tea Compatibility: Includes an Elm-style runtime (Init, Update, View) and a compatibility adapter for smooth Bubble Tea migrations.

• Cross-Platform & Remote: Native Linux (pure ioctl raw mode, no CGO), macOS, Windows ConPTY, WebAssembly (in-browser xterm.js), and multi-tenant SSH terminal server support.

You can install it via: go get github.com/thebanri/limoni

And test out the runnable showcase demos: go run ./examples/3d_viewer go run ./examples/treeview go run ./examples/dashboard

GitHub Repo: https://github.com/thebanri/limoni

Website: https://limoni-website.vercel.app/

I would love to hear your feedback, thoughts on the architecture, and ideas for new widgets!

here’s a demo for my project of putting Claude Code on DS terminal . fully open source
https://github.com/logancarrillo/ds-claude-terminal

from quiet a time i watching chat-gpt's animation it shows during the period betwen image generation input and output...

it was intresting to watch - then when i zoom abit i found it's are circles getting small and big to generate patterns... i try find same in ascii characters... all i found was three dots one bigger than another... later i used them to create shades and build a rendering engine arround it to make more kind of animation in same paradigm...

i say it: DIVAE — Dot-Induced Virtual Art Engine

it's in cpp and support 24bit colors, no external library not even sys/ioctl or unistd.h... it;s totaly bare engine

feel free to feedback, github link of repo is here if you want to use it freely:

https://github.com/intriXlabs/DIVAE

Okay okay. So obviously not much to look at. But hey, it's a proof of concept written in a TUI framework that didn't exist three days ago on a platform that didn't exist a month and a half ago. Let's see what I can do with the next iteration.

I'm a broke developer always looking for different ai agents or ai models to use free quota, so I always switch between codex (I have free 12 month go plan), groq (free api), antigravity(google ai pro which I gets from sim recharge). so I switch between ai agents.

and settle on pi for now, but faced a issue that some skill I had on the opencode but not on pi. and went to look for marketplaces for skills, there are some but you'll have to manually maintain it.

so I took matter into my own hand and build a simple tui for it. to sync the skills with symlinks with different ai agents with one place store.

currently maintaining registry as a single json file. but if it hopefully grows to big, nevermind, we'll think about later.

so yeah here's the repo: https://github.com/Nitesh000/skmp

check it out if you're free or need something like this. and hopefully it's solving an issue.

¡Buenas! Recientemente me estuve metiendo al mundo de la programación y me llamó la atención las TUI. Sé un poco de C, C++ y Python, así que me surgió la duda: ¿cuál es la mejor forma de hacerlas, qué lenguajes se usan y qué recomendaciones hay para hacerlas bonitas? Se agradecería cualquier tipo de ayuda.

Hi everyone!

I've been working on Vinux — my own AI model with a lightweight terminal-based user interface (TUI) built right into it. And this is my first project!

Key Features:

• Custom AI model implementation.

• TUI built using Python and the Textual framework.

• Fast streaming responses in the terminal.

• Fully open-source.

Why I'm building this:

Honestly, I was just super curious about AI and TUI development, and had plenty of free time this summer, so I decided to build something cool for myself.

https://github.com/winowne/Vinux

Which feature should I add next: context history saving or custom color themes for the TUI?

I'd love to hear your thoughts and suggestions!

The one that looked best is rmpc, but when I installed it I realized it's just a frontend to mpd, and after looking up mpd I don't understand why I need that, why do I need a system level music server/service with network protocol to control it. I don't understand usecase of that. Thus I'm looking for pure user side self-contained TUI app with no unnecessary server features but with actual user-facing features related to browsing music library instead.

Wrote a brief post on my reasoning for writing a new tmux plugin.

hi guys, i really like simplistic games and i had an ambition to write a terminal snake game without using ai coding, so i did that.

later, while waiting for claude code to complete a prompt at my day job, i got bored and started playing my snake game in the adjacent terminal pane. that’s when lightning struck. instead of losing another 20 minutes to doomscrolling, i just played a quick round of snake and jumped right back into my coding project.

so i made terminalika. it is a standalone terminal native game launcher that contains 5 games rn, 6 is on the way.

here’s the twist: when your ai agent finishes its task, terminalika automatically pauses and exits the game so you can instantly switch back to work.

but of course, that's totally optional. you can also just use it as a chill terminal game launcher whenever you want.

it’s also available as a native plugin for pi and opencode, so you don’t even need a side pane if you use them.

here is some links about terminalika:
website: https://terminalika.dev

source code: https://github.com/terminalika/terminalika

discord: https://discord.gg/VptcJvm7Fk

pi plugin: https://pi.dev/packages/@terminalika/pi-play

opencode plugin: https://terminalika.dev/opencode/

check it out and let me know how it fits into your workflow.

a TUI that manages dev VMs for coding agents. Attach, create, resize, and destroy without leaving it. Sessions park themselves when the agent goes quiet and resume in about 20 seconds.

https://github.com/kerem-kaynak/pier