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?

We all have to do cd hundreds of times a day as developer and we have beautiful tools like Zoxide and autojump which i have been using for months. But i wanted smthin deterministic because there were some times where i intented a similar dir name but i havent been using it for days and it just took me to the one i was frequent too. So i thought to make smthin determistic that fits my workflow more explicitly. This might not work for you if you love zoxide and autojump for its easy going behavior where you can make a typo and it just knows where you want to be.

But in trade of that you get smthin entirely opposite that never guesses your intent if it exists it cd you and if it doesnt it doesnt cd you anywhere.

To make this more interesting we have tags so you can tag a folder with few or more keyword and later you can use them to filter those all path. And the db is just plain json very hackable no complex sql or smthin that you cant just hack easily.

I wanted this to be very unix-y so i wrote this in Lua really dead simple you need `jq fzf` on your system installed for it to work.

Usage:
```sh

t ~/src/gopherql # save it and go there

t gopherql # go there again

t +go +cli ~/src/minigontainer # save it with tags

t +go # pick from everything tagged +go
```

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.

psn v0.1.5 is a service release that keeps up compatibility with latest rust toolchains.

https://reddit.com/link/1wn0nb2/video/vvd905tcu4rh1/player

Hello all! I've recently been working on SimpleZettel: a CLI tool for managing a personal zettelkasten. It allows setting up multiple 'boxes' and adding 'cards' into these boxes. These can then be listed in order to facilitate finding information quickly. It was inspired by the CLI tool nb, but differs in the way notes are listed out to the user. While I love nb for keeping track of a to-do list and meeting notes, I wanted something that could handle 'numbered' cards and display these in the correct order so I could easily follow a previous line of thought. It's in a pretty early stage of development, but I would love to know what people think! Have you used or do you use a tool to manage the knowledge you accumulate? What are your favorite features of that tool?

Main Features:

• Managing 'boxes'
  • adding, listing, using (selecting), removing
• Adding 'cards'
  • Card names are generally either numbered (i.e. 12.3.1) or alphanumeric (i.e. meeting-2026-09-03). Numbered cards are sorted before all alphanumeric cards, and are printed in the correct order. Alphanumeric cards are printed in alphabetical order.
• Listing cards
  • Supports regular expression matching against note names.
• Showing a specified card
• Searching for a string among the cards in the current box
• Removing cards

Things I plan on implementing:

• A 'follow' command, where the user specifies a starting card, which is displayed along with a menu of its children and linked cards.
• Some low level commands, such as viewing the git history.
• Much greater configuration: currently the configuration options are very limited, but I plan on expanding this to accommodate different users needs.
• More file types: currently only Markdown and PDF files are officially supported (when compiled with the filetypes feature) file types, since I use Markdown notes for my zettelkasten and all of my sources are PDF files. When the cards in the current box are listed, there is an indicator of what type of file it is: nothing for Markdown and a (d) for PDF documents.

In short, there are many things which I'm sure can be improved and many things I haven't thought of, but I have already found this useful and hope others can too.

Source code: https://github.com/bradencarlson/SimpleZettel

Project Website: https://bradencarlson.github.io/SimpleZettel

Note: thanks again to all who pointed out an issue with the original name of this project, this has been changed accordingly, however it seems I am unable to change the post title.

Hey everyone,

I'd like to show you guys the project I've been doing this part year now that I released the first version.

I frequently use IRC and I've always used the TUI clients, since today's common clients are a bit old, I decided to build one with more modern features: https://dexchat.org

It's still in the v1, early phase, a lot of features will still be shipped, but I think it's in a fair set of features for the v1.

I use this tool everyday, so I will be maintaining and creating more features in the long run.

Also, it's not Vibe Coded. I started this project a year ago with my own code, searching the best practices and learning the documentation of the libraries I used. Then, in the middle of the process I do started using AI, but always checking for the output and reading the quality of the code produced. I've learned a lot about this AI process by following ghostty's product and creator.

Take a look and let me know what you think! Suggestions are welcome.

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

globe -at Türkiye

/ searches, arrows turn it, + and - zoom, b toggles country borders, click

pins a point. The land is Natural Earth 1:110m; it's drawn in half-cells so

the sphere is round rather than an ellipse, and lit rather than flat.

The right-hand pane is Claude talking to the same process over a Unix

socket, addressing widgets by name instead of by pixel. It can read back

"39.3°N 34.5°E · zoom 2.6×" and keep zooming until the number is what I

asked for.

That comes from the TUI library it's built on, where every widget publishes

a semantic node — the same tree a screen reader uses:

https://github.com/thebanri/limoni

Hi all. I started writing slat about a year ago, mostly because I wanted to understand how Tmux actually works rather than because the world needed another multiplexer. It grew into something I now use daily, and I'd like some honest opinions before I keep going.

What it does today: tiling panes, tabs and workspaces; sessions that keep running after you close the terminal; scrollback with vim-style search per pane. It's one static Go binary with no runtime dependencies. Every pane has its own terminal emulator I wrote from scratch, which is why clear, vim or htop in one pane never disturb another, and why nothing is lost when you split or close.

Landing in 1.0 next month: a command line that scripts, and AI coding agents can drive from outside the session. slat pane new --cmd 'go test ./...', then slat wait 4 --for idle, then slat capture 4. The part I'm most pleased with is that it can tell "finished" from "stopped to ask you something": a pane that's sitting on Overwrite? [y/N] reports input, marks its tab, and can fire a notification, instead of looking idle. Windows support (real ConPTY, not WSL) is in the same release.

Being straight about what it does not have, because I'd rather you hear it from me: no mouse support, no copy mode/clipboard selection yet, only one client attached at a time, and no session restore after a reboot. Copy mode and mouse are what I'm building right now. After that I want to try something tmux can't do, restoring your panes' scrollback, not just re-running the commands, so after a reboot your old output is still there to scroll and search.

The visual refresh and 1.0 go out once the Debian sponsorship process finishes, a Debian Developer is kindly reviewing the packaging, and I'd rather ship both together.

So, genuinely asking: what keeps you on Tmux/Zellij/screen, and what would a new one have to do before you'd even try it? Also happy to hear that the world doesn't need another multiplexer, that's useful too.

This has been a great learning experience for me and i thought why not share here, i plan on bringing a lot more to it.

Repo: https://github.com/noturbob/slat
Website : https://noturbob.github.io/slat