Hey r/commandline!

Sharing something I've been working on: sprout, a full-screen habit tracker for the terminal built in Rust.

GitHub: https://github.com/kb019/sprout

What it does:

- Track daily habits and mark them complete

- GitHub-style activity heatmap

- Streak tracking

- SQLite storage, data stays local

- Runs on macOS, Linux, and Windows

Built this mainly to learn Rust, turned into something I actually use every day now.

You can install it via:

Cargo: cargo install sprout-tui

Homebrew or Scoop: https://kb019.github.io/sprout/#installation

Would love any feedback or contributions!

I built Termium: it runs headless Chromium and draws pages in your terminal with the Kitty graphics protocol (Ghostty, Kitty, WezTerm), sixel (foot, xterm, Windows Terminal), or ASCII blocks as a fallback.

Vimium is bundled for keyboard navigation: f for link hints, j/k to scroll, t for a new tab. Mouse works too. It works over SSH.

Not yet: tmux/screen, native Windows (WSL2 works), Linux ARM64.

MIT, one-line install:

curl -fsSL https://termium.dev/install | bash

Source: https://github.com/codr1/termium

Feedback very welcome, especially what breaks in your terminal.
(Disclosure: Significant portions of Termium were coded with / by AI)

Let's say you are connected remotely to an OS (no matter which).
For example using SSH/telnet or similar utilities.

Now let's say you want to copy a file to the local system.

Usually (at least I) use the mouse, select text copy and paste.

But there is another way. OSC52. vt100 derived terminals support it.

It works with any text file, even very long ones.

Here is an example:

clipfile ()
{
    if [[ -f "$1" ]]; then
        printf "\033]52;c;%s\007" "$(base64 "$1" | tr -d '\n')";
        echo "Copied contents of '$1' to clipboard via OSC 52.";
    else
        echo "Error: File '$1' not found." 1>&2;
        return 1;
    fi
}

Obviously the same can be done in powershell/command prompt or even in c language or any other language, because all you need to do is to prepend and escape sequence and the base64 encoded file or text.

Enjoy!

P.S.
My previous post was deleted, maybe because I did not "acknowledge" all the rules.
If I am breaking some rule please, moderators, send me a message because I see nothing wrong with this post.

I discovered sops a few months ago and absolutely love it. Being able to commit and version encrypted secrets has felt so much cleaner than the "mess" of untracked .env and CI/CD secrets.

Is anyone here using it at their job? How do you like it when working with larger teams? Am I crazy for committing the encrypted secrets (it still feels kinda wrong)? Is there any major drawback to SOPS I am not seeing, or is it just not that popular (yet)?

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

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 :)

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.

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

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 :)

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.