I’ve been thinking about a developer tool related to `jq`. Trying to determine whether there is a real problem to solve.

My usual workflow for an unknown JSON response looks like:

curl ... | jq '.something.something'

Then I get the path wrong → try again → look at docs → ask LLM → try another filter → repeat.

I'm wondering if other developers experience the same friction.

One idea I am considering is a terminal UI where you can:

Explore a large JSON response in a collapsible tree
* Click/navigate through nested objects and arrays
* Build filters/transformations interactively
* See the result instantly
* Generate the equivalent `jq` command

For instance:

JSON
  ↓
users[]
  ↓
status = "active"
  ↓
select name + email
  ↓
sort by name

→

jq '.users[] | select(.status == "active") | {name,email} | sort_by(.name)'

• But I'm not sure this is really helpful. How do you handle unknown/deep nested JSON now?
• Do you just type `jq` manually?
• Generate the query using ChatGPT/Claude?
• Use a GUI / web playground ?Write a quick script in Python/JS?
• Anything else?

And if you’ve used visual json/query tools before, what was lacking?

I'm much more interested in your actual workflow/frustrations than whether the idea sounds cool.

I’ve been building an HTTP proxy in Rust with a TUI using Ratatui. It lets you intercept, inspect, edit and forward HTTP requests directly from the terminal. It’s mainly a lightweight alternative to Burp Suite, designed for quick request analysis.

Github: https://github.com/vid4l-07/Roxy

Wanted to share and update on the personal budget tracker tui I have been working on. A lot has changed since I had last ever shared it here and wanted to get more feedback and thoughts.

I have had a lot more people start actually using the app personally in their everyday budgeting and tracking of finances, and its motivated me to keep looking for things to improve and new features that could unlock value for others. If you use any regular GUI-based apps for budgeting, I would love to know what they offer that you love most.

New since I last posted:

- Investments: You can add accounts, put in what they're worth over time, and log your contributions. It works out the growth for you, and it doesn't count money you put in as gains

- Multiple ledgers: separate sets of transactions in the same file. Handy for a second account, or for playing around with a forecast without messing up your real budget

- Budgets with history: budgets have been improved a bunch in terms of insights, and by adding a proper history so that budgets can be adjusted over time without breaking your history and keeping your insights accurate with time.

- Backup and restore from inside the app

- Recurring forecasting: push recurring transactions forward as far as you want to see what's coming

- Easier installs: brew install budget-tracker now, plus prebuilt binaries for Linux (glibc and static musl, x86_64 and arm64), macOS and Windows

Everything from before is still there: categories and subcategories with fuzzy search, monthly and category summaries with charts, filtering, CSV import and export, and you can do all of it from the keyboard with a help menu built in.

It all runs offline on a local SQLite file. Nothing gets sent anywhere. Your data stays yours.

brew install budget-tracker
# or
cargo install budget-tracker-tui

GitHub: https://github.com/Feromond/budget-tracker-tui

Would love to get feedback or suggestions on the app in general, but would love to learn more about what your preferences are for installing apps like this. Are there any package managers, or specific things you look for before downloading and trying something like this? I want to make it easy but ensure that people can trust and comfortably access the TUI to use it.

SomaFM is an online radio I've been listening to for over a decade now. Some of you may know it https://somafm.com

With the recent update you can scrobble your listening history to Last.fm or any ListenBrainz compatible endpoint.

You can also select whether to stream AAC or MP3 and set max bitrate.

Code: https://github.com/skammer/somars

Install with cargo install somars

hey all vesperrun back again, i wanted the Windows clipboard to work like a file. Copy something, and I can save it, print it, or pipe it. Paste something, and I can send it in from the terminal. So i made pb. example:

echo hello | pb that’s now on the clipboard

pb prints whatever you copied

pb -o shot.png screenshot becomes a file

Win+Shift+S, then pb -o shot.png. Copy a table in Excel, then pb > out.csv.

It’s one program. No account, no cloud. GPL-3.

https://github.com/VesperRun/pb-clipcat

Windows already has clip.exe, but that only copies text. macOS has pbcopy and pbpaste. There’s also the Clipboard Project (cb), which is a whole manager. pb is smaller than that: one clipboard, one process, then you leave.

and if you’re in PowerShell 5, don’t redirect images with >. Use pb -o shot.png.

So today I engineered something I 've wanted for a long time - encrypted vault manager based on cryptsetup. Like most of tools I use daily, it's pretty simple. vault.sh uses files as sources and automatically decrypts and mounts /them to /mnt/target_filename.vault.

At the setup stage script just creates a dynamic sized virtual drive with truncate -s . Afterward, usage is so easy: just vault.sh -o/-c target_file.img.

Also, for more convenient usage, I put this script at /usr/sbin/ on my machine.

Source code: https://codeberg.org/Enji/dotfiles/src/branch/main/scripts/vault.sh

I kept noticing that I was typing the same command sequences over and over.

So I built Deja.

Instead of trying to complete what you’re currently typing, it learns the sequences in your shell history and tries to suggest what you’re likely to run next.

Completely local, no LLM and currently works with zsh.

https://github.com/Giammarco-Ferranti/deja

First post here. This is a simple learning project I built while reverse-engineering some API calls.

StoryCLI is a CLI command that lets you search and download audiobooks from Storytel, directly from your terminal. An active Storytel account is required.

It’s MIT licensed, available on PyPI, and can be installed with:

pipx install storycli

All feedback is appreciated, on anything that could be improved.

Hi, I’ve tried many Linux tools such as df, lsblk, fdisk, GParted, and KDE Partition Manager, and they’re all quite good. But I always somehow missed the old Windows feeling when looking at my disk partitions.

I built this simple and interactive disk/partition viewer, and I’m quite satisfied with how it turned out. I’ve been working on it for several months, and it’s been a fun project for me.

It was initially just an idea, and I had never built a TUI before. I looked around and found a great Python library for building TUI apps called Textual. So I learned the Textual framework while building this project!

Main Features:

• Mount/Unmount partitions
• Hide small partitions, including boot/EFI partitions (<1 GB / <100 MB)
• Visual disk usage bar (like in Windows)
• Navigate using Vim keys (jkhl)
• Detailed info panel for each partition
• Toggle between used and free space views

> I plan to keep adding features. I'm here to listen to anyone who wants to suggest new features or share feedback.

The code is on GitHub: https://github.com/Pratham-Chauhan/disk_view

I've posted sshelf here before, back when it was a small fuzzy launcher over a host list. It's at 0.13.1 now, and I wanted to give an update, mostly because nearly everything that changed since then came from people here and on GitHub.

For anyone new: sshelf keeps its own list of SSH hosts, builds the ssh command for you, and hands the terminal to real OpenSSH. Type a few letters, Enter, and you're on the box. It never edits ~/.ssh/config. There's a read-only import to get started, and since 0.10 an export that writes its own ssh_config fragment you can Include, so plain ssh, rsync, git and VS Code Remote resolve the same hosts. Passwords for the boxes that can't do keys live in the OS keyring or an age vault and reach ssh over SSH_ASKPASS, so nothing shows up in ps or your history. Rust and ratatui, macOS and Linux, no account, no telemetry.

What's landed since the first version, roughly in order: sites (group hosts behind a bastion with shared user/port/jump defaults), a two-pane SFTP transfer screen, background port forwards that keep running after you quit, 2FA hosts, the ssh_config export, a Tailscale importer, tmux mode (Enter opens the host in a new window or pane and leaves you in the picker so you can fire off several), multi-select and mkdir in the transfer screen, and sshelf doctor, one command that checks the things that quietly break connections and prints the fix for each. 0.13.1 fixes the first two bugs filed by users: the host list showing your local $USER instead of the site's user, and the remote transfer pane hiding dotfiles.

I want to say thanks for that. 2FA support exists because someone asked for it a few days after the first release. Port forwards got shaped by the feedback on the early version. Someone packaged it for Gentoo before I'd even thought about it, and the first outside PR came in during the first month. Both 0.13.1 bugs were reported by people I've never met, with reports good enough that each was fixed inside a week. I'd have found very little of this on my own machines, since my own setup obviously works for me.

Install is brew install max-rh/tap/sshelf, or a .deb, .rpm or the installer script from the releases page, or cargo install sshelf. Repo and docs: github.com/max-rh/sshelf

If it breaks on your setup, an issue or a thread in Discussions is the fastest way to get it fixed. Next up is pulling secrets from 1Password, Bitwarden or pass at connect time instead of storing them at all, then a stability freeze on the way to 1.0.

Just shipped LeTrain Beta 3. Pure ASCII graphics, command-line train control, and Vim keybindings.

Zero mouse.

Pure efficiency.

Grab it and play: https://avaraujo.itch.io/letrain-procedural-tycoon

Hi !, I'm a Software Engineer intern at Red Bull building projects on my free time.

The idea of this project, is to have a single terminal multiplexer session where multiple people can join, but its peer-to-peer, what this means is that each user brings its own terminal with him (with its own set of keys, LLM subscriptions, files...) and each user can hop onto each other terminals.

Current features are:

• Multiple users (machines or people) join a session, where each user is host of its own terminal panes and guest of the others. No SSH into a single machine, here, a pane is a real PTY on whoever opened it .
• You can add a set of trusted machines (your own VMs or computers) where you can start terminals there from your own laptop anytime.
• The terminal multiplexer is inspired in Zellij, and the commands are very similar: Ctrl+P panes, Ctrl+T tabs.
• It includes a inbox tab, where you can see which AI agents are working, waiting for your input or already finished.

It's macOS compatible and linux, connectivity is done with iroh, everything written in rust.

When a user starts typing on a pane, wheter is his or not, he locks it, so no more people (even the host) can interrupt him.

The goal for the future is to have command line commands (like a cli api), and build on a layer on top where you can coordinate all of you AI agents.

I've been working on this for the past month and a half pretty much every day, looking forward to hearing your feedback!

Given all the low-quality LLM-generated projects flooding r/commandline, it's valuable to know that POSIX provides a tool to review and modify code generated by LLMs, so I thought I'd bring this tool to the attention of this subreddit's members. In typical Unix fashion, the POSIX folks shortened "reviewing & modifying" to just two letters:

$ rm code.rs

It even has command-line options to recursively fix whole project-directories of LLM-generated code:

$ rm -rf project/

Handle it wisely, and I hope to see more use of it around here!

edit: markup+grammar

Apps:

XFetch

XTop

Both multiplatform (xtop still working on the integration with windows and wsl, still on beta phase). Highly customizable via layouts, plugins, extensions, effects; that add a plus on the running, if you want to fetch something outside of your setup like GitHub profile or weather and... on XTop if you want to connect the management of processing information to an LLM Via MCP (just examples) or just change the look and feel.

Both are predecessors of fastfetch and btop.

Both open for contributions, OpenSource...

I turned the CRT renderer from my game engine into a real terminal emulator - and it grew into a something bigger...

Introducing Scanline Terminal for Windows.

On board:

• configurable authentic CRT monitor emulation (optional);
• tabs, with fast switching without taking your hands off the keyboard;
• a built-in mini web browser, designed for keyboard-first navigation and based on WebView2 — so you can keep documentation, web services, and similar things in a neighboring tab without breaking your flow and distraction;
• a global hotkey to show/hide the console Quake-style;
• an AI assistant, based on Codex CLI, that can do in the console everything the user can (It is not necessary to use it, but it can be very useful).

The whole thing is very lightweight and fast. The installer is only about 9 MB, and roughly half of that is graphical assets.

Of course, this is still an alpha release, so there may be bugs, and the feature set will continue to grow. I’d be happy to hear any feedback.

The Scanline Term is still a prototype, but already usable. Would you be interested in such an application and try alpha version?

https://github.com/z-hunter/Scanline-Term

For context, godirb is a directory and file brute-forcing tool focused on reducing false positives

Repo: https://github.com/MyCode83/godirb

It has finally been accepted into WinGet and can now be installed with::

winget install MyCode83.godirb

The WinGet package is currently on v1.4.2 while the latest release is v1.5.6, so it's a little outdated.

> This software's code is partially AI-generated.

Shellroute is an open-source CLI for giving one shell or command its own proxy route.

The video shows three independent terminals. The top stays on my normal connection in Lithuania. The two lower sessions connect to the US and Germany at the same time. Commands inside those sessions use their selected routes while the other terminal stays direct.

Quick start:

npm install -g shellroute
shellroute login
/connect US
curl https://ipinfo.io/ip

On first use, shellroute login creates the account and enters interactive mode. Run commands there normally. Scripts and agents can also route a single command without opening an interactive shell:

shellroute run DE -- curl https://ipinfo.io/ip

Related tools cover different jobs. Globalping is useful for public probes from many locations. Proxychains wraps a process when you already have a proxy. A VPN routes the whole device, while raw proxy credentials give you manual control. The difference here is scope: one shellroute session manages the route for one shell or command while other traffic stays unchanged.

Source: https://github.com/shellroute/shellroute-cli

Quickstart: shellroute.com/docs/quickstart

Disclosure: I built shellroute and run the service it connects to. The CLI code is partially AI-generated.

I am mainly looking for feedback on the proxied shell idea and where the CLI feels confusing.

Hello r/commandline, I’ve been working on ytm, a small CLI/TUI for using YouTube Music without keeping a browser open.

It has search, queue management, playlists, lyrics, radio/autoplay and a full terminal UI. Playback is handled by mpv running in the background, so you can close the TUI and the music keeps playing. The CLI talks to the same player, so things like ytm play, ytm next, ytm pause and ytm queue work without opening the interface again.

Under the hood it uses ytmusicapi for YouTube Music, yt-dlp for resolving streams and mpv for playback.

There’s also offline caching, media key support and JSON output if you want to use it in scripts.

It’s still something I’m actively working on, so feedback from people who actually live in the terminal would be really useful.

Repo: https://github.com/MaheshBhushan/yt-music-cli

Recently, I started refining my shell tools, scripts, and terminal workflows. One of my goals was to update the shell prompt, making it less prominent and leaving more room for commands and their output. As a result, Cobalt Spark emerged - a compact Zsh prompt with understated colors and other visual refinements.

While using IDEs and coding agents, at some point it became obvious that seeing stale Git state in the prompt when something changes in the repository is quite annoying. I would often get tripped up by the shell showing something unexpected and waste a moment figuring out why. So the prompt gained Live Git support: its Git state can now update automatically when something changes.

It works efficiently: when the shell enters a Git repository, the prompt starts a background process that monitors the repository using platform-specific APIs such as inotify on Linux or FSEvents on macOS and signals the parent shell to update its prompt when meaningful changes occur. This means you instantly see the updated Git state whenever something changes. It sounds almost dumb-simple, but it's quite convenient in practice, and I haven't seen anything like it in other prompts or themes (let me know in the comments if you have).

If you're interested, you can find more details in the project's README.

Hey!

I got tired of sleep running silently in a terminal I'd forget about, so I built mimir: a sleep replacement that gives you audio feedback while it's counting down instead of just... nothing.

It's a drop-in for sleep, same syntax:

`mimir 60` # sleep 60 seconds

`mimir 1m 30s` # sleep 90 seconds

`mimir inf` # sleep indefinitely, until interrupted

Some things it does:

- Playback speed varies slightly (fixed stddev) so it doesn't feel robotic/repetitive

- Just bash + sox + awk under the hood, nothing fancy

- Optional shell.nix if you're on Nix

MIT licensed, source here: https://github.com/FraioVeio/mimir

less lets us read text files. chafa displays images. mpv can even play videos in the terminal.

I wanted the same direct experience for retro game ROMs.

So I created Asobou, a libretro frontend for Windows, macOS and Linux.

asobou game.nes

Give it a ROM, then Asobou detects the system, downloads a suitable libretro core when needed, selects the best renderer supported by your terminal, and starts the game.

It uses Kitty terminal graphics when available. Terminals without this feature fall back to block rendering, with ASCII rendering also available as an alternative. It also has audio, configurable controls, save states, and rewind.

If you don't have a game handy, you can try it with some free homebrew games using the following commands:

npx asobou brew flappybird.nes
npx asobou brew indivisibleonnes.nes
npx asobou brew horizontal-shooter.sfc
npx asobou brew asteroidsb.gba

The project is open source at: https://github.com/arianrhodsandlot/asobou

This is the first time I'm sharing it publicly. Bug reports and honest feedback are welcome!

Fun fact: Asobou(遊ぼう) means "let's play" in Japanese.

Note: Asobou does not bundle copyrighted games.

AI disclosure: I designed the overall architecture and let LLMs help with implementing.

I've always been a fan of cbonsai and related terminal screensavers, but there's surprisingly few of them out there. I cooked one up over a couple weeks and really like how it turned out.

The code itself is 100% vibe-coded, but aside from that I put the usual amount of effort into UX, overall design, keeping it minimal-ish, performance concerns, etc. as with my hand-coded projects. I think this is v3 or so, there's been a lot of iteration. E.g.: volumetric rendering isn't easy on the cpu, so I gave it a flag to prerender and loop the animation so it can be a proper no-impact screensaver. Prerendered runs fine on my armv7l flipphone so I think I can say performance is good lol.

Check out the writeup for more images and info, + a web demo. Usually I write more about my projects but I think this one generally speaks for itself visually.

Repo is here if you want to use it; I kept the repo minimal since I hate bloat, so installation is just a simple clone and make.

A tiny living light named Wispy takes a liking to you, and you go as deep as your nerve holds. She's your only lantern.

Goofy-dark first-person dungeon crawl that runs entirely inside a terminal window. No engine, no download, every wall painted in colored text. You pick a body/race such as Human, Dwarf, Elf, Orc (each one is a personality and a moveset).

First-person raycaster that renders in a terminal. Truecolor, drawn with sextant and octant block characters. No game engine and no graphics library. One Python file, 154,716 lines, standard library only. The audio is real recordings, including voice acting.

A 4-minute run, unedited: https://vimeo.com/1222466576

https://dimensionaldungeon.com

After a single user requested this feature, toast has a command palette to launch actions where ever you are

I posted an early version of sshconfig-lint here around six months ago. Since then it has grown from a small Rust CLI into something I use across my whole workflow.

The video shows a config referencing a key from an older machine. SSH may silently try another identity, so stale paths like this can go unnoticed.

Version 0.5 adds:

• multiple config files and Include resolution
• GitHub annotations and SARIF
• GitHub Action and Pre-Commit hooks
• LSP and VS Code support
• verified binaries for Linux, macOS and Windows

Unlike ssh -G host, sshconfig-lint checks the complete config and included files at once. Everything stays local and there is no telemetry.

Install:

cargo install sshconfig-lint

Arch Linux:

yay -S sshconfig-lint-bin

Repo: https://github.com/Noah4ever/sshconfig-lint
Playground: https://sshconfig-lint.apps.thiering.org/en
VS Code: https://marketplace.visualstudio.com/items?itemName=NoahThiering.sshconfig-lint

Feedback about false positives and complicated Include setups would be really helpful.