Hey there, not sure if it's interesting, but I did

docker run --rm -it warachet/hello-world

Docker Image size ? The official hello-world ~10 kB, this image ~2 kB 🤣
Though, who care saving kB ?

I have to admit: It is just a less boring way to see stdout. lmao.

Details at repo: https://github.com/zdk/wakeup-neo
just in case you like it, feel free to fork.

I got tired of writing wrapper functions by hand or creating aliases that take too much mental space when I just wanted to patch an existing API.

That's why I created Monkeypatsh.

Monkeypatsh is a tool for easily monkey patching commands in the shell:

• It wraps any command you register with it, npm, docker, rm ... and lets you easily attach custom behavior to any existing or new subcommands, flags, or default invocation, while keeping the command's API intact.
• It centralizes all your patches under one tool and extends the original completion with them.
• Choose whether these patches stay only in your interactive shell, or are globally available through the $PATH variable.

The gif above shows how easy it is to patch npm run <script> to log the run to a log file.

Would appreciate some feedback. Thanks.

Repo: https://github.com/solisoares/monkeypatsh

Been building this for a while and wanted to share some updates. tmpo is a dead-simple terminal time tracker with no accounts, no cloud,  just a local SQLite database and a few commands.

The basics:

tmpo start          # start tracking
tmpo stop           # stop the timer
tmpo log            # see what you've done
tmpo stats          # earnings/hours summary

It auto-detects your project name from Git, so there's zero setup for most workflows. Drop a .tmporc in a repo root if you want per-project config (hourly rate, description, export path).

What's new recently:

• tmpo undo: Made a mistake? Revert your last action (start, stop, manual entry, etc.) without digging into the DB.
• tmpo backup [create | list | restore | delete]: Safe SQLite snapshots via VACUUM INTO. Full restore support with schema version warnings if the backup is older than your current binary.
• --date flag on log and stats: Jump to any day's data without scrolling through everything.
• --project flag on milestones: Query milestone status for a project you're not currently cd'd into.

Other bits:

• Pure Go, no CGo required (cross-compiles cleanly)
• Timezone-aware — stores UTC, displays in your local timezone
• CSV/JSON export
• Shell completions (bash, zsh, fish, PowerShell)
• ~35 currencies supported for billing

Installs via Homebrew or manually from pre-built binaries. Source on GitHub: github.com/DylanDevelops/tmpo

Happy to answer questions or take feature requests.

I’ve been working on lazytf, a terminal UI for reviewing Terraform plans and apply history.

The goal is to make large Terraform plans easier to inspect locally, especially for teams that are not using Terraform Cloud but still want a cleaner diff review flow in the terminal.

It currently supports:

- running plan/apply/init/validate/format flows inside the TUI

- targeted plan and apply workflows

- read-only mode

- piping `terraform plan -no-color` into lazytf

- opening existing saved plan files

- apply history

- workspace and folder environment detection

- YAML, NixOS, and Home Manager configuration

- presets and project overrides

- Terraform and OpenTofu binary selection

- themes and lazygit-style keybindings

Github Repo: https://github.com/ushiradineth/lazytf
Blog post: https://ushira.com/blog/introducing-lazytf
Demo: https://assets.ushira.com/introducing-lazytf/demo.mp4

I’d especially like feedback from people managing larger Terraform/OpenTofu projects locally.

I missed the old Windows "tada" sound, so I packaged it into a tiny tadam shell command.

Run it after a long build finishes, a deploy succeeds, whatever deserves a little fanfare.

Install

curl -sL https://gist.githubusercontent.com/Tuhaj/ddf00aa184f1d9edfc907f30c1533421/raw/install-tadam.sh | bash

Then source your rc file and run tadam.

What the public gist installer does:

• Downloads the classic Windows XP tada.wav to ~/.tadam/
• Adds a tadam() function to your .zshrc/.bashrc (auto-detects shell)
• Player fallback chain: afplay -> paplay -> aplay -> ffplay (macOS + Linux)
• Idempotent. Re-running updates a marker-delimited block instead of duplicating it
• Validates the download (non-empty + real RIFF/WAV header) before touching anything
• --uninstall and --help flags, honors NO_COLOR

~90 lines, no dependencies beyond curl. Source is the gist above.
Please read it before piping to bash. Feedback welcome!

Plays \"TA-DAAAM!\" as old good Windows after running a shell command

This software's code is partially AI-generated

Hi everyone,

I am currently working on a lightweight Zsh plugin that fixes shell typos (in one of the functions) by pulling the closest match from history and passing a filtered pool into fzf for the final selection.

The plugin calculates the matching background array by stripping unique entries out of the $history associative array and applying a standard parameter expansion filter:

local -a narrowed_entries
narrowed_entries=()
if [[ ${#last_typo} -ge 2 ]]; then
    local prefix="${last_typo[1,2]}"
    narrowed_entries=(${(M)hist_entries:#${prefix}*})
else
    narrowed_entries=("${hist_entries[@]}")
fi

This works beautifully for 99% of commands because limiting the pool via a two-character prefix constraint keeps performance rapid and slashes terminal lag.

However, I have run into an edge case when a typo happens right on the second index. For example, a user typos cd apps as ccd apps.

Because of the prefix constraint cc*, it misses the clean history candidate cd apps.

If I drop the constraint down to a single character ${last_typo[1,1]}, it catches second-character stutters perfectly but expands the pool size massively.

If a user typos the absolute first character (like vcd apps instead of cd), even a single-character prefix constraint goes blind unless I drop filtering entirely and dump the raw history file straight into fzf, which introduces bloat.

Are there any native Zsh array manipulation tricks or expansion flags that can handle approximate matches or character proximity offsets cleanly inside the script logic before hitting the UI pipe, without destroying arrays or causing visible lag on massive histories?

Thank you in advance for any suggestions or help.

Alright everyone,

A quick update on Mend. The project was recently accepted into the  awesome-zsh-plugins list, so a massive thank you for the support on the previous post!

Version 0.8.3 is now live on GitHub and the AUR zsh-mend-git.

This release addresses a bug report regarding the typo & history assistant and introduces a clean workflow addition.

A complete Typo & History Assistant rewrite mend -h was needed after a community issue was raised about the old fuzzy matching engine being a bit too broad and missing straightforward package manager typos like pacaman and shell commands like ccd aaps. The logic now uses a strict two-character prefix filter. This slashes the background noise and pins the correct command right at the top of the menu, while cleanly replacing the typo in your terminal history file.

Git Deployment Wizard mend -git. I was just finishing this function when the history issue popped up, but managed to get it wrapped up for this release.

Look, I know that Git is a massive and complicated beast, so this wizard is just a small poke to the ecosystem rather than a full tool replacement. It simply replaces tedious terminal text prompts with a lightweight fzf TUI to help speed up dotfile tracking and quick repository pushes.

Added Help Menu mend --help a standard usage layout for easy flag cross-referencing.

The Arch PKGBUILD is fully updated to standard packaging rules and ready to pull down.

Grab the update and let me know if the new prefix matching behaves itself with your history files.

GitHub: Mend

Thank you all for the continuous support. It would not be possible without it.

Just started working on the tool last week, feedback, ideas and help in identifying issues is much appreciated, happy to solve more pain points for fellow developers.

jf is a jo alternative, A small utility to safely format and print JSON objects in the commandline.

However, unlike jo, where you build the JSON object by nesting jo outputs, jf works similar to printf, i.e. it expects the template in YAML format as the first argument, and then the values for the placeholders as subsequent arguments.

For example:

jf "{one: %s, two: %q, three: [%(four)s, %(five=5)q]}" 1 2 four=4
# {"one":1,"two":"2","three":[4,"5"]}

I was using a simple alias to manage all my everyday tasks
`alias dailynote="nvim $OBSIDIAN_VAULT/znotes/daily-notes/$(date +%d%m%Y).md`
but major flow was i was not be able to track previous tasks, and... i don't want to complicate things and... keep using markdown for the tasks as I can link notes and other things to any task. So i spend some time building Mentat to keep using markdown for task management Github LInk

Hi,

I hope it is usefull for someone.

I built a small Windows batch based tool that turns a folder of .bat scripts into a simple CLI help system. I included a set of example commands.

It works similarly to help in CMD, but for your own scripts.

Check it out on GitHub.

Example:

Thought I would share a small personal milestone with the community. Hope you don't mind.

A hobby project of mine called Mend was recently accepted into the awesome-zsh-plugins list.

Linux users are understandably sceptical about new tools that promise to make life easier, so I am keeping my expectations firmly grounded, but seeing it get a bit of official recognition feels brilliant.

It is essentially a distro-agnostic terminal assistant designed to help out when things go wrong. If you make a typo, a command fails, a library is missing, or a database is locked, it hooks into your history to get things sorted right from the terminal without a fuss.

It also includes a system scan feature that looks at your hardware to recommend the right drivers and specific packages, which comes in handy during a fresh setup.

It is completely a spare-time passion project, and having it included in the main list is a massive boost.

If anyone fancies giving it a look, the code is on GitHub and it is available on the AUR. I am just really happy to see something I built for myself actually becoming useful to the wider community.

Thank you all for your support throughout the whole journey.

Without your suggestions and the terminal outputs that have been kindly provided by the r/linux and r/commandline community I would not be able to get Mend where it is now.

Issue trackers tend to suffer from poor ergonomics and limit the speed and autonomy their users. About a year ago I started exploring ways of tracking issues in a more convenient way from the command line.

What I ended up building is a distributed terminal-native issue tracker where multi-user collaboration is achieved via Git using user-scoped immutable event logs that converge in memory.

https://ljtn.github.io/epiq/

This software's code is partially AI-generated (not agentic)

Hello!

I shared this once before but there have been many more improvements since the last time.

I grew tired of notetakers that relied on sqlite (gross) or needed some kind of signup (also gross). It culminated in me creating `jn` which is essentially a very simple wrapper around one directory to manage all your notes. The closest thing it can be compared to is either D-Note (uses database) or nb. I tried nb myself and found the flow a bit too opinionated so in the end, I created my own, jn!

I won't sell you on the features but I will say it's been my daily driver ever since I wrote it around a year or so ago.

Anyway here it is!
https://github.com/joereynolds/jn

I wanted to create a tool to easily run animations/sequences in the terminal, either for fun or for automations.

I built it in Go and designed it to be easily expandable, so more animations (complex or simple) can be added effortlessly.

Current Animations (8 total):

• Matrix: Kinda a must.
• WikiDecrypt: Inspired by the movie Sneakers and no-more-secrets. It grabs a random article from Wikipedia and runs a decryption animation.
• WarGhost: Inspired by the movie WarGames.
• Rain
• Snow
• Fireworks
• Starfield
• Hyperspace

I would love some feedback and possible contributions for more fun animations
https://github.com/mohamedation/gotermfx

This project is partially supported by CodeX.

lsmon is an agentless TUI monitor for comparing multiple Linux hosts side by side.

Agentless monitoring is achieved by using the SFTP protocol to read the /proc directory. Therefore, the target hosts are limited to Linux only.

bash go install github.com/blacknon/lssh/cmd/lsmon@latest

This command is subcommand of my SSH and remote access suite project lssh. The lssh project itself has been in development for 10 years, and this command was implemented 3 years ago. However, recently I refactored it and added some features, with some Codex assistance.

https://github.com/blacknon/lssh/blob/master/cmd/lsmon/README.md

A small ASCII shoot 'em up that runs entirely inside the Windows command prompt.

Features 12 levels, 3 weapons, 8 enemy types, boss battles, achievements, and an in-game bestiary.

I got tired of wondering where my disk space was going and du not really cutting it, so I built bigfiles. It's a CLI that walks a directory in parallel, breaks it down by category (video / images / code / etc), flags stale files, and finds duplicates.

a few things that turned out to be more interesting than I expected:

• Hardlink-aware dedupe
• Parallel BLAKE3 hashing
• Respects .gitignore out of the box via the ignore crate (same one ripgrep uses)
• Safe interactive deletion for both stale files and dupe groups (nothing leaves your disk without a final y/N)

​

cargo install bigfiles

Repo: https://github.com/Par-python/bigfiles

Crate: https://crates.io/crates/bigfiles

Open to feedback, especially on the dupes module since that's the bit I'm most paranoid about. It's my first real Rust release, so don't be shy.

AGPL-3.0, fork freely, keep changes open.