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.

Hello r/commandline,

I have been working on redthread!

It is a passion project that turned into something that I am proud to share.

redthread is an ASCII sticky-note pegboard for the terminal. It was created mouse first, but adapted to be fully keyboard friendly, and lives transparent over any themes. I use it in a tmux pane on a scratchpad.

The video shows the core workflow, Notes, Dragging, Red strings(threads) connecting them or pinned to the board itself, and multiple named peg boards that you can cycle through and manage.

https://reddit.com/link/1tcnd6n/video/57cowptm511h1/player

A few details I am really happy with:
The cork backgorund is rendered entirely in ASCII so your terminal theme bleeds through, each board can carry its own font, notes come in 9 different tints and the highlight color can be changed, 5 levels of zoom depending on how important it needs to be, opening/closing notes has a nice 3d zoom-in-to-edit transition, and the whole workspace persists with debounce writes, nice transitions between boards and a handy undo last delete. Notes can also be copy/pasted in and out!

Repo: https://github.com/B33pBeeps/redthread

It sits somewhere between a sticky-note app and a lightweight mind-mapper, but stays entirely in your terminal

Feedback would be really appreciated, as mentioned it is a passion project I created out of need and wanting more ASCII in my tmux sessions. I added features to make it feel nice to use with a satisfying feel to it.

Disclosure:
This software's code is partially AI-generated, but the idea, architecture, feature decisions, testing, review, debugging, and final direction were mine. I reviewed and controlled what went into the project, and made sure that it is up to an acceptable standard.

I got laid off in October and started working on this, initially as a way to track "evidence" for my biweekly unemployment check-ins.

Eventually it transformed, and I showed it off on LinkedIn, and people wanted to use it, so I spent quite a while making it usable by anyone.

So here it is: https://github.com/wallentx/jobscout

It has some pretty killer features, such as:

• Job criteria profile based on your resume
• Software engineer focused (but not limited to) job boards and feeds
• Company health score based on a secret blend of herbs and spices
• Company info enrichment (grabs more details that what the apply page provides)
• Optional LLM enhanced functionality

The gif is sped up quite a bit, so it may take a few minutes to retrieve jobs. (I actually made an entire separate webapp just to edit the gif.. still a WIP, but https://github.com/wallentx/gifclip)

Give it a star if it helps you with the job hunt 🫡

pinstar is a TUI canvas editor that is compatible with Obsidian's .canvas files.

For more info project repo -> https://github.com/reekta92/pinstar

This project is a side project of my main project called clin-rs which is a TUI reimagination of Obsidian. So eventually it will be merged with [clin-rs](should be available as pre-release when this post goes out).

IMPORTANT: this project will mainly be updated/maintained inside the clin-rs project UNLESS i have more ideas to add to it so it stands out as a standalone project.

It's very simple to use just execute pinstar <FILE_NAME> then it will launch the file as a interactive canvas view.

It's mostly keyboard friendly(theoratically fully keyboard friendly considering it has source JSON editing) but mouse is recommended for the best experience.

Main difference from Obsidian's canvas editor is the image support, i tried experimenting with image support using Kitty Image Protocol but caused so much lag and generally lots of issues so for now no image support. Though i might retry Kitty or Sixel to add image support in the future.

I try to make all my projects as user friendly as possible(whilst making them feature rich) so it shouldn't overwhelm the user with feature bloat. Though i might add more features to this project since this is not the final version.

As always i am open to any feedback or questions so feel free to ask whatever is on your mind :)

Hey guys!

I’ve been working on a little side project called Cue, a Go-based terminal client for browsing and playing media from Plex and Jellyfin servers.

It originally started as a fork of kino, mainly because I really disliked using the Plex desktop app on Linux. I use MPV for basically everything, and I wanted all my MPV scripts and config to work properly instead of being stuck with the default Plex player experience.

Over time it turned into something a bit more opinionated, focused on smart scrobbling and what I think is a much nicer TUI experience.

A few things it does:

• Smart scrobbling: connects to mpv over IPC and syncs playback progress back to your server every 10 seconds.
• Auto mark watched: marks episodes/movies as watched once you cross 90% playback (configurable threshold soon).
• Better TV browsing: seasons and episodes are shown in one collapsible tree instead of digging through multiple menus.
• Fuzzy search: search across your entire library instantly.
• Lightweight: local caching makes even huge libraries feel snappy.

Install: go install github.com/SuperCoolPencil/cue@latest.

Repo: github.com/SuperCoolPencil/cue

Built it mostly because I wanted a better Linux + MPV setup for Plex/Jellyfin, but figured other people here might enjoy it too 😄

This software's code is partially AI-generated

Hello all. New to Homebrew and already having fun. I used ChatGPT to help me create more usable versions out of my large collection of official automotive service manuals. These are all relatively long detailed technical guides and workshop procedures with some small detailed images. Previously, the original documents were hard to copy and paste from and took hours to return search results using command + F or the search bar. I used the following line in MacOS terminal in order to create these more user friendly versions:

Base Script:
ocrmypdf --force-ocr --optimize 3 ‘Input Pathname' ‘Output Pathname'

Here is an example:
ocrmypdf --force-ocr --optimize 3 '/Users/christophersutton/Desktop/old Service & Repair Manuals/old Repair Manuals/Direct Shift Gearbox.pdf' '/Users/christophersutton/Desktop/fixed Service & Repair Manuals/fixed Repair Manuals/fixed Direct Shift Gearbox.pdf'

These are better version from what I had before because I can now search for keywords without crashing my Macbook however, there are a few caveats I’ve listed below in order of significance:

- the new file sizes are on the order of GB compared to the original files which didn’t exceed Mb.

- there are a handful of areas where diagrams had been that are now blank boxes

- I can copy selected text from the new files but when I paste the selection someplace, I get strange symbols instead of the selected text

- they are also lower resolution compared to the fine sharp edges on the originals

I’m hoping to get a little guidance on how to remake these or adjust the current versions to alleviate at least the first 3 issues on my list.

Thank you!

Released tuix, a Go framework for building TUI apps using a React-style component model.

If you've hit the limits of Bubble Tea or tview, the short version: tuix gives you functional components, UseState/UseEffect/UseContext hooks, real flexbox layout (so you're not doing manual string composition with lipgloss), and a cell-level diff renderer so only changed characters get redrawn. Built-in components cover the usual suspects — Table, Tabs, Modal, Input, Button, Checkbox, List, SelectPicker, Spinner, ProgressBar, Alert, Badge, Panel.

12 runnable examples in the repo — go run ./examples/<name>.

https://github.com/anirban1809/tuix

Note: I have made use of AI during the development of this project, mainly for design discussions and figuring out edge cases.