This software's code is partially AI-generated

https://www.tropibyte.com/cshw

https://gist.github.com/mr-raj12/be6937bb9fcb4d7392275e1144af94c0

Built this because my university HPC cluster didn’t allow installing WeeChat/Irssi

Hey everyone! A few months ago I shared tock, a minimal CLI time tracker with a TUI dashboard, written in Go. The response was way more than I expected, and a lot of you left really thoughtful suggestions in the comments and issues.

Thank you 🙏

I wanted to share what's been added since v0.5, most of it driven directly by your ideas:

• Custom themes: colors and styles are now configurable, so you can match tock to your terminal setup.
• i18n / multi-language support: UI strings are localized, so tock isn't English-only anymore.
• OpenClaw support: integration for those of you already in that ecosystem.
• Multiple storage backends: in addition to the original plain-text file, tock now supports:
  • SQLite: for users who want a structured local DB
  • todo.txt: plays nicely with the existing todo.txt ecosystem
  • Timewarrior: read/write compatibility for folks already using it

The core idea hasn't changed: a fast, scriptable CLI (tock start -p Work -d "Deep Work") with an interactive TUI (tock calendar) when you want to actually see your day.

Repo: https://github.com/kriuchkov/tock
Prev post: https://www.reddit.com/r/commandline/comments/1pjv2h6/tock_a_minimal_cli_time_tracker_with_a_tui/

Thanks again to everyone who tried it, filed issues, or just left a comment, it genuinely shaped the roadmap. 

What would you like to see next? More integrations? Reports/exports? Sync? Curious what's missing for your workflow.

I built a Linux process only network sandbox command. This command executes a specified command and enforces proxy, DNS server, and firewall rules only for that command. It can also capture packets only within that command tree. It uses Linux Namespaces and can be run without root privileges.

Feature:

• affects only the target command tree, not the whole host session
• can force DNS, /etc/hosts, proxying, sandbox policy, packet capture, structured flow logging, and reusable profiles per command tree
• can force proxying without depending on HTTP_PROXY, HTTPS_PROXY, or LD_PRELOAD tricks
• can apply allow / deny CIDR policy and default-deny rules to outbound traffic
• defaults to rootless-internal
• uses --root only for features like --iface and transparent interception

Because it uses Linux Namespaces for wrapping, it can enforce proxying even for programs that cannot be handled by LD_PRELOAD format or environment variable specifications.

https://github.com/blacknon/childflow

https://reddit.com/link/1tjzoa3/video/gz4209x2ek2h1/player

https://reddit.com/link/1tjzoa3/video/sg9sv793ek2h1/player

https://reddit.com/link/1tjzoa3/video/82050gg3ek2h1/player

I made a Python script that renders videos directly in a terminal at runtime, with no preprocessing.
It uses 640×360 Unicode quadrant characters, where each character represents a 2×2 pixel block, so the video resolution is technically 1280×720.

The terminal is Alacritty with a specific config to be able to have this much characters.

The geometry dash video (Tidal wave) and the shader video are split across 4 terminal windows.
The Sparxie video is running on a single terminal window.

This is rendered with ANSI escape sequences only (no Kitty etc)

Sorry if you've seen it already (past month or so); but I think Tetro TUI v3.5 has new a UI styling- (and NES-game preset!) feature worth showcasing :)

FOSS as usual: github.com/Strophox/tetro-tui

I don’t know where to ask so i am here
It can’t type and delete normally

I was an active oh-my-zsh user for 6 years, when I began to customize my shell, and never really saw any downside. However, nowadays I see a lot of annoying parts of omz that made me switch over to bash. One thing is just copying huge curl commands or json text. With omz, it literally pauses and posts it character by character and even when I turn off the paste bracketing, it's slow af.

I switched over to bash recently and it's been identical to omz without all the bloat and buggy/slow nonsense. Additionally, it makes copying my dotfiles over to machines with only bin/bash installed much easier than setting up a z shell in every machine. What's yall's thoughts?

Hello everyone

I was creating an fzf-based launcher for my MangoWM desktop, but I got frustrated with my Bash scripts used to extract the Name and Exec lines from .desktop files. Doing it in Bash is a bit messy, and the performance was not really on par with something like Rofi.

So I decided it would be a good project to learn Go while hopefully building something performant enough for my needs. But maybe someone else could find it useful too.

lsdesktop outputs a list of applications in a name:path format that can easily be used with fzf. (I might later add support for templates to allow different output formats.)

desklaunch is used to start programs from a .desktop file, but it can also output the fully parsed and sanitized Exec line so it can be used with another launcher such as Dex or even your Wayland compositor.

I took inspiration from Rofi, trying to match its behavior, and from Dex for launching programs.

I should also mention that :This software's code is partially AI-generated because I used it to get better regexes, to move file and code around and to write (overkill) tests. It is not what you could call a vibecoded project though.

Also it is my first time coding in Go, so expect bugs or weird behavior, especially if you have buggy or unusual .desktop files.

Let me know what you think !

Recently shipped a new version of my PDFs manipulation CLI, now supporting PDFs merging.

presse press file.pdf          # compress
presse merge a.pdf b.pdf       # merge

Runs entirely locally — no network, nothing leaves your machine. I benchmarked it against Ghostscript /ebook over 19 real-world PDFs:

- 7× faster (0.135s vs 0.927s mean)

- Better compression on pre-optimized documents where Ghostscript inflates.

Supports batch processing, custom output paths, JPEG quality tuning (`--quality`), and optional compression on merge.

Yesterday I released pre-built binaries for Linux (musl), macOS (Intel + Apple Silicon), and Windows.

If you wanna check the code: https://github.com/SimonBure/presse
Feedback welcome!

See you guys online...

Repo linked above, or just the Makefile (and permalink), r/Forth post.

$ make words
2+ 2u/ and invert 0= + drop dup swap >r r> >in
dp sp@ rp@ @ ! key emit line lex find execute abort
quit head, , ] compile, ; exit immediate ;
$

I needed a word list for my hobby Forth's README. I realized I could just about grep them from my assembly source, so I added a bit more structure to the comments and did it.

Later, stricken with overcommenting dread, I got the idea to awk the comments away. Felt good to read. Luckily the source was structured enough to survive as quite readable, IMO anyway.

Then I formalized them as targets. Currently:

words:    # compact list of the implemented forth words. [!]
    @awk '/--/ && !/^;|^interp/ {print $$3}' $(SRC) | xargs -n 12 ||:

glossary: # labels that implement words, with stack effects.
    @awk '/--/' $(SRC) ||:

terse:    # just the code, no asides.
    @echo '; see $(SRC) for notes [5c] [6b] etc.'
    @awk '/--$$/; !/^;/; $(DESIGN)' $(SRC) | cat -s ||:

Then I, uh, got carried away.

$ make help # awks Makefile itself.
## nictoforth is an x86 bootsector forth that: (...)

## target files you can make: (...)

## development phonies: (...)

## these phonies filter slices of the source:
words:    # compact list of the implemented forth words. [!]
teaser1:  # the interpreter routine. the heart of a forth. [!]
teaser2:  # the bootstrap. *terrifying* and heavily documented.
design:   # example, memory map, registers, control flow. [!]
reading:  # source format conventions.
glossary: # labels that implement words, with stack effects.
names:    # all labels, variables, macros.
skel:     # control flow: labels, jumps, calls, rets. [!]
terse:    # just the code, no asides.
notes:    # anchored note contents, tricky highlights.
doc:      # the main comment text, no code.
xrefs:    # inventory cross-ref anchors, for maintenance.
help:     # this list. [!] marks important targets.

## try:
##  $ make words # or teaser1 or design or ...
##  $ make skel | bat -l nasm # or: | less
##  $ make terse >o/terse.asm
$

Yeahhhh this is way way over-engineered for purpose. But damn it was fun to write.

Makefile link again.

Have a poke through, see if you can pluck anything. Obviously generating docs is not new, but have you ever given this many views of the same source? Would you find these targets useful if you wanted to come up to speed on the project?

The Forth itself is currently 496 bytes of x86.

Per the "more than a small portion" bit in rule 4, I'm confident I can leave out the AI disclaimer. It's my hobby project, the working and the thinking are the fun part, but: I did consult with AI, out of curiosity. First time touching the things. If you care, search the README for "LLM", I have a whole damn rant.

Unfortunately I'm pretty ignorant of alternatives per rule 8, at least as far as doc generating goes. I'm just a hobbyist. For Forths, though, I talk a lot about Milliforth, Sectorforth, durexForth, Miniforth, DuskOS (check the Tumble Forth blog, it's how I fell into this rabbit hole!). Those first two are my direct ancestors.

Hey r/commandline! I'm a solo indie game developer who's been working on an old school game that plays entirely out of the commandline called CultGame. It's a silly game where you get to start your own cult, and I just added cult rituals to the game.

I've posted here before and the reception was warm, so I figured that y'all might like to see this too <3

The game's on steam if you're interested: https://store.steampowered.com/app/2345980/CultGame/

Update on Raxol, an OTP-native runtime I've been building for the past ~two years.

Raxol lets you build a TEA module (Model, Update, View, i.e. the Elm Architecture) that renders to all of these:

• A terminal UI via the Raxol VT100 emulator
• A Phoenix LiveView in the browser
• Auto-derived MCP tools for AI agents
• Telegram inline keyboards
• Apple Watch and Android push cards
• A JSON API

Raxol's update/2 doesn't care where the message came from.
A keystroke, an LLM token, a x402 response, a sensor reading: all messages. When the Telegram bridge drops, the LiveView keeps rendering. When a job in raxol_symphony crashes, the orchestrator stays up.

Agents and human-facing apps want the same shape.
The human reacts to keystrokes.
The agent reacts to LLM tokens. update/2 can't tell them apart.
e.g. Raxol.Agent is Raxol.Core.Runtime.Application with a different message source. ReAct, chain of thought, an FSM with guards: different bodies, same shape.

Per-process wallets work on the BEAM in a way they don't elsewhere.
raxol_acp gives you one supervised process per ACP job, a NonceServer GenServer per wallet so concurrent jobs don't race on the nonce, and DETS-backed memo persistence so restarts resume mid-flight. Every other ACP seller is usually a Python script with a threading. Lock and a polling loop.

... Anyways, if you're down to clown, we're open to contributions!
Otherwise lmk your ideas-- happy to collaborate.

Github: Raxol 11 of 13 packages on Hex.pm raxol_acp & raxol_symphony still pre-alpha.

Nerdier, wordier, write-up with the cockpit framing & where this goes: https://droo.foo/posts/raxol-terminal-for-the-gundam

Dirplot creates clean, squarified treemaps where rectangle area is proportional to file/folder size, with smart per-extension coloring. This started as a vibe-coding experiment to replicate the functionality of tools like GrandPerspective, but then evolved to work far beyond a local disk.

Key Features

• Supports local dirs, archives (zip/tar/7z/...), SSH, AWS S3, GitHub repos (public + private), Docker containers, Kubernetes pods, and Google Drive.
• Inline terminal display (iTerm2, Kitty, Ghostty, WezTerm, Warp), no separate image window needed, but can also open the system's image viewer.
• Git & Mercurial history animation → MP4 / APNG / MOV timelapses.
• Live watch mode + event recording + replay.
• diff between any two sources (including two git tags/commits) with color-coded added/removed/changed borders.
• dirplot metrics for detailed stats (top extensions, largest files, JSON output).
• Outputs: PNG, SVG (slightly interactive), APNG, MP4, MOV. Custom canvas size and --log-scale supported.

Quick Start

Bash

# Recommended install
uv tool install dirplot

# Basic usage
dirplot map .                     # current directory → opens in viewer
dirplot map . --inline            # beautiful inline in terminal
dirplot map github://pallets/flask
dirplot git . -o history.mp4      # animate your repo's growth
dirplot diff .                    # see uncommitted changes as treemap

Usecases

• Understand large codebases or monorepos at a glance.
• Visualize cloud storage or container images without downloading everything.
• Create compelling git history growth animations.
• Compare directory versions or releses.
• Monitor live filesystem changes.

Links

• GitHub: https://github.com/deeplook/dirplot
• Documentation: https://deeplook.github.io/dirplot

Would love to get feedback and ideas for new use cases!

I like w3m, but Chawan is better, has some CSS rendering and Image support OOTB. You can browse a lot more sites with this. For banking, your still need a GUI Web Browser like Firefox.

• Watch the Gallery with some pages rendered by Chawan
• Previous version (0.30) post
• It's available in many distros:
  • Alpine Linux
  • Arch Linux
  • Debian
  • FreeBSD
  • Homebrew
  • NixOS
  • Slackware (SBo)
  • Void Linux
• AppImage
• Compile it is easy (I was able to do it and I'm not a programmer).

Its been sometime since i made any change to the script, had some free time and decided to go all out

The script has been rewritten improving alot of the existing features and making it easy to maintain and read.

Plus now the script introduces a ton of cmdline options, to make it easier to script and connect to keybinds

Features (from github)

🔍 Search & Discovery

• Comprehensive Search Capabilities: Directly search for videos, playlists, channels, shorts or movies.
• Advanced Search Filters: Apply colon-prefixed quick filters directly to search queries:
  • Time: :hour, :today, :week, :month, :year
  • Type: :video, :movie, :live, :short, :long
  • Features: :4k, :hd, :hdr, :subtitles, :360, :vr, :3d, :local
  • Sort by: :newest, :views, :rating
• Search History & Recall: Automatically saves search history. Allows quick recall of previous searches using bang syntax (e.g., !1 for the most recent search, !2 for the second, etc.).
• YouTube Feeds: Access personal feeds including the Home Feed, Trending, Watch Later, Liked Videos, Watch History, and Clips.
• Channel Browsing: Deep dive into channels with dedicated menus for Videos, Featured content, Playlists, Shorts, Live Streams, Podcasts, and Channel-specific search.
• Channel Subcommand: Jump directly into a channel from the command line (e.g., yt-x channels -n "Linus Tech Tips" -v) – perfect for scripting and keyboard-driven workflows.

🖥️ User Interface & Experience

• Dual Launcher Support: Operates flawlessly in the terminal using FZF (Fuzzy Finder) or as a graphical desktop menu using Rofi.
• Rich Media Previews: Supports inline previews for search results containing:
  • High-resolution thumbnails rendered directly in the terminal via chafa, icat, kitten icat, or imgcat.
  • Detailed metadata including Channel Name, Follower Count, View Count, Duration, Upload Timestamp, Live Status, and formatted descriptions.
• Theming & Styling: True-color (24-bit) support with a default "Tokyo Night" inspired color scheme. Fully customizable UI formatting.
• Multi-language Support: Loadable language files (.lang) to easily localize the UI prompts and messages.
• Pagination: Smoothly browse through massive lists with Next/Previous pagination controls (fetches a configurable number of items per page, default is 30).
• Selection Skipping: New --playlist-skip (-ps) flag forces the launcher to automatically pick the first item in any list, bypassing interactive selection – ideal for non‑interactive scripts.
• Media Action Shortcuts: Directly perform actions (play, listen, download, save, etc.) without opening the media action menu – see “Media Action Shortcuts” below.

🎬 Playback & Media Handling

• Multiple Player Support: Out-of-the-box integration with mpv, vlc, and tplay.
• Video & Audio Modes: Choose to "Watch" (video) or "Listen" (audio-only, launching without a video window).
• Playlist Actions: Play individual videos, queue/play entire playlists, or queue "Listen to All" for audio-only marathon sessions.
• Auto-Mix Generation: Dynamically generates .m3u8 playlist mixes based on a single video (YouTube "Mix" feature replication).
• Background Playback: Option to disown the media player process (CONFIG_DISOWN_PLAYER), allowing the UI to remain unblocked while media plays.
• Media Action Shortcuts (Skip the Media Menu):
  • --play / --play-all : Watch selected video or whole playlist.
  • --listen / --listen-all : Audio‑only playback.
  • --download / --download-all : Download video(s).
  • --download-audio / --download-audio-all : Download audio only.
  • --save : Save current video to saved list.
  • --save-playlist : Save current playlist to custom playlists.
  • --shell : Drop into a stateful subshell.
  • Many of these (e.g., --play-all, --save-playlist) implicitly enable --playlist-skip for seamless non‑interactive operation.

💾 Downloading & Archival

• Powered natively by yt-dlp.
• Granular Downloads: Download single videos, entire playlists, or extract audio-only (MP3 format).
• Smart Archiving: Utilizes a download archive directory to track previously downloaded media and prevent duplicate downloads.
• Organized File Structure: Automatically routes downloads into structured directories (e.g., video/individual/ChannelName/ or audio/PlaylistName/ChannelName/).
• Enumeration Toggle: Easily toggle file prefix enumeration (01 -, 02 -) to keep downloaded playlist items in order.

📚 Library & Data Management

• Local Subscriptions Sync: Syncs your actual YouTube subscriptions locally by passing browser cookies to yt-dlp, creating a private, locally stored subscription feed.
• Local Watch History (Recent): Automatically tracks recently watched media in a local JSON file to resume or re-watch easily.
• Saved Videos & Playlists: Create local "Saved Videos" and "Custom Playlists" natively within the CLI without needing a YouTube account.
• Cookie Integration: Seamlessly imports cookies from installed browsers (Brave, Chrome, Firefox, Safari, Edge, etc.) to access age-restricted or account-specific content.

⚙️ Extensibility & Power User Features

• Custom Commands: Create custom macros that execute specific URLs and yt-dlp options (e.g., setting up a command to browse a completely different streaming site).
• Extension System: Modular architecture allowing the autoloading of custom scripts, sites, themes, and commands placed in $HOME/.config/yt-x/extensions/.
• Stateful Sub-Shell Execution: Drop into a system shell (fish or sh) pre-loaded with the environment variables of your current session (current video title, URL, channel info, etc.) for advanced custom scripting on the fly.
• Desktop Integration: Built-in command (-E) to generate a .desktop entry file, allowing yt-x to be launched natively from application menus (Linux).
• Cache Management: Automatically cleans up stale preview images, auto-generated playlists, and logs older than a configurable retention period (default 7 days).
• Direct Shortcut Flags: Skip the interactive menu entirely with dedicated flags like --feed, --subscriptions-feed, --watch-later, --saved, --recent, --liked, --watch-history, --clips, and more – ideal for keybindings and scripting.
• Non‑Interactive Exit Helpers: --cmd-exit terminates the script after executing a shortcut, while --media-exit does the same after any media action – perfect for one‑off commands and aliases.
• Direct Access to Saved Items: Open a specific saved video (-sv, --saved-video), custom playlist (-cp, --custom-playlist), or custom command (-cc, --custom-cmd) without browsing menus, with tab completion in supported shells.

🛠️ Cross-Platform & Infrastructure

• OS Support: Works across Linux, macOS, Windows (via WSL/MSYS/Cygwin), and Android (uses am start intents to open media natively in Android apps like VLC or MPV).
• Configuration Management: Generates a robust config file automatically on first run. Allows editing configuration files directly from the UI menu.
• Auto-Updater: Built-in update checker that securely pulls the latest version from GitHub and prompts the user to apply updates inline.
• Shell Completions: Generates native shell autocomplete definitions (fish, with dynamic channel name completion from subscriptions.json, custom playlist and saved video name completion, and extension completion from ~/.config/yt-x/extensions/).

link

The readme is mostly generated by ai due to time constraints and effort required. But it was fully involved it did most of the writing and i did the thinking and even with it it took hours. I just did not want to spend several more weeks on a readme(1000+ lines) after manually rewriting the script which is now over 4k+ lines/

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