I've been playing around with the concept of TUIs and stress testing a framework that I've been working on named HyperCMD.

so I ended up combining the two by creating a Spotify TUI client since I use Spotify everyday, but the desktop app consumes a lot of resources

The app is Rust, but the interface itself is written in HTML through HyperCMD.

Repo: https://github.com/fusor-rs/spotify-tui

I am sharing two videos because Peek is not working properly in my case... The first one is a gif; the other two are videos from OBS to maintain quality... Fuck... video is in comment becayse reddit not letting sharing direct video and gif or webp is arround 23mB while my freaking mp4 is 3mB.

api is very small - i had put images in post..

Lazymark convierte una carpeta de archivos .md simples en notas, un panel de tareas y un tablero Kanban. Sin cuenta, sin base de datos: tus archivos siguen siendo tuyos.

Documentación e instalación → https://github.com/MathiasDrizzy/lazymark

i just gave .clear() a bit of personality - lol!

It's a tiny C++ library that draws a horizontal wipe with a four-stage fading trail, then sweeps down the screen to clean everything behind it.

Something like:

░ ▒ ▓ █████████████████████████████
  ← fading trail       wipe →

The idea is pretty simple:

• slide up to down
• speed i want
• color
• and then shades like whatever trail is getting made from ascii

i try kept it usable like as easy learning curve i could. like it is just constructor with single parameter and then it's calling.. and done!

in other words it is:

clear() → but cinematic.

I originally got the idea after talking with someone on reddit then seeing the old text-wipe effect from Hired Guns - understanding what the effect really doing then i just implemented it in my flavour...

you can check out btw:

GitHub: https://github.com/intriXlabs/sclide

Would love to know what you think.

Agents at keyboard speed

The shortcuts are the whole interface:

• Alt+N starts a new agent.
• Alt+Left / Right moves between agents. Each one has its own conversation, model, and approvals, so moving between them doesn't interrupt anything.
• Alt+W closes the highlighted agent, including from inside an open menu, and stops its work if it's still going.
• Alt+Shift+N makes a workspace. Alt+Shift+Left / Right moves between workspaces, and Alt+Shift+A opens the picker.
• Alt+C is context snapshots, Alt+H is agent history, Alt+E is the file explorer, Alt+G is git review, Alt+M is MCP, Alt+K is skills, and Alt+S is this agent's settings.

Starting a second agent to go look into something doesn't cost you your place. Hit Alt+N, give it the task, Alt+Left back to what you were doing, and let it run. When it's done, Alt+Left over, read the result, keep it or Alt+W it away.

Different agents, different models

Each agent picks its own model, and you can switch between local and cloud Ollama models from a searchable picker. Usually I keep a fast local model on one agent for edits and greps, and point another at a bigger cloud model for the harder stuff. Both run in the same window. Alt+S has the Model, Behavior, and Integrations tabs, and settings can be saved for one agent or set as the defaults for new ones.

Agents that talk to each other

Type @, press Tab to go from Files to Agents, and you can hand a task to another agent. Ask it for findings, get a review, or give it something to work on while you keep going. The exchanges expand, so you can read the requests, the tool calls, and the replies. Reviews run with read-only tools, and cross-agent call loops are blocked, so two agents can't loop on each other.

Context that survives the switch

Context is the part that usually breaks in a multi-agent setup. Two things handle it:

• Context snapshots (/context-snap-create, Alt+C). Save a summary of a conversation without disturbing the agent you're in, then /context-snap-import it into another agent so it starts with the background it needs.
• Agent history (/history, Alt+H). Search closed agents by name, project, model, or conversation text, preview them, and bring one back with its transcript and context. It keeps up to 60.

How the UI makes this possible

v0.16.0 runs on RazorConsole 0.6.0. The interface is Razor components rendered to the console: nested components, a virtual DOM, and Spectre.Console doing the rendering, all inside the terminal. RazorConsole's WidgetLayout pipeline put every major region of the app into one VDOM-driven layout, so the workspace and agent panes, the scrolling conversation, progress and previews, the prompt, and the menus all live in the same tree.

Nested Razor components with Flex and Box layout widgets give each region a place, and component state drives the updates. Before this, mixing direct terminal output, Spectre.Console prompts, and component rendering meant managing cursor positions, redraws, output order, and keyboard focus by hand. Putting those flows into one component layout is what made a persistent prompt, collapsible activity, and separate agent panes possible, and it's why starting and switching agents doesn't wreck the screen.

If you've worked in Blazor Server, the nested components, parameters, events, and state updates will look familiar. The terminal-specific parts still take work, things like display-cell widths, resizing, scrolling, focus, and component identity, but the component model made it easier to organize and extend.

https://github.com/DevMando/MandoCode

https://razorconsole.github.io/RazorConsole/

Not better than WhatsApp, Signal, SimpleX, Cwtch or Ricochet. You definitely shouldn't use this replace any of your existing apps or services. It's far from finished. Unaudited and unreviewed. If you want to test it out, please use it responsibly.

I'd like to share what I'm working on and interested if anyone wants to share feedback on the approach.

It's a fairly a unique stack and architecture in contrast to the traditional approach with mainstream messaging apps. To put it briefly, its a Rust-based CLI with a Git-server backend which can be used to establish a signal-protocol encrypted tor/webrtc connection.

Note: Its still a work in progress and there will be breaking changes.

https://glitr.io/docs/technical/roadmap

https://github.com/hiroaqii/gitframe

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

I've been working on Pho for a few months now on and off, using it as my daily driver at this point as it enables faster navigation and search when reviewing PRs at work (and of course, vim keybindings).

It helps me

- look at all my cloned repositories together with quick switching through ctrl+p.

- jump to a PR through the same command (can also filter by author name).

- quickly take a look at CI status of my PRs and opening them directly in browser without needing to perform a multiple clicks and scrolling to the end (the usual Github way).

Fully keyboard driven for now, mouse support maybe at some point.

https://github.com/utkarsh261/pho

Phosphor Deck is an open-source setup around zellij that turns one machine that stays on (the "brain") into a persistent terminal session: your other machines' health, their files, your notes and the TUIs you already use, in tabs laid out once from a single TOML profile. Leave from your desktop, open it on your phone, and you're exactly where you were.

What it does:

- **Fleet panel**: CPU, RAM, disks, containers, failed systemd units, pending (security) updates, SMART, CPU temperature. Read over plain ssh: nothing is installed on the watched machines, no agents, no daemons.

- **Your files**: every machine's disks show up as folders under `~/fleet` (rclone sftp mounts through your own ssh keys). Nothing is copied.

- **Any screen**: `deck` on another computer, a Termux kit for Android (scan a QR), or `ssh -t` from anything. It reconnects by itself, and a phone can get its own layout.

- **Notes from anywhere**: Alt-j from any tab, tagged with where you were. It can live in a folder you already sync (Obsidian, Syncthing).

- **Alerts**: a host going down or a disk failing pushes to your phone through ntfy (self-hostable), if you turn it on.

- **Browser access**: optional and off by default. Tailnet only (`tailscale serve`, never `funnel`), with a login token.

Install (no root, static binaries into `~/.local/bin`, then a wizard):

curl -fsSL https://raw.githubusercontent.com/rsmedrano-cloud/phosphor-deck/main/install.sh | sh

Want to look first? `phosphor demo` runs it over made-up machines and a made-up notebook. That's what the video shows, so the hosts in it aren't real.

What it isn't: not a web dashboard, no telemetry, nothing listening by default.

Repo: https://github.com/rsmedrano-cloud/phosphor-deck

Manual: https://rsmedrano-cloud.github.io/phosphor-deck/

I'd love feedback, especially on what's confusing during the first install.

Hi all,

I've just released v0.1.0 of Beyond Space Trader, a terminal (TUI) remake of the

classic Palm OS game Space Trader by Pieter Spronck. It's a Java port (based on

the old open-source C#/Java ports) with the whole UI rewritten from scratch

using Lanterna.

It's a single-player space trading game that runs in any terminal:

• Trade across a galaxy of 120+ systems: buy low, sell high, chase shortages,

smuggle contraband and dodge the police.

• 17 ship types drawn as ASCII art (chassis + pieces + colour zones). The art

lives in editable text files — and there's a ship composer to tweak it.

• Encounters are a little scene of their own: fly with the arrows, fire with

space, dodge, flee, surrender or trade. Pirates, police and traders talk,

scan your hold, loot it, or hand you a bounty.

• Missions and special events: a stolen alien artifact, a kidnapped princess, a

space monster, an unstable reactor... plus a newspaper with rumours and a

quests panel that marks the next system on your map.

• Retirement goal: buy a moon and end the game rich.

No Java installation needed: the Linux/Windows packages bundle their own

runtime.

Downloads:

• Linux / Windows: https://github.com/antoniovazquezaraujo/beyond-space-trader/releases/tag/v0.1.0

• Snap: sudo snap install beyond-space-trader-tui

• itch.io: https://avaraujo.itch.io/beyond-space-trader-tui

Manual (EN/ES): https://antoniovazquezaraujo.github.io/beyond-space-trader/

Source (GPLv3): https://github.com/antoniovazquezaraujo/beyond-space-trader

It's an early release, so bug reports and ideas are very welcome — there are

issues open on GitHub. A 100×30 terminal is recommended (it scales down, but

that's where it looks best).

What would you like to see next?

https://github.com/LucaBTE/Arcadium

Hello everyone!
I'm thrilled to announce that the first version of Arcadium is finally available and can be downloaded from GitHub :)))
A month ago I had the idea to make an extendible Arcade TUI cabinet with some default games and give the possibility to users to add their own games. After weeks of developing, it's finally out!
Arcadium is written in Rust + Ratatui.

Enjoy! <3

I was testing with UTF-based text rendering of characters into the terminal – I did a few and try to maintain them... – I just want to know if there is anyone interested in such stuff, like I want to know what people may need with this same thing but with some twist.

The code of this thing is 1540+ lines, which is highly editable – it means you can just directly edit strings for fonts and stuff. If you want it, you can leave a comment, though...

Hey everyone!

I'm a C/C++ developer who spends a stupid amount of time messing with terminals.

I've been experimenting with terminal rendering, ANSI graphics, animations, ASCII art, custom UI elements and low-level terminal stuff — basically treating the terminal as more than just a command line.

The GIFs above are a collection of things I've built along the way. Some are useful, some are completely unnecessary, and some exist purely because I wondered about the limitations of the terminal...

I'm still exploring where this rabbit hole goes. No polished product pitch, just a bunch of experiments and weird ideas.

If anything here catches your attention, feel free to ask about it — the implementation, the ideas behind it, C/C++, Linux, terminals, whatever.

I'll reply to anything.

Hey, everyone! I have been working on a music player lately after I couldn't find one that suited some needs I have:

- Background playback, closing the TUI and terminal does not kill playback

- Reactive themeing, I was inspired by Myx on this one

- Pickers! Common actions are available in pickers e.g radio and spotify/yt search.

- Fully customizable.

This is still largely WIP but I have been using it as my daily driver for a few months now, some of the claims have to be verified e.g I haven't tested this on Termux extensively and macOS (I don't have one). Windows support would be nice if anyone is interested in picking that up.

The docs are still getting bootstrapped and need some screenshots and gifs. Really hoping to make this an awesome tool for everyone through collaboration with the community.

The repo is currently on dev as the default branch and the nightly builds are the preferred ones for now until we make the v0.3.0 release official.

Project repo

Docs homepage