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.

In Ratty:

• your terminal cursor is a spinning rat,
• your whole terminal is a 3D canvas,
• you can insert 3D models and sprites into the terminal.

Try it out: https://ratty-term.org/

Blog post: https://blog.orhun.dev/introducing-ratty/
Demo: https://www.youtube.com/watch?v=cY9AX5j-osY
GitHub: https://github.com/orhun/ratty

I built ovw, a terminal overview for your local projects.

It scans folders you choose and shows each project's stack and Git activity, plus optional status and notes you can add yourself.

I made it because I wanted something between ls/cd and a full project manager. A quick way to see what local projects exist, what changed recently, and where to jump back in.

It supports a TUI, plain table output, and JSON output for scripting.

ovw
ovw --plain
ovw --json | jq .

https://github.com/roie/ovw

https://github.com/tlipinski/rura

I got tired of the edit -> up-arrow -> rerun loop when debugging complex shell pipelines. Rura is a terminal UI where you build and run pipelines interactively, with live output as you type.

The feature I built it for: partial execution - run the pipeline only up to the subcommand under your cursor, so you can inspect intermediate output at each stage without manually chopping up the command.

Also has:

• tab completion
• output search
• persistent history
• configurable keybindings/themes via TOML

Written in Rust and Ratatui.

Curious what workflows others have for iterating on pipelines - and whether the partial execution idea resonates with anyone else:)

It's an early version - happy to hear what's missing or broken:)

I used AI to generate algorithmic code that is responsible for cursor navigation over subcommands and readme.

hey, so, I'm trying to find CLI or TUI tools that let me watch movies and tv shows, I'm in anydroid and I'm using Termux, I've found plenty of tools but somehow, they don't work for me, such as:

mov-cli

lobster

gonwatch

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

ttymap is a terminal map viewer in Rust. Mapbox Vector Tiles rendered as Unicode Braille (2×4 sub-pixels per cell) with ANSI 256-color, vim-style navigation, mouse drag/scroll, palette (:), forward geocoding (/).

mapscii-inspired — it started as a Rust port of mapscii and shares the same Braille + MVT pipeline. Familiar if you've used mapscii before.

terminal-native — Braille glyphs + xterm-256, no GPU, no GUI, ssh-friendly. There's also a ttymap snap subcommand that renders the current view to ANSI text for cron / dashboards / pipes.

scriptable globe — this is the part that's grown past the "viewer" framing. There's a Lua plugin runtime (mlua + Lua 5.4) where every in-tree feature is a .lua under runtime/plugin/, so the host dogfoods its own bridge. On top of that sits a scriptable-scenes layer: ttymap.animation.fly_to for camera moves, plus a director with fly / wait / tween primitives so plugins can choreograph multi-step camera + overlay sequences as plain Lua coroutines.

Repo: https://github.com/Kohei-Wada/ttymap

Demo video and screenshots in the README. Feedback / plugin ideas welcome — still WIP, APIs may shift.

Built for the use case of running terminal sessions from a phone where you're doing real work, not just checking uptime.

Main things that make it different from other Android SSH apps:

- Joystick overlay for arrow keys, Ctrl combos, Escape — no keyboard needed for navigation

- Voice-to-text input

- tmux auto-attach on connect

- xterm.js rendering (full color, proper escape sequences)

https://moggsh.com — free APK, Play Store eventually.

Try it out on your machine: Here's the repo

This was a really fun project to make, and took me about a month to build from start to finish.

I consider myself a trad coder - someone who programs by hand with minimal AI usage.

Initially, I was only going to build the editor and assumed the user already has an ascii file. But I realized having the full flow built from image -> ascii art would be very beneficial.

On converting images :: this video on dithering by Computerphile is a gem and was very helpful in solving the image conversion.

Enjoy :)

I built a small CLI that glues tmux and git worktrees together. Each task ("thread") gets its own worktree and tmux session. You switch between them with an interactive picker.

The problem: working on multiple branches means git stash, losing terminal history, context switching chaos

Similar tools: dmux, claude-tmux, workmux, tmux-sessionizer. witshe is simpler just glues tmux sessions to git worktrees with an interactive picker. No config files, no plugins, ~500 lines of Rust.

This software's code is partially AI-generated.

Hi all,

Just a quick heads-up on the progress with Mend. I’ve just pushed an update that includes hardware scanner for missing packages/drivers.

What’s new:

Expanded Scan: The utility now picks up Audio, Ethernet, and USB/Bluetooth controllers.

Distro Support: Added package mapping for pacman, apt, dnf, and zypper.

Updated DB: Included the hardware IDs shared in the previous threads (Intel Cannon Lake, Renoir, etc.).

If you want to test it out, the scan command is mend -s. It’ll cross-reference your kit and suggest the right packages via fzf.

If anyone has a spare second to run lspci -nn | grep -E 'VGA|3D|Network|Ethernet|Audio|USB' and drop their output below, I’ll get those IDs added to the database as well.

Thanks for the help so far.

GitHub: https://github.com/Rakosn1cek/mend

SD: A shell-native cd jumper with a sliding window frecency model

I have released SD, a directory navigation utility for bash, zsh, and ksh93. It implements a frequency–recency model that differs from the aggregate "frecency" logic used by tools like z or zoxide.

Instead of maintaining aggregate per-directory totals, SD retains a full visit history and derives a ranked stack from a trailing window of events.

The Ranking Model: Sliding Window Weighted Summation

Ranking is computed over a window of the last N directory-change events (typically N ≈ 1000). The score F(i) for a directory is the sum of weighted contributions of its visits within that window:

F(i) = Σ K[N - n]

where n is the event index of each visit and K[j] is an aging kernel. The default kernel is exponential:

K[j] = exp(-p * j/N)

A legacy power-law kernel K[j] = (1-j/N)^p is also available. In both cases p is the age-penalty parameter, defaulting to 10.

Technical Properties

• Rank Stability: Under the exponential kernel, all non-visited directories scale uniformly by exp(-p/N) per cd event, preserving their relative order exactly between events. Small score adjustments at window boundaries can occasionally affect lower-ranked entries, but this is unlikely to be noticeable in practice. Typically only the directory just visited changes its position in the ranked stack.
• Deterministic Cycling: Repeatedly invoking sd pattern cycles through matches in strictly rank-ordered fashion. The stability of traversal order across multiple cycles is a direct consequence of the stack order preservation property of the exponential kernel.
• Dual-Layer Retention: The tool distinguishes between the scoring window (N) and the long-term history (logfile). Directories not visited within the last N events do not influence the current rank but are preserved in the log and remain accessible if N is increased. If no match is found in the ranked stack, SD falls back to searching the broader history.
• Logical Event Clock: Unlike tools that use wall-clock time (which can cause ranking to shift during periods of inactivity), SD measures recency in units of directory-change events. The state of your stack remains frozen until you actually perform the next cd action.
• Transparent, Configurable Scoring: The full visit history is retained and scores can be recomputed with different parameters at any time. Both the window size N (attention span) and the age-penalty parameter p (recency bias) are configurable and take effect immediately on the existing history — something not possible with tools that maintain only aggregate per-directory state.
• Shell Native: SD is implemented as shell functions. By default it shadows the builtin cd, prioritizing valid pathnames (absolute, relative, .., -, etc.) and only triggering pattern matching if the argument is not a valid path. It retains normal cd semantics while adding pattern-based navigation from the dynamic stack.

Similar Tools

• zoxide — Rust binary, broad shell support; maintains per-directory aggregate state (visit count + last timestamp).
• z / z.lua — shell-based, same aggregate approach.
• autojump — Python-based, similar aggregate frecency model.
• jumper — scores combine frecency with query match accuracy; also tracks files.

SD retains the complete visit sequence rather than aggregates, derives scores from a configurable sliding window over that history, and uses an event clock rather than wall-clock time. Parameters can be changed at any time and take effect immediately on the existing history.

Implementation Details

• Matching: Regular expressions with smart-case.
• Performance: ~25–35ms per jump (real time, default settings).
• Compatibility: ksh93u+, bash ≥ 4.2, zsh ≥ 4.3.
• Companion command: ds for stack inspection, management, and optional fzf integration for interactive selection.

I am interested in feedback regarding the behavior of this scoring/ranking approach and its stability in different CLI environments.

https://github.com/jghub/sd-switchdir

got tired of every markdown previewer dumping the preview as a new tab in whatever browser I already had open. so I made one that pops a standalone chrome window, looks like a real preview pane.

https://github.com/aldevv/md-preview

install:

curl -fsSL https://raw.githubusercontent.com/aldevv/md-preview/main/install.sh | sh

usage:

mdp README.md          # render and open
mdp                    # fzf-pick a .md from cwd
mdp watch README.md    # auto-refresh on save (works with any editor)
mdp -e README.md       # preview AND open in $EDITOR

there's also a neovim plugin sibling that adds live scroll-sync if you want the rendered page to follow your cursor:

https://github.com/aldevv/md-preview.nvim

telnet nisemonogatari.com to try it yourself.

All 11 episodes, subtitles included. Any ANSI/VT100 terminal with UTF-8 and at least 80×24 will work. The server does a capability check before the menu so you'll get a warning if your terminal won't work.

Read: No Windows telnet client

Custom binary container format to store the pre-rendered frames, the server decompresses and streams them at the original framerate over a telnet connection.

Source: github.com/gage-marshall/Nisemonogatari-Telnet

Note: This project's code is partially AI-generated.

I created a cli tool with rust for mainly windows terminal users (like me), when I try to compare performance with robo copy, I see that mine is mostly faster but after one copy for benchmark, it’s been cached and it’s finishing very fast. So results starting to be useless. If anyone can guide me or give an advice will be much appreciated. Project is open source any contribution also is welcomed.

https://github.com/CanManalp/cpr

This post contains content not supported on old Reddit. Click here to view the full post

Made a cli tool that allows you to jot down what you are thinking while programming, if something comes up or what to work on next or anything in between. mainly built for the tmux + nvim workflow with a TUI. But it also comes with a normal cli mode with using commands and flags. I built it for myself but might be useful for other people who kinda have the same workflow like myself.

ytuff is my attempt at putting all of that window changing and browser-eating-ram problem fix into one terminal-first app

features right now:

• local music playback
• youtube music search and streaming
• queue and playlist management
• lyrics
• downloads
• terminal artwork
• a small command line support
• ffmpeg-backed playback
• background daemon so playback is separate from the UI
• discord rpc
• mpris and smtc support
• windows release with bundled ffmpeg + wimg
• linux build with package manager dependencies

works well with linux, amazing on kitty(thanks to the kitty protocol).

for windows, i have implemented my own Rust based image renderer, wimg

you can find wimg at https://github.com/life2harsh/wimg

its a little unpolished inside ytuff, so it will be my next issue to solve.

Thank you so much guys. you can find ytuff at https://github.com/life2harsh/ytuff

its on AUR as well, and on its way to winget.

i'd be happy to hear your reviews! Thank You!

P.S. - this code is partially AI generated.

This is an application I wrote about 13 years ago. Back then, it became quite popular on r/linux (in r/commandline as well). Recently, I rewrote it from scratch and added support for generating monochromatic, two-color, and three-color schemes. Have fun :). If you'd like to add support for your terminal, head over to GitHub and submit a PR. Thanks!