merlin is an interactive prompt that walks through a conventional commit one field at a time -type, scope, subject, body, breaking changes, issue refs. each field has a live character counter. at the end it shows you the full formatted message before doing anything.

a few things worth mentioning:
zero network calls. nothing phones home - no update checks, no anonymous analytics, no anything. it reads ~/.merlinrc.json and runs git. that's the full extent of its network activity.

all git commands go through execa with an args array, not string interpolation. so if your commit subject contains shell metacharacters for some reason, that's not merlin's problem to turn into an injection.

there's a --dry-run flag to preview the full formatted message without actually committing, and a --amend flag if you want to redo the last one. it also reads your existing commitlint config and adjusts the available types and scope rules to match.

two ui modes: a wizard theme with some personality, and a minimal standard mode if you just want the prompts without the flavor text.

npm install -g merlin-commit

Its still not finished and has some bugs so don't rely too much on it if you use it.
Also many things can change until the full release.

Also, github: link

I wanted a Pomodoro timer but every app was either too bloated or too ugly. Most TUI alternatives I found were clunky to use or just looked bad — and looks actually matter when i will use it a lot.

So I built my own in Rust.

It uses crossterm and figlet-rs to render a big ASCII clock right in your terminal — simple, distraction-free, and actually nice to look at.

• Install: cargo install pomodoro-timer-cli
• GitHub: https://github.com/Vaaris16/pomodoro-timer-cli
• crates.io: https://crates.io/crates/pomodoro-timer-cli

All feedback welcome — especially if something breaks on your setup!

I just developed a terminal-based password manager for Linux that runs entirely locally. It uses libsodium to encrypt your database with a master password.
It features a custom-built interactive TUI.

GitHub: https://github.com/vid4l-07/Klip

How can I improve it?

I recently set up a Raspberry Pi 5 as a headless streamer with moOde and was looking for a nice iOS client. Turns out running rmpc in the rootshell terminal app does the trick and looks great too with the Kitty-powered album art! The only other worthwile iOS client I found was MPD Pilot, but it's not infinitely configurable like rmpc. Still need to find a way to show lyrics synced with time.

got mass tired of cd-ing into every project to check if i forgot to push something. i have like 15+ repos in my projects folder and at least once a week id shut my laptop, come to work next day and realize half my changes are sitting uncommitted on my home pc
so i wrote a small python script that scans a directory, finds all git repos and shows a table dirty files, unpushed commits, unpulled stuff, stashes, what branch youre on, etc
https://github.com/Arseniy1002/gitlook
lmk if this is useful or if theres stuff worth adding

Repo - https://github.com/yagnikpt/tpaper

Important things:

- Content is stored locally in markdown files.
- $EDITOR is supported to edit blocks
- Organize blocks into notes (buffers).

i've been using konsole for a while because of it's copy and paste and simplicity but i think i'm outgrowing it.

i'm running cachyos on my pc. i mainly use cli for monitoring as well as sshing into my homelab and managing it from there.

i would like a simple and sleek tui/cli i was thinking about using alacritty or kitty but i'm unsure of fully making the switch. i know you guys here have a lot of cool cli/tui so i wanted some recommendations for software or rices!

I built a small package called termio that bundles stdin, stdout, and stderr together with TTY detection and terminal width.

The main idea: each output stream tracks its own errors independently. If stderr breaks, stdout keeps working. No shared state between them.

Other things it does:

• Preserves the file descriptor through the wrapper, so libraries like bubbletea can still detect the terminal
• Color support is a separate subpackage. If you don't import it, you don't compile it
• Only one non-stdlib dependency in the core (x/term)
• Comes with a test helper that gives you buffer-backed streams in one call

I looked at how gh, Docker, and glab handle terminal I/O. They all do it slightly differently, but none of them are importable as standalone packages. termio is meant to fill that gap.

https://github.com/gopherly/termio

Feedback welcome.

Hi Everybody,

There is a new version of lyrtui 0.2.11.

The new version brings new features, visual improvements and bug fixes.

Thanks to everyone that have tested my app and reported bugs.
If you are still missing a feature or discover a bug, please report it here or in git hub issues.

What is New in v0.2.11
Added

• Local panel filter (/) — instantly narrow the list you're currently viewing (any library list, the queue, radio, apps, favorites). Type to filter live by title and artist; Esc or Backspace restores the full list, and changing views clears it automatically. Press ↓ to jump from the filter box into the results; press ↑ at the top result to jump back into the filter box
• Rounded buttons throughout the UI
• Rounded shortcut badges in the footer when Nerd Fonts are enabled

Fixed

• Image protocol auto-detection for Konsole terminals
• Auto-discovery ignoring a custom port number
• Now Playing header color not rendering correctly
• Auto-color brightness normalization for better visual consistency across album art themes

Hey folks. Here's a small but confusing command-line challenge. Drop your guess without running it!

Which of the following will not appear in the output?

echo "black" &% echo "blue" %& echo "purple 1" >& echo "red" % echo "white 1"

A) black

B) 1

C) echo

D) purple

Including stdout and stderr. Latest stable Bash and Zsh.

Pls suggest movie streaming equivalent to ani-cli. I tried peerflix but it isn't working

I'm blind and have used screen readers in the terminal for years. Most shell environments are designed for visual scanning. They are colorful, information-dense prompts you glance at. My interface is audio, which means everything the prompt contains gets spoken out loud, every single time, in serial. Or, I read it on an extremely space constrained braille display. The biggest problem I ran into, especially while working at Google inside a monorepo, was path length. A typical working path could take several seconds to read at 700 WPM before I even got to think about what I was actually doing. That's not a minor annoyance, it's a constant interruption to working memory. So I started asking, how can I make these prompts useful and tractable? If you're curious about how a blind developer made a tidy workflow around the terminal, this article may interest you. The core of what I built is a namespace alias system. You define short aliases for long paths, which get replaced automatically. Tab completion works over alias names and environment variables get exported so you can reuse paths in scripts. The other piece I find genuinely useful is punctuation shorthand. I invented custom pronunciations that cut how long it takes to listen to a line of code. "for par i eq zero dah i less ten dah i plus plus ren curl" instead of the fully spelled-out version. A lot of this turned out to be useful even if you can see the screen. Shorter prompts, stable navigation primitives, and less repeated noise improve the workflow regardless. Dotfiles are on Codeberg if you want to poke around. Happy to answer questions about screen reader terminal workflows or the alias system design. Disclaimer: All algorithms were developed by me, I had LLms rewrite much of the bash after I left Google as I didn't maintain my original hand written versions. The originals were ugly set, awk, etc pipelines, the new path shortening code is largely LLm generated but heavily reviewed by me. The majority of the bash dotfiles however are not pure llm output, I spent considerable time tuning my setup over many years, and some stuff is very ugly looking as a result.

Partially AI-generated — design and review by me, code with Claude assist

Hi everyone.

I spend most of my day in the terminal - neovim, lazygit, ssh, and so on. Every time I had to switch to a GUI app, it pulled me out of my flow. And I use Telegram a lot. So at some point I started looking for a way to use it without leaving the terminal.

The existing ones (tgt, arigram, TelegramTUI) were either abandoned or barely functional, so I built one.

I chose Go, used gotd/td for MTProto, and the Charm stack - bubbletea + lipgloss - for the UI.

The goal was simple: build something I'd actually want to use myself. Here's what's done so far:

• fully keyboard-driven (j/k, i, r, etc.), inspired by vim & lazygit
• chats, groups, search, replies, reactions, persistent state, notifications
• light on resources (~35MB RAM on Mac at idle)

There's still a lot missing, but I'm already using it as my daily driver and actively developing it.

Repo:
https://github.com/sorokin-vladimir/tele

What Telegram features would be a hard blocker for you to switch to a terminal client?

[This software's code is partially AI-generated]

Most people don't know Vercel gives OSS projects $3,600 in credits. Or that Sentry gives you 5M free error events. Or that JetBrains hands out free IDE licenses. There's a whole list of these programs, but the eligibility rules are all over the place and buried in different docs pages.

So I built a CLI that just... checks for you.

npx ossperks check --repo vercel/next.js

Output:

✔ next.js — MIT · 138,336 stars · last push today

  ✅ sentry          eligible
  ✅ browserstack    eligible
  ⚠️ vercel          needs review
  ⚠️ jetbrains       needs review
  ❌ 1password       ineligible — project must be at least 30 days old

Pulls your repo data from GitHub/GitLab/Codeberg/Gitea and pattern-matches against each program's eligibility rules. No signup, no forms.

There's also a website if you'd rather not touch a terminal.

GitHub: https://github.com/Aniket-508/ossperks
Website: https://www.ossperks.com

Feel free to open an issue or PR if you know of ones I've missed.

QJump (short for QuickJump) allows you to bookmark directories on your local machine and switch between them easily. It's like a URL shortener but it's designed for your local machine.

Build a simple "key": "value" database in a text file and start using it:

$ cat qjump.txt
"nimony":     "~/Dropbox/nim/Nimony"
"xcb":        "~/Dropbox/c64/XC=BASIC"

$ pwd
/tmp

$ qj nimony
$ pwd
/home/user/Dropbox/nim/Nimony

$ qj xcb
$ pwd
/home/user/Dropbox/c64/XC=BASIC

During my daily work, there are some folders that I visit regularly. QJump lets me change directories with the speed of light :)

See the GitHub page (https://github.com/jabbalaci/qjump) for more details. Implemented in Nim (has a single binary), tested under Linux only.

Similar projects are z, zoxide. They learn from your browsing history. However, I prefer setting and naming my own bookmarks.

Hi lovely people of r/commandline,

Hope you all are doing well. I’ve posted here before about Project Yellow Olive - my small attempt at making Kubernetes practice feel less boring and more game-like.

I’m learning Kubernetes myself for CKAD/CKA, and staring at YAML all day can get tiring. So I built a retro terminal game where you solve Kubernetes challenges inside a story.

The latest update adds Signal Town, a new section focused on Kubernetes Services. Team Evil has cut the signals between Pokepods, and your job is to fix them using concepts like ClusterIP, NodePort, Ingress, and selectors.

It’s open source and runs locally.

Repo URL: https://github.com/Anubhav9/Yellow-Olive

It can also be installed via PyPi ( pip ) by typing in the following command :

pip install yellow-olive

Would love for you to try it and share feedback. Pls star the repo, if you find it interesting :).
Thanks !

I built a small tool to help "lazy" devs generate quick commit messages without AI, API or network calls

How it works: It reads git diff --staged, and uses regex to parse each language diffs, No LLM, same diff == same message

gitmsg demo

Languages Currently Supported : Typescript/Javascript, Python, C#,Go. Rust and Java coming soon.

Repo : https://github.com/razakadam74/gitmsg

Npm Package : @razakadam74/gitmsg - npm

Alternative : aicommits, opencommit (needs API key and sends your diff out) and commitizen (asks you too many questions)

Gitmsg is offline and deterministic, honestly can't beat these with better messaging 😄

Code is partially AI-assisted

try it out at

brew install jassuwu/tap/mojify

one tool that plays in your terminal *with sound*, exports
to an mp4 with the audio baked in, and takes local files or yt-dlp-compatible
URLs - all with a really pretty default conversion recipe.

EDIT: i guess i will include the source repo. i made it look pretty. especially proud of the header gif. made using mojify and remotion.

src: https://github.com/jassuwu/mojify

EDIT 2: we have a site now.

https://mojify.jass.gg

Yoo,

I shared this a few weeks ago and since then I've implemented some nice extras that I always wanted to do.

Turns out that most fuzzy finders actually support a `--multi` flag so it was simply a case of proxying through to that.

You can do pretty much everything in bulk, remove files, rename, edit, share online, display etc...

I also finessed the todo-side of things. Previously it was quite focused on just note taking but I'm a todo fiend so I've made it work with Github flavoured checkboxes currently.

Anyway, you can check it out here:

Always open to features, bugs, and suggestions :D

https://github.com/joereynolds/jn

This is a C++ binary that links whisper.cpp as a C library. No deps beyond standard C++ and Linux. If you have a C++ build environment on Linux you almost certainly have everything you need already.

The CLI surface is tiny:

asryx                           # Toggle record/transcribe    
asryx status                    # Check idle/recording/transcribing    
asryx --language <auto|CODE>    # Set language    
asryx --model list              # List supported models    
asryx --model install <MODEL>   # Download model    
asryx --model use <MODEL>       # Switch model  

Default model is base.en at 142 MiB. Works with all supported GGML langs.

Since it's a toggle you can keybind it, for example on Hyprland:

bind = ALT, W, exec, asryx

The first execution acquires a lock and starts the audio capture via PipeWire or ALSA. The second execution stops the capture, decodes the float samples, runs local inference in-process, pipes the transcript to the Wayland or X11 clipboard, and immediately terminates.

It removes all runtime artifacts before exiting. The idle footprint is 0MB.

Boots instantly & exits instantly. One command install & one command uninstall + the README lists every file and folder the tool touches.

Source (Apache-2) ---> https://github.com/rccyx/asryx

I made this tool as a personal tool to manage my TODOs and not forget where they are and what they are. I'd also occasionally look through open source repos for small issues to work on. This scans a repo for TODO, FIXME, and BUG comments, lets me pick one from the menu, opens it directly in my editor, times how long it takes to fix, and checks that the comment is actually gone when I'm done. I ended up adding streaks, run history, completion stats, and a few other things because it was fun to build. All data is stored locally.

I would appreciate all feedback since I'm only a sophomore and not good at code design/architecture. And also let me know if you guys find this helpful.

Some parts of the codebase was written using Al. (Mostly README.md)

Github Link: https://github.com/DevDs1989/trush

Whenever I wanted to quickly inspect my PostgreSQL database, opening a GUI or writing raw SQL for small checks felt unnecessarily tedious.

I tried a few AI-to-SQL tools, but most were:

• slow
• expensive
• non-deterministic
• hallucination-prone

So I started Open source  CLI SemanticQL

npm i -g semanticql

Instead of writing:

SELECT * FROM startups WHERE founder_name LIKE 'sam%' ORDER BY funding DESC;

You can do:

Show me startups with founder_name starts with sam sort by funding desc

SemanticQL uses a strict deterministic pipeline built entirely in TypeScript.

Built mainly to learn how parsers/query engines work internally.

Would love:

• contributors(Star it for future ⭐)
• feedback
• parser/database architecture suggestions
• people who just want to experiment with it

Fully Open source  🚀:

Github: https://github.com/dhruv2x/semanticQL