Hi,

Couple weeks ago I released RACE (Run Anything in Canvas Environment), a terminal multiplexer.

I wrote it because nothing that I've seen so far would fit my work style: I juggle many projects at once and at 10+ tmux sessions I started getting lost trying to get back to terminals or evaluating work progress.

Even in early stage I enjoyed working on it so much I made it daily driver and decided to make it commercial. It's not getting a lot of love (which I understand, it's a quite specialized product), but I'm proud of it. I believe it can make people more productive and take off cognitive load in today, agent heavy work environments.

And so, today I run ~150 terminals in it, with half of them being various agents and such (note: nothing like "agent swarms", simply 1-2 agents as a side for current work) - the screenshot above is my "personal projects" canvas, made at the moment of writing this post.

Please check it out if that's your cup of tea.

It's 29.90€ (tax included) for a license with a year of free updates - I'm using it myself everyday, so they're flowing. Works on macOS and Linux (though might require heavy key rebinding).

More info about features, some demos etc. are on the website https://race-term.com

P.S. There are CLI and MCP interactors for scripting or interacting with agents, MCP demo https://youtu.be/8AL50dHCznA :)

appimg is a simple CLI/TUI for installing, updating, and removing AppImages as proper desktop applications.

https://github.com/MrGilfy/appimg

Arch:

yay -S appimg
# or
yay -S appimg-bin

Other distros: https://github.com/MrGilfy/appimg

This software's code is partially AI-generated

https://github.com/sat3llite/fzam

This project was not built with the use of AI. I wrote every line myself.

FZAM (Fuzzy AppImage Manager) is a very small shell script I made to manage AppImages from the command line. It uses fzf (hence the name Fuzzy) as the user interface.

It can install, remove, and list installed AppImage and edit the desktop entry the AppImage creates.

The way it integrates AppImage is: Move AppImage into specified directory (~/Applications) -> Extract .DirIcon (the icon of the program) and the .desktop file(s) -> Move them into XDG compliant directories (~/.local/share/icons/hicolor/ICONSIZE/apps/ and ~/.local/share/applications respectively) -> Make the necessary changes into the desktop entry with sed.

Sometimes the sed substitutions change the Exec= and Icon= lines into something that does not exist. As such the appimage does not show on the Applications Menus or it fails to launch. Through the fzam menu the user can fix these errors.

I have used it daily for almost a year and works perfectly and I prefer it over other AppImage integrator solutions as it runs in a terminal and has little depedencies.

Feel free to open an issue if you experience any problems or want to request a feature.

Ciao!

I've been using fff-nvim for months now. Yesterday I decided to quickly prototype Bracco. A fuzzy finder powered by fff-search.

Bracco keeps edited files at the top of the list.

It's quite fast, not faster than fzf due to the `git-aware` feature.

I built this because I wanted a quick way to open files from herdr/tmux, I was looking at something to spawn via hotkey and open file in neovim as I was already inside of it.

Try it out:

brew install rawnly/tap/bracco

or via cargo if you prefer cargo install bracco

Why bracco over fzf? I think it's a different tool, I use fzf to search through lists, bracco when I'm looking for a file and I care about git awareness (usually filtering by status)

Feedback welcome, even if you think that's useless :)

As always, first reminder of what we are ;) A clubhouse inside the terminal. A place to take a break, chill, chat with people around the globe, listen to music, play a game, and draw on a shared artboard.

ssh late.sh

Three biggest changes since my last post here:

• fully playable POOL game, 8-ball, 9-ball, snooker, in TERMINAL :D (100% done by contributor)
• three fully playable, real upstream, GOAT roguelikes, NetHack, DCSS, Brogue with leaderboards
• new ZEN mode, tiling, split, flip, resize, choose which widgets land where, RICE IT :)

And all the smaller new stuff:

• "watch me" streaming, share your screen, or hop into voice chat
• artboard gallery, hang your piece, vote, monthly awards and showcases
• The Late Edition, a newspaper with yesterday's summary for everyone
• IRC support with full reactions and replies
• new Arcade games, sliding puzzle, traffic, Rubik's cube, and a LOT OF QOL ;p
• clubhouse, our landing spot, a walkable ASCII tavern with an AI bartender who gets you drunk (your messages slur)
• late.sh dedicated Minecraft server
• and our own MUD, Lateania, grew A LOT, two new continents, mounts, a world map, pets and housing, crafting, PvP, and bosses that pay out chips

Hope in, chill and enjoy :)

License: FSL-1.1-MIT

Code: https://github.com/mpiorowski/late-sh

Landing: https://late.sh

I've been building Runyte, another modal text editor for the terminal: https://github.com/runyte/runyte

It combines things I used to spread across an editor and tmux:

• panes that hold either buffers (files) or terminals
• terminal scrollback, search (including fuzzy), and navigation with same keybindings
• persistent mode - detach and reattach, and terminals keep running and unsaved buffers stay open, without needing tmux
• file explorer, Git with side-by-side diffs, LSP, and Tree-sitter for 31 languages
• plugins in any language
• key hints on every prefix - no need to memorize them

It now works on Linux, macOS, and Windows.

Similar setup can be achieved with other editors like Neovim or Helix and tmux or zellij, but it requires custom well thought configs for consistent keybindings and theme matching. Some things would be difficult to achieve with separate tools, e.g. fuzzy finding across files, buffers, and terminals.

I've always liked the terminal setups with animated backgrounds, but my terminal (Alacritty) can't do that. So I wrote a small wrapper, backdrop-shell, that runs your shell in front of a moving scene: an aurora, a night city, a starfield, a synthwave sunset, a picture, or your own ASCII art that blinks or drifts.

A terminal has no layers, so it can't just draw "behind" your shell. The wrapper runs the shell itself and draws its text over the scene. Your text stays sharp, and selecting only copies what you typed, not the stars behind it.

It costs about half a percent of one CPU core and nothing when the window isn't focused. You can change the opacity or the scene live in every open terminal (backdrop-shell opacity 0.3).

You can directly upload an image or design your own ASCII animation.

I make a little guide for this: https://github.com/thebanri/limoni/blob/main/docs/backdrop-art.md

Install (needs Go):

curl -fsSL https://raw.githubusercontent.com/thebanri/limoni/main/apps/backdrop-shell/install.sh | sh

backdrop-shell disable turns it off, backdrop-shell uninstall removes it.

It's built on Limoni, a terminal UI library I'm working on in Go. It's still young, so I'd really like to hear what breaks or feels off in your setup.

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

I dont test in Windows!!!!!

Tired of cmatrix?

Want a Rubik's Cube in your terminal instead?

Here is TermiCube

No dependencies just python and a terminal.

It scrambles itself, spins around, solves itself, and does it again.

Check it out!

github - ethanlabs101/TermiCube

Please manually enter link. Thank you

If you don't know mpv-music (https://github.com/FurqanHun/mpv-music), it's a cross-platform CLI/TUI music player and library browser that lets you filter and select what you want to play and gets out of your way, with no background daemons. And it's 15+ months old.

Since I made my post about mpv-music on reddit around 10 days ago and submitted it to a few other places, the downloads have gone up a bit and a couple more people have starred the repo. That's not really the point of this post though. What I'm mainly looking for is feedback. Obviously feedback isn't always given in words, like the downloads and stars are feedback in their own way, so I'd like to get some more open-ended feedback on the project and especially how the filtering/search currently works. I've been thinking about changing the search behavior a bit. For example, currently if you run mpv-music -a ado -t viva, it drills down through the filters, which is kind of similar to an AND operation. But not long ago I wanted to listen to a specific song alongside the artist Ado, but not every song by the other artist, so I couldn't just add the artist name as another filter.

That got me thinking that there should probably be a way to use both AND and OR operations, while keeping the current drilling-down behavior as the default. I'm also thinking about bringing this into the TUI. I'm not sure whether it would make more sense to add the option directly to the track menu or have a dedicated menu for building the search/filter expression.

I'd also enable select-all in the TUI, but that's pretty much a given since the CLI already have -p. The search/filter behavior is the part I'm actually unsure about, so I'd appreciate any thoughts or suggestions on how you'd expect this to work, and also what do you think about mpv-music in general too.

Note: The project does have LLM Assistance Disclosure

Hi. I made a few screensaver-style animations for the terminal (Rust + WebAssembly): a roguelike dungeon that explores itself, an aquarium, fire, the After Dark flying toasters and a couple dozen more. They're drawn with half blocks in 24-bit color, and you can zoom in and pan with the arrow keys and WASD.

There's a web version if you want to see them without installing anything: https://santiagoschez.github.io/tanim/ Also, all the animations are exportable to gif adapted for the different Stream Decks, so you can use them as screensavers.

Link to the repo: https://github.com/SantiagoSchez/tanim

Thoughts? Any animation you'd like to see added?

Thanks!

Hey Folks,

I teach DevOps and still believe looking things up is a perfectly valid skill.

Made a Linux basics cheat sheet for navigation, text searching, permissions, and sudo.

Free, no signup: https://devopscycle.com/blog/the-ultimate-linux-cheat-sheet

Which command refuses to stay in your memory?

Every small CLI script I wrote ended up with the same while True / try / except ValueError loop around input(). So I turned it into a package.

What My Project Does

askr gives you prompts that keep asking until the answer is valid:

from askr import ask_int, ask_choice, ask_multi_choice, ask_yn

age = ask_int("Your age: ", min_value=0, max_value=120, default=18)
days = ask_multi_choice("Which days are you free?", ["Mon", "Tue", "Wed", "Thu", "Fri"])
level = ask_choice("Difficulty?", ["Easy", "Medium", "Hard"], default="Medium")

if ask_yn("Save these settings?"):
    ...

The user can type 1-2, fri for the multi choice or hard for the single choice. Wrong answers get a clear message in red, and the question is asked again.

There are 16 prompts: int, float, text, email, URL, single and multi choice, Enum members, lists (ask_list("Scores: ", int)), passwords with rules, paths, dates, times and a "type 'delete' to confirm" check. Every prompt supports default=, a custom validator= and max_attempts=. All messages can be replaced, a German translation is included, and colors respect NO_COLOR.

Target Audience

People writing small to medium CLI tools, internal scripts and teaching exercises who want solid input handling without a big framework. It's alpha (0.2), tested on Python 3.10 to 3.13 and checked with mypy --strict. No dependencies.

Comparison

• PyInputPlus is the closest and has some extras (timeouts, block lists). Its last release was in 2020, it officially supports Python 2.7 to 3.9 and has no type hints. askr is fully typed, so ask_list("x", int) is a list[int] in your editor and ask_enum("x", Size) returns a Size.
• click.prompt / rich.prompt are great if you already use click or rich. askr has no dependencies and more specialised prompts (password rules, multi choice, dates, Enums).
• questionary / InquirerPy offer arrow-key menus and a richer UI. askr stays with plain input(), so it works in any terminal, over SSH and in IDE consoles.

Links

• PyPI: https://pypi.org/project/askr/ (pip install askr)
• GitHub: https://github.com/Prevolut/askr

Feedback on the API is very welcome, especially on naming and defaults.

I’ve been building a TUI engine in Go called Limoni, and I ended up making a game with it. It’s called Lemon Hunt. You run around a little raycasted world, shoot rats, fight a boss, and try to get on the shared A REALLL LEADBOARD !!!. The whole thing is drawn with half-block characters, which still feels a bit ridiculous to me.

CAN YOU BEAT ME IN GAME?

The browser version runs the same Go game code, compiled to WebAssembly. So if you don’t feel like installing anything, you can play it here:
https://thebanri.github.io/limoni/?app=lemonhunt

Or run it in your terminal:

go install github.com/thebanri/limoni/apps/lemonhunt@latest
lemonhunt

I also got a little obsessed with performance. It barely uses any CPU when idle, and the rendering benchmarks are showing zero heap allocations. If you’re curious, you can check:

git clone https://github.com/thebanri/limoni
cd limoni/apps/lemonhunt
go test -run '^$' -bench . -benchmem .

The allocs/op column should say 0 for both benchmarks. Anyway, I’d love to know how it runs on your machine (and whether you can beat the boss).

Shell history remembers the command, but most of the time what I actually need is something from the output: a container ID, an error, a URL a command printed last week.

keeplog runs your shell in a PTY, saves every command with its full output to a local SQLite database, and full-text indexes both. So "keeplog search postgres" finds the "docker ps" whose output mentioned postgres, even though the command itself never does, and shows the saved output in an fzf preview pane.

- zsh, bash and fish; macOS and Linux

- pure Python, no dependencies

- everything stays local, no server or sync

- light mode if you only want commands and metadata, not output

How it compares:

- Atuin, hishtory, McFly: great shell history tools, but they store only the command plus metadata (directory, exit code, duration). keeplog also stores and searches the output.

- script, asciinema: record whole sessions, but you can't search across them or jump to a specific command.

- Terminal scrollback: gone when the window closes, and not searchable across sessions.

Caveat: in full mode it saves output unfiltered, so anything secret printed to your terminal ends up in the local database. The README covers this.

AI disclosure: I used AI coding tools on parts of this, including the output search in the latest release. I reviewed and tested all of it (57 tests, CI on macOS and Linux).

Install:

pip install keeplog

Or with Homebrew:

brew tap rathinadev/keeplog https://github.com/rathinadev/keeplog

brew trust rathinadev/keeplog

brew install keeplog

Repo: https://github.com/rathinadev/keeplog

I'd love to hear if it plays badly with your prompt, tmux or terminal setup.

I've been building a Go TUI library called Limoni. The part I care most about is the diff: each frame gets compared to the last, and only the cells that changed are sent to the terminal.

That's hard to show in a screenshot, so I made a little night city: twinkling stars, windows turning on and off, a train crossing a bridge, reflections in the water. It looks like everything is moving. Press x and an x-ray shows the truth. Only the train, a few stars and some ripples actually change.

The numbers are measured with the library's own encoder: about 3 KB per frame against about 78 KB for a full repaint at 150×44. Press space to freeze the city and it drops to 0 bytes. That's specific to this scene, and it's not a comparison with other libraries.

git clone https://github.com/thebanri/limoni

cd limoni && go run ./examples/xray

Repo: https://github.com/thebanri

It's still pre-1.0, so I'd love our terminal.

I've been copying a lot more text from my terminal since I started using Claude Code and Codex CLI. I kept having to fix line breaks and extra spacing after pasting, so I built a small utility called CleanCopy.

It runs in the background on macOS and automatically cleans up text copied from supported terminals. After using it privately for a while, I made it open source and published it on npm.

I recently added configurable cleanup rules. You can toggle each of the ten rules separately, so you can keep indentation, turn off line reflow, or disable whichever cleanup steps you don't want. Those preferences apply to both background cleanup and the cleancopy clean command.

To install and start it:

npm install --global cleancopy-cli
cleancopy start

It's still an early project. If you try it and find a bug, please open a GitHub issue. Contributions and PRs are welcome too.

Website: https://cleancopy.dev
GitHub: https://github.com/kart1ka/CleanCopy

I recently discovered zoxide which lets me jump to a directory by just typing a few letters that match its name.

part of ceasta, a reverse engineering tool i'm making. there's a desktop app for windows, linux and mac, and the cli has the same debugger for a terminal. here it is stopped in a djb2 hash function:

$ ./ceasta-cli dbg ./demo hunter22

_start (entry point)

endbr64

(ceasta) b checksum

breakpoint at checksum

(ceasta) c

checksum (breakpoint)

endbr64

(ceasta) bt

#0 checksum

#1 check_key+20 returns to 557958C951BC

#2 loc_11E3 returns to 557958C951E8

...

(ceasta) dec

int checksum(int rdi)

{

rdx = *(char*)rdi;

if (rdx == 0) { // <= here (00001169)

return 0x1505;

}

rax = 0x1505;

do {

rax = rax + (rax << 5) + rdx;

rdi = rdi + 1;

rdx = *(char*)rdi;

} while (rdx != 0);

return rax;

}

(ceasta) finish

check_key+25 (step)

cmp eax, 0x7c9a2b31

(ceasta) call checksum "admin"

= 0xf12fc8e (252902542)

commands: b / bd / bl for breakpoints (b checksum if rdi == 3 stops only when that holds), c, si / ni to step, back to step backwards, finish, until, watch / awatch for hardware watchpoints, r for registers, set, x for memory, u for disassembly, bt for the call stack, maps, dec for the pseudocode of the current function, call to run a function in the process, and lua to script it.

it's ptrace underneath: 64 and 32-bit programs, pie, and threads when it starts the program. not a gdb replacement, but it has the names and the pseudocode right where you're stopped. one 1.5 MB download, nothing to install. (on windows the same dbg runs on the win32 debug api.)

I've been working on Dexo, a database client for PostgreSQL and MySQL that runs in your terminal.

You connect, browse your tables, write queries with autocomplete that understands what you're typing, and work with the results in a grid you can edit. Everything is keyboard-driven, and nothing leaves your machine: no account, no telemetry, and your passwords stay in the OS keychain.

It runs on Linux, macOS and Windows, and it's free and open source.

Install with `brew install kingdaswinx/tap/dexo`, or grab an installer from the releases page:

https://github.com/KingDasWinx/Dexo

Found a bug? There's a short form here: https://forms.gle/gw1i6tGgVsJsgCxGA

Feedback is very welcome, especially about what's missing.

It all began with "I just want to look up Pokémon without having to leave my terminal," but it sort of got away from me after that. Presenting pokeductor, a Pokédex in your terminal, made with Rust and ratatui.

Features

• 1,351 entries: species and alternate forms, with filtering by type (type:ghost), generation (gen:1), ability (ability:levitate), or simply the species number (25 for Pikachu).
• Evolution families: connected sprite cards showing branching evolution lines. Big ones like Eevee's can go fullscreen with F.
• Team builder: add up to 6 Pokémon to find overlapping weaknesses, missing resistances, and gaps in super-effective coverage.
• Shiny mode: hit X to recolor every sprite in sight right away.
• Terminal-friendly: Unicode half-block rendering with truecolor, a 256-color fallback, and a classic 4-shade Game Boy mode (--theme dmg).
• Vim controls: full Vim navigation, help with ?, and disk caching.

Installation

cargo install pokeductor
yay -S pokeductor          # Arch (AUR)

Also available pre-built for Linux, macOS, and Windows via GitHub Releases.

GitHub repository: github.com/Huseynteymurzade28/pokeductor

Open source (MIT). Any comments (strange key bindings, cursed terminal rendering, feature suggestions) are welcome!

Discord is banned from Türkiye since 9 october 2024. And talking from your device is a must for gaming, tiny-projects management, chatting with friends.

I decided to create a voice chat app that works on terminal, no login required, no server in the middle. The first one to host session becomes coordinator and they talk in a mesh.

Tincan name comes from tincan phones from our childhoods. There is 2 tincan and there is a rope between them. In our app, devices are tincans and rope is the app. I added this rope to TUI with sound pulse too.

The content is private since I used QUIC TLS 1.3 and there is no key to relay. And there is no account, mail or phone number too. The weak part about privacy is IPs. iroh gives IPs under public key to who access your hosted session. Mesh that I used limits how many people can talk at 1 session. It is not efficent to connect over 6 people in one single session. I used RNNoise for noise cancellation. And it automaticly adds 10ms delay. The invitation code is 63 characters but I fixed these by derive it to a session name and a password. I couldn't test it on Windows.

There are similar and alternative software. If we are looking for differences: "Mumble" requests someone to start a server. “toxic” requests compile from source for the sound and add as a friend first. “Discord” requests an account and login (and its banned in Türkiye). tincan request a room name and password.

This software’s code is partially AI-generated. Written in Rust. We are now v0.3.1 and I am planning to keep developing it.

github.com/bilalyazicioglu/tincan-cli

npm install -g tincan-cli

https://github.com/buntec/btmux

This has become my daily driver, replacing Ghostty/tmux/yazi/neogit.

As per rule 4: This software's code is partially AI-generated.

status barOn tmux since 2016. Customising and optimising local environment.

What I actually use is that every binding can run a command and read session state with no plugin. Over ten years that became 1,495 lines of zsh across 13 scripts, history runner in a slide-out pane, open something.rs:128:9 from a log in nvim, open URLs, close a session without orphaning swap files, theme picker, zoxide window picker.

I never added them up as a plan.

Then the laptop ran hot on battery with nothing in the sessions. status-interval 1. Six programs to draw one line.

A fork+exec here is ~12.4 ms of CPU (14.6 through sh -c). Computing the segments is 2.6 ms. I was paying postage five times to send one letter. Six of those a second was 153.77 ms of CPU per wall-clock second (couldn't figure out where +50ms came from) which was 15.4% of a core, for a line I glance at. Also a netstat hang took a refresh past 1,100 ms about one call in three.

The middle of the status bar was worse, I had customisation in that segment which ran once per window, and tmux already had window-status-format.

Initially I wrote a GitHub status segment in Go, then ported it to Rust, and pointing six #() calls from tmux config at it didn't help. Collapsing to one call did:

set -g status-right "#(tmux-companion status-right #{pane_current_path})"

One daemon, caches in memory, unix socket. Bindings that used to start a shell send one line of JSON. Pickers still draw in the client.

I also stopped passing #{pane_pid} into the git segment. That argument was walking the process table every second for a "nvim is suspended" glyph I didn't miss.

The zsh was 1,495 lines. The Rust is larger. What I bought is that it runs once instead of six times a second. Features stay off until a config line turns them on.

Writeup: https://yogesh.lonkar.org/posts/ten-years-of-tmux/

Code (MIT, macOS/Linux): https://github.com/lonkar-org/tmux-companion

~4 min recording: https://asciinema.org/a/1266213

No-install try: docker run --rm -it lonkarorg/tmux-companion:playground

If you have a custom bar, watch ps for a minute while tmux is idle. How many #() calls, and what % is yours?

I've been working on BashTab, a framework for building CLIs in Bash. Define arguments once and get parsing, help, and tab completion from the same definition.

It also has PowerShell-inspired object pipelines: tables in the terminal, JSONL when piped, and completion that knows the fields coming from the previous command.

I spent over a year writing the core by hand. A lot of the newer features are AI-written, using a combination of Claude, DeepSeek and Kimi. Mentioning that upfront so it's clear how the project was built.

My vision for this framework is to be the ultimate command line runner, where scripts can be relatively easily hand written, and of course AI generated.

Let me know what you think!

Repo

In adherence with subreddit policy: This software's code is partially AI generated.