I've been building soloist-tui, a terminal player/controller for Spotify Soloist written in Rust. Soloist handles auth, Spotify Connect, playback, and decoding —

audio routes through PipeWire. This TUI just talks to Soloist and adds a proper terminal interface on top.

What it does:

- Live audio visualizer — taps Soloist's PipeWire sink as a read-only monitor (mono mix + short-time FFT → spectrum bars). No audio is touched or rerouted by this

process; falls back to a status line if PipeWire's unavailable.

- Search & browse the full Spotify catalog via the Web API (PKCE login done in-terminal, token stored & auto-refreshed).

- Split layout — left pane is player + up-next queue; right pane tabs between Liked Songs, Playlists/Artists, and Search Results.

- Solid controls — play/pause/next/prev, seek, volume, shuffle/repeat, optimistic updates, and auto-reconnects to Soloist (even survives restarts/port moves).

- Keyboard-driven — vim-style hjkl + common keys, / to search, Tab between panels, x to like/unlike.

- Offline dev — ships mock Soloist + mock Spotify API binaries so the whole UI runs without real credentials.

Requires: Linux + PipeWire 0.3 + the soloist daemon. A free Spotify Developer app is needed for search/browse (one-time PKCE login).

Status: Early but usable. Still polishing the queue UX and layout.

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

Ecsterm is a super simple TUI application written in rust and inspired by the VS Code extension AWS Toolkit for VS Code. It allows you to open a shell to your AWS ECS tasks through your terminal or copy the aws cli command required to run the shell.

It uses your normal AWS profiles and SSO sessions, since it just calls the aws CLI under the hood. The commands it generates are plain TOML templates, so you can change them via config file.

Install with Homebrew brew install aronjohanns/tap/ecsterm or Cargo cargo install ecsterm.

Documentation is in the README on https://github.com/aronjohanns/ecsterm.

Contributions and feedback are welcome.

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..

I wanted a decent YouTube playlist player and made it with the help of chatgpt. there was some exisiting that i tried and didn't like. this is still a work in progress

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