r/CLI

Making legally binding digital signatures on linux is a hassle when using Italian smart keys. They have proprietary drivers and the desktop apps that support it barely work on linux, they are very heavy electron apps supported by private companies and with bad distribution practices (installation scripts that assume you're using ubuntu).

I made it better for me by building a Rust CLI for CAdES/PAdES digital signatures on Linux.

The tool targets InfoCert bit4id smart cards through PKCS#11 (this is the only kind of key I have so I only tested this one) and exposes a small clap-based interface capable of:

- CAdES attached and detached signing

- CAdES parallel or higher level signatures

- PAdES signing

- p7m content extraction

I'm a Rust newbie, so this was a learning project and I feel like I learned a lot. I also ended up with a tool that feels good to use and I feel is a genuinely better alternative than what I've tried before, although simpler.

I feel like this could be a nice example for anyone looking to learn more about digital signatures and rust.

AI disclaimer: No agent ever wrote code in my files. I only used LLM chats for research and asking for suggestions about libraries, patterns, and so on... I typed all my code manually and I'm aware of every line I committed.

Repository: https://github.com/buonhobo/firmina

flow v0.1.1 is out

This release is mostly about making the UI work better in more environments while cleaning up a lot of rough edges.

New in this release:

• Added a new --mini mode that shows only the live graphs. Useful for smaller terminals.
• Press m to switch between Hero, Compact, Mini and Tiny views without restarting.
• The dashboard now automatically switches to a smaller layout if your terminal isn't tall enough.
• Refreshed the UI with cleaner borders, gradients and typography.
• Added a cleaner help dialog and status bar.
• Peak throughput now briefly flashes when a new session record is reached.

--tiny also got a pretty big overhaul.

It no longer depends on Bubble Tea or terminal detection, so it now works properly inside tmux #( ), cron jobs, pipes and redirected output. --tiny --no-color now produces plain text with no ANSI escape sequences.

Also fixed:

• Daily totals not resetting correctly across month/year boundaries.
• Hangs when network counter reads failed.
• Config file creation on macOS and Windows.
• Platform-specific config paths on Linux, macOS and Windows.

If flow has been useful to you, consider sponsoring the project. It helps me dedicate more time to maintaining it and building new features.

A GitHub star, bug report, or even sharing the project is just as appreciated.

https://github.com/programmersd21/flow

https://github.com/sponsors/programmersd21

I got tired of network monitors that look like they were designed for a BBS, so I built flow. It's a real time bandwidth monitor with Braille grid waveforms, spring smoothed numbers, and glowing borders that react to traffic load.

What it does

It shows live download and upload throughput with units that auto scale from B/s up to GB/s. The waveform is a high res Braille grid scrolling at 30fps, and the borders glow brighter as traffic picks up, going from a dark idle state to bright cyan and emerald under load. Numbers are spring interpolated so they glide instead of jumping around. It tracks session peaks, flashing white when you hit a new record, and keeps a running daily total.

There are three views that adapt to your terminal width. Hero is the full dashboard. Compact strips it down to numbers only. Tiny is a single line built for tmux status bars.

Philosophy

If a feature doesn't help you understand your network in under a second, it doesn't make the cut. No CPU panels, no packet counters, no multi pane clutter. Just download and upload throughput, done well.

Usage

flow                        # hero view, auto interface
flow --compact              # numbers only
flow --tiny                 # tmux status bar
flow --json                 # one-shot JSON for scripts
flow --once                 # one-shot plain text

tmux integration

set -g status-right "#(flow --tiny --no-color)"
set -g status-interval 1

Install

go install github.com/programmersd21/flow/cmd/flow@latest

or AUR:

yay -S flow-network-monitor-bin

or homebrew:

brew install programmersd21/flow/flow

Pre-built binaries for Linux, macOS, and Windows (amd64/arm64) are on the releases page.

It works with zero config out of the box. If you want to tweak the refresh rate, history length, or units, there's an optional TOML config at ~/.config/flow/config.toml.

Platform support

It runs on Linux (/proc/net/dev), macOS (sysctl), and Windows (GetIfTable2, no admin needed). Idle CPU stays under 1%.

Links

Source and demo: https://github.com/programmersd21/flow

---

Would love feedback, especially on the tiny/tmux mode. Curious if the info density is right for people running it in a status bar all day.

Hey folks,

Just wanted to share a quick milestone that blew my mind today. I launched SimUtil about 4 months ago, and I just crossed the 500-star mark on GitHub!

To be honest, I never thought it would reach this many people when I first started. I'm incredibly grateful for all the support, stars, and feedback.

I'm currently working hard on developing new updates and improving the tool. Thank you all so much for making this happen! 🙏

🔗 GitHub Repository: https://github.com/dungngminh/simutil

So I wondered sometimes, how little info we have when we install NPM packages.. so I built revera... its a npm package scorer, but on steroids. It uses a complex sophisticated algorithm (still not perfect, but near-perfect) that nails at ranking NPM packages.. it gives every package a score and the score is determined on criterias such as maintainability, trust, package releases, downloads, much more..

the audit command scans the working directory for

it has the following extra features:

• logging in with github for higher rate limits
• why command for explaining a certain package's score
• doctor for checking if everything is working
• caching system which lives for 24h on local machine
• and a customizable config

It would mean the world to me if you all could try it out and give feedback (bad or good)!

github repo: https://github.com/aaravmaloo/revera

npm package page: https://www.npmjs.com/package/@aaravmaloo/revera

The whole idea is one Ghostty window that shows every pane at once. I usually have a bunch of things running across projects — a localhost dev server here, two or three Claude Code sessions there — and I wanted to see all of them side by side in a single window instead of tabbing between terminals. That's the default view: the full grid, one row per repo.

From there, Opt+1 through 9 focuses the matching pane, or you can just click it with the mouse. Cmd+1 through 9 focuses AND zooms it fullscreen when you want to actually work in one, and Cmd+0 drops you back to the overview of everything.

Setup is one script — it installs tmux if you don't have it, drops in the tmux.conf, and appends the Ghostty keybinds. macOS + Ghostty only for now.

Makes it very easy to work on multiple projects at the same time.

Repo (MIT, demo in the README): https://github.com/philmard/mygrid

Hi! So Postman was eating 2gb of ram just to send a GET request, and Insomnia was forcing me into an account. Bruno was close to what I wanted, plain YAML files on disk, no account nonsense, but I live in the terminal and wanted something I could use without a mouse, so I built Noodle.

It is a TUI REST client. Requests are .yml files on disk. You browse collections in a sidebar, edit requests inline, swap environments at runtime, send them, and save changes back. No accounts. No telemetry. Just YAML files you can commit to git.

What works:

• Full request lifecycle, browse, edit, send, save
• Create, edit, delete and nest requests on folders
• Inline editing for url, headers, params, body. Keyboard-first, customizable keybindings at ~/.config/noodle/keybinds.yml
• Basic, Bearer, API Key built-in authentication
• Environment switching with $var substitution, cycle environments at runtime without restarting
• Send JSON body, multipart form data, URL-encoded, raw text, binary uploads
• OpenAPI 3.x and Postman importer (CLI only for now, UI is on the list)
• Tab to cycle focus between sidebar, request pane, response pane
• f1 pulls up a keybinding cheatsheet

Not there yet: pre/post scripts, assertions, runner, autocompletion, collection export and other features, but they are all on the roadmap.

Install:

curl -LsSf https://noodlerest.dev/install.sh | sh

Repo: github.com/wilfredinni/noodle

Docs: https://noodlerest.dev/docs/

Roadmap: https://noodlerest.dev/roadmap/

I built this for myself but figured others might want something similar. Feedback is greatly appreciated.

Edit: some errors on links and repeated features

I recently built VinMail, an interactive CLI mail manager written entirely in Bash that sits on top of msmtp.

It lets you manage multiple email accounts from a terminal interface, compose emails with attachments, switch accounts instantly, save drafts, reply to existing emails from .eml files, and optionally GPG-sign messages. VinMail builds complete RFC 2822/MIME messages itself in pure Bash and sends them directly through msmtp, without requiring a graphical mail client or mail daemon.

The interface supports arrow keys and j/k navigation, while email bodies are edited using your preferred $EDITOR.

GitHub repo: https://github.com/VintellX/vinmail

If this looks interesting, give it a try and let me know what you think. Feedback, bug reports, feature requests, and contributions are all welcome. Thanks for checking it out! :)

Like VinMail? A ⭐ on GitHub would mean a lot. ^_^

Hey r/rust,

Sharing a side project: Runx, a small CLI that reads a runx.toml config,

downloads the exact runtime versions your project needs (currently Node.js

and Python), caches them under ~/.runx, and runs your command with an

isolated PATH — no global installs, no shell rc changes.

Example config:

[runtimes]

node = "20.11.0"

[run]

dev = "npm run dev"

Then just `runx dev`.

Rust-specific things that might interest this sub:

- Single static binary, no async runtime (blocking I/O via ureq — didn't

see a need for tokio in a CLI that mostly waits on one download at a time)

- Cross-platform archive extraction (zip/tar.gz/tar.xz) with path traversal

guards during extraction

- GitHub Actions CI runs real end-to-end smoke tests on Linux/macOS/Windows,

not just cargo test — actually downloads a runtime and executes a command

on each OS

- Ran into an interesting bug: my GitHub API retry logic only retried on

request failure, not on successful-but-truncated JSON bodies. Fixed by

moving the decode inside the retry loop.

It's early (v0.1.0) — Node and Python only so far, no checksum verification

on the install scripts yet, no auto-detection (you write the config

yourself). Would love feedback on the crate choices, error handling

approach (anyhow + custom error types), or anything that looks off in the

architecture.

GitHub: https://github.com/aryankahar31/runx

Most of my workflow already lives in Neovim — code, prose, notes, scratchpads. The piece that always lagged was querying the notes. Plenty of tools let me grep them; almost none let me ask things like "all the drafts under tasks/q2 that link to people/alice" without leaving the buffer.

Turns out you can. IWE is a Rust binary (LSP server + CLI) that treats a directory of .md files as a queryable graph. Install once, use it from the editor over LSP and from the shell over :!.

The query language is small and reads like Mongo's:

iwe find --filter 'status: draft, priority: {$gte: 8}'

iwe find --filter 'author.email: {$exists: true}'

Frontmatter is the schema. Markdown links are the relationships — and there are two kinds, which the engine actually distinguishes:

• An inline link in body text is a reference: "see also."
• A markdown link alone on its own line is an inclusion link: containment. The linked document becomes a structural child of this one.

Each gets its own pair of operators:

iwe find --references people/alice # docs that link to Alice inline
iwe find --included-by tasks/alpha:0 # everything under alpha's tree (unbounded)
iwe find --included-by tasks/alpha:0 --references people/dmytro --filter 'status: draft'

That last line: drafts under the tasks/alpha subtree that also mention people/dmytro inline. Three relationships, three flags.

The same predicates drive iwe count, iwe update, iwe delete. Bulk-set frontmatter from the shell:

iwe update --filter 'status: draft, reviewed: true' \
--set status=published \
--set published_at=2026-05-02

update and delete require an explicit --filter (no accidental whole-corpus rewrites). --dry-run previews.

From inside Neovim, this composes two ways.

The same iwe binary is also a markdown LSP server, so the editing side feels like working in code:

• gd — jump to linked notes
• gr — find references / backlinks
• K — hover preview of a linked note without opening it
• Code actions for extract section to a new file, inline a referenced note, rename
• Auto-complete for link targets as you type
• Inlay hints showing parent context and link counts

There's a dedicated plugin — iwe.nvim — that wires the LSP up and adds Telescope integration with hierarchical path search (notes show as Journal ⇒ 2026 ⇒ Week 18 ⇒ Mon notes). Lazy / packer / vim-plug all work.

For querying, you don't need a special integration — the CLI is enough:

• Output is plain text — pipe to jq, fzf, telescope, whatever.

Same install handles both: cargo install iwe and you have the LSP server + the CLI. The LSP runs against any folder of .md files; the CLI queries the same folder.

Side note: this also turns out to be a decent shape for AI agents. They use the same CLI you do, see the same files, and git log is your audit trail for whatever they touch.

Repo: https://github.com/iwe-org/iwe · Plugin: https://github.com/iwe-org/iwe.nvim

Curious what the heavy notes-in-Neovim crowd thinks, especially on the inclusion-vs-reference link split.

Ask questions across your Markdown notes using a fully local Graph RAG engine. Built for Obsidian vaults, works with any folder of Markdown files. Extracts entity-relation triples from wikilinks & YAML frontmatter, retrieves answers via hybrid search (vector + BM25 + temporal). Multilingual. No cloud. Runs on Ollama.

https://github.com/benmaster82/Kwipu

I posted this days ago but the 'automated admins took it down saying was generated by AI' as the formulation was maybe too academic. Trying now with other words.
Short storry: I wanted to generated python glue code for webgpu based on webgpu header. After exploring libclang and generating correct results, I wanted something more generic, more 'built in into C++'. At the beginning I thought will be easy with constexpr compile time tricks, but turned out the compile time 'runtime' is very restrictive. And I solved the challenges with ycetl. https://github.com/zokrezyl/ycetl

This is not a toy project, it is work of couple of months, fight with windmills of compile time runtime. If you see issues that can make it production ready, please share.

skl does not try to manage your skills, and you don’t need node on your machine - just one binary and one command to install multiple skills from a remote repo:

brew install abogoyavlensky/tap/skl
skl add https://github.com/anthropics/skills

Github: https://github.com/abogoyavlensky/skl

Hey!

I've been building vibez, a TUI Apple Music player for Linux and MacOS

v0.3.0 is out today!

Here's what changed:

Play Next

Press Shift+Tab on albums, artists, recommendations, or tracks to insert them right after the currently playing song.

Better queue management

You can now reorder the queue with Shift+↑/↓ (or **Ctrl+↑/↓**). The selection automatically follows the moved track, making queue editing much smoother.

Keyboard shortcut docs

The README and in-app help now document Tab (add to queue), Shift+Tab (play next), and Shift+↑/↓ (move in queue).

More reliable playback

Improved Widevine DRM support for headless playback and macOS, fixing playback issues and CONTENT_UNSUPPORTED/"no DRM" errors in Chrome-based streaming.

Better authentication

Expired Apple Music user tokens are now detected during startup and automatically trigger the re-authentication flow instead of leaving the player stuck on initialization.

Fixes

* Gracefully handle empty Apple Music libraries and Favorites (404 responses now return empty collections instead of failing).
* Fixed equalizer keyboard conflicts, so navigation keys no longer interfere with playback controls while the EQ panel is open.

Install, instructions and more: https://github.com/simonepelosi/vibez

Feedback and issues are very welcome. If you're enjoying vibez, a star on GitHub would mean a lot!

Hey All. I just released latest the dskDitto. dskDitto aims to be a simple, blazing fast duplicate file finder and manager. It's written in Go so its quite portable. It has many useful features:

1. Very fast. Can crawl SSDs with millions of files in under a minute.
2. Display results in a sleek TUI (default) or a Raylib based GUI (pass --gui). Of coursel you can dump in various text formats (JSON, etc).
3. It can perform similarity hashing to determine if files are “nearly duplicates" i.e fuzzy mode.
4. Safely handles deletion and sym-link conversion
5. UNIX hard-link aware
6. Hashing algorithms currently Blake3 and Sha256 which are optimized for MacOS and Linux
7. Support for file restore if yo accidentally blow away a bunch of dups.

More features and performance improvements are coming. Check out the README.md

Trabajo constantemente con repositorios personales, del trabajo y de clientes.

Uno de los problemas que más me molestaba era tener que cambiar entre cuentas de GitHub. Entre credenciales, autenticaciones y configuraciones de Git, terminaba perdiendo tiempo en algo que debería ser transparente.

Así que decidí crear una herramienta para resolverlo.

Se llama GAM (Git Account Manager)

¿Qué hace?

• Permite gestionar múltiples cuentas de GitHub.
• Autenticas cada cuenta una sola vez mediante OAuth.
• Cambias entre ellas con un solo comando.
• git push, git pull y git clone funcionan sin volver a iniciar sesión.
• Puedes asignar alias como 'work', 'personal' o 'cliente'.

Ejemplo:

gam add
gam use work
git push

Repositorio:
https://github.com/miguelbalvin-dev/gam

Instalación:

npm install -g @gamcli/gam

Es la primera versión pública, así que me gustaría recibir feedback de otros desarrolladores.

¿Qué funcionalidades creen que harían falta? ¿Cómo manejan ustedes múltiples cuentas de GitHub?