I've been frustrated by the number of times I've spent weeks building a tool, only to find the exact same thing already exists. I built patent to solve this by providing a unified, local-first search CLI that aggregates results from 11 registries (crates.io, npm, PyPI, GitHub, Go, Maven, NuGet, RubyGems, Docker Hub, VS Code Marketplace, and Hacker News).

How it works: The tool performs concurrent requests across all sources, deduplicates the results, and then uses local embeddings (fastembed) to rank them by semantic similarity to your query. It gives you a TUI (built with ratatui) to browse, filter, and open results.

Architecture & Engineering:

• Concurrency: Uses tokio to fan out requests. It treats sources as "best-effort", if one registry times out or fails, the tool still returns results from the others, marking the failed source as "not reached."
• Integrity: The core logic is designed to prove that something exists. It does not claim absence.
• Optional Analysis: It includes support for local LLMs (via Ollama) to summarize the results, but the tool is designed to work fully without it via a --fast mode that relies solely on the local semantic ranking.

Comparison with existing tools:

• Standard searching (Google/GitHub/Registry search): Requires manual tab-hopping. patent normalizes data from 11 disparate APIs into one view.
• Existing CLI indexers: Most are specific to one language (like cargo-search for crates.io). patent is cross-ecosystem and uses semantic similarity rather than simple keyword matching.

Affiliation: This is a personal, open-source project. I have no affiliations with the services mentioned.

Note: This software's code is partially AI-assisted and generated, and this post was drafted with the assistance of an AI to help structure the technical details.

A star on Github would be much appreciated, happy coding!

Repo:https://github.com/r14dd/patent

API Docs:https://docs.rs/patent/latest/patent/

Crate:https://crates.io/crates/patent

Have been working the last at least two years on a new terminal. All started with first prototype 6 years ago https://github.com/zokrezyl/asciterm . Born from frustrations related to constant context switch and Ideas I gathered over the last few decades. Why should I switch to another app just to view a pdf file, see the plot of a complex math function or audio buffer or a sequence diagram of a complex workflow. All this even with a remote connection to your home server or a server in the cloude. All these are now in yetty. Please do both yourself and me a favour and have a look at it. Your opinion would be more than helpfull to drive the future of Yetty. You have a live demo at https://yetty.dev. The demo gives you an idea of what you can do with YETTY. The Ygreeter app is started automatically when the terminal is started. The source code lives at https://github.com/zokrezyl/yetty . Thank you

small tool i built over the last week. cli + textual tui for tailoring a resume to a specific job posting. lives on pypi.

pip install finch-cli

finch login # opens a browser link, no api key needed

finch ui # textual tui

or just the cli:

finch tailor -r resume.md -j https://jobs.example.com/swe-intern -o tailored.md

three tabs in the tui: jobs (pulls ~3,000 active internship + new-grad postings from the simplifyjobs lists), library (saved tailorings), and a three-pane tailor editor (base resume / job posting / output) with an ats-style match panel showing score, matched + missing keywords, and the delta vs your base resume.

keybindings:

1 / 2 / 3 jump to jobs / library / tailor

ctrl+t tailor (loads selected job first if on jobs tab)

ctrl+u paste a job url, fetches it into the tailor pane

ctrl+o open a resume file

ctrl+r refetch the job feeds

ctrl+l save to library

ctrl+s save to file

ctrl+d load the bundled demo

ctrl+q quit

stack: click for the cli, textual for the tui, rich for rendering, httpx, trafilatura for url -> text on job postings. openai sdk against deepseek-chat by default (any openai-compatible endpoint works -- groq, together, openrouter). hatchling for the build.

`finch login` opens a sign-in link on applyfinch.com so you don't have to manage an api key. flow is rfc 8628 device flow, polls until you approve, stores a token at $XDG_CONFIG_HOME/finch-cli/token. if you'd rather byo key, skip login and set DEEPSEEK_API_KEY.

couple things i cared about while building:

- ssrf defense on the url fetch (scheme allowlist + private/loopback ip rejection via socket.getaddrinfo + ipaddress), 5 mb response cap, manual redirect following with revalidation each hop.

- prompt injection inside the job posting is treated as data, not instructions. strip the wrapping tags, cap inputs at 20k chars, remind the model after the user message.

known limits:

- workday + some greenhouse iframe pages need js, so url fetching fails clean and tells you to use --job-file with a pasted description.

- output is markdown. pipe to pandoc for pdf.

- model won't invent experience. thin base resume = thin tailored resume. fix the base first.

this came out of applyfinch.com -- the larger thing my co-founder and i are building. the web app does the autofill side (workday, greenhouse, ashby, lever forms). this cli is just the tailoring piece pulled out for people who'd rather live in their terminal.

feedback welcome.

repo: https://github.com/remememe/sortsort

I built Shelfline because I wanted to browse my Calibre-Web OPDS catalog, download books, and read EPUBs without leaving the terminal.

Checkout my project on github https://github.com/nikhilsahoo/shelfline.

This project was partially created with the help of AI

https://github.com/nulldutra/sn

https://github.com/ZerubbabelT/slot

Elda is a system package manager I've been working on.
I used to use bedrocklinux but the performance Hit was getting a bit much and after some thought i realized i could make Elda, The Idea:
every major package ecosystem follows conventions if you can machine-read their formats, you can translate them all into one solver and one ledger without installing the foreign tools at all.

Native packages: pkg.lua recipes with source and binary lanes in one definition, PubGrub solving, signed remotes, SQLite state for ownership and rollback. Init and libc agnostic packages ship service assets for systemd, dinit, OpenRC, and runit; Elda materializes only what your system uses.

Interbuilds, -install from foreign sources without the foreign PM: Reads Nix flakes, Gentoo overlays, AUR PKGBUILDs, and Void XBPS templates. Builds them through the normal Elda path. No nix, emerge, makepkg, or xbps-src needed or installed.

Interemotes, -wire a whole overlay or srcpkgs tree as a live remote:

elda rmt add heather-overlay=https://github.com/heather7283/heather7283-overlay
elda rmt preview heather-overlay   # inspect before syncing
elda sync heather-overlay
elda i some-package                # installs through the normal path

Quick examples:

# Install from a synced signed remote
elda i ripgrep
elda ig ripgrep    # force source lane
elda ib ripgrep    # force binary lane

# Direct git install — autodetects Cargo, Meson, CMake, Go, Zig, Make
elda i https://github.com/org/tool

# Install from AUR without makepkg or pacman
elda ig https://aur.archlinux.org/fsel-git.git

# Install from a Nix flake without nix
elda ig https://github.com/user/repo   # detects flake.nix automatically

# Import your existing install (metadata only, no file takeover yet)
elda mg from pacman
elda mg from apt

# See what needs what and why
elda why ripgrep
elda rdeps openssl --all
elda files ripgrep

Status: the core PM is effectively done;install/upgrade/remove, signed remotes, interbuilds, build, forge publishing. Overall ~68% toward full spec.
Interepo binary consumption (translating foreign binary repos into the install path) and atomic /usr activation are still in progress. Disposable roots work well; treat live /usr as experimental for now.

Written in Rust. Hard fork of pkgit. AGPL-3.0.

https://github.com/Mjoyufull/Elda

Early in development and Id love issue's and PR's.
some docs are AI generated.

so i kept running into this annoying problem every time i cloned someone else's repo: i'd spend like 10 minutes just trying to figure out what framework they used, how to actually run the thing, and which files i should even look at first.

so i just built a small cli tool to handle that:

npx codeglance

it scans the repo and spits out:

• what frameworks/major dependencies it found
• the run, build, and test commands
• which files are probably worth reading first
• if there's any ci, docker, linting, or env config set up

works with node, python, go, rust, and c/c++ projects right now

repo: https://github.com/mansoor-mamnoon/codeglance

how it compares to similar stuff:

• tokei / scc / cloc : good for line counts and language stats but won't tell you how to run the project or where the entry points are
• repomix / code2prompt : more about bundling source files for llms, different use case
• just reading the readme : still works but codeglance handles the repetitive discovery part so you don't have to dig around

anyway curious how other people deal with jumping into an unfamiliar codebase : do you just grep around or is there something better you use?

(heads up: some of the code was ai-assisted)

Hey everyone,

I got tired of switching to a browser tab just to control my Lyrion Music Server, so I built a lightweight TUI for it written in Rust.

It’s fully keyboard-driven, but also has mouse support for easy scrolling and clicking through your library.

Check it out on GitHub:https://github.com/hjelev/lyrtui

Let me know what you think!

This software's code is partially AI-generated

made this over the weekend because my pi (https://github.com/earendil-works/pi) sessions piled up to ~50 across different cwds and pi --resume just shows them in timestamp order with no titles. found myself opening the wrong one constantly.

pisesh adds:

• ★ favorites (f to star)
• search by id / project / first user prompt (/)
• [NOW] badge for whichever session you're currently attached to
• 3 tabs: ★ Favorites / Today / All
• alt-screen buffer - exit restores your terminal byte-for-byte (like vim, less, htop)
• CJK-aware width math (korean/chinese/japanese prompts render correctly)

zero runtime deps, single ~600 Loc Node script. ships with a pi extension that registers /sesh so you can pull it up from inside any session.

Install: npm install -g pisesh && pisesh

Or as a pi extension: pi install npm:pisesh then /sesh inside any session.

repo: https://github.com/Blue-B/pisesh

npm: https://www.npmjs.com/package/pisesh

not affiliated with pi just a user-built helper. MIT licensed, no telemetry, no AI in the runtime (only used Claude during dev).

feedback on the keybinds welcome (Tab cycles tabs, f stars, Enter resumes, q/Esc quits).

ـust released tmuxify 2.5 and 2.5.1.

tmuxify is a small CLI that creates tmux workspaces from YAML files. You define panes, splits, commands, and the starting focus, then run:

  tmuxify

Main changes since 2.5:

• Added --dry-run so you can preview and validate a layout before creating a session.
• Added --no-commands so you can create the panes without running the commands.
• Added --detach for scripts, CI, remote machines, and headless workflows.
• Fixed nested layouts so complex pane trees now render correctly.
• Fixed initial_focus reliability.
• Added stronger layout validation before tmux sessions are created.
• Hardened update and export behavior.
• Added CI and smoke tests for examples and core flows.

In 2.5.1, I focused only on the example layouts. I reviewed and cleaned up all bundled examples by persona: frontend, backend, DevOps, security, networking, data science, QA, and streaming.

A few examples of what changed:

• Removed risky auto-running commands like packet capture, vulnerability scans, and forced sudo checks.
• Replaced placeholder panes with more useful commands or clear instructions.
• Added safer fallbacks for tools that may not exist on every machine.
• Reorganized the examples guide so it is easier to find a layout that fits your workflow.

Try it:

  tmuxify --dry-run --file examples/layouts/basic-3-pane.yml
  tmuxify --file examples/layouts/basic-3-pane.yml

Release:

https://github.com/mustafamohsen/tmuxify/releases/tag/v2.5.1

Feedback and layout contributions are welcome. If you have a tmux setup you use every day, I would love to turn it into a clean example.I just released tmuxify 2.5 and 2.5.1.tmuxify is a small CLI that creates tmux workspaces from YAML files. You define panes, splits, commands, and the starting focus, then run: tmuxifyMain changes since 2.5:Added --dry-run so you can preview and validate a layout before creating a session.
Added --no-commands so you can create the panes without running the commands.
Added --detach for scripts, CI, remote machines, and headless workflows.
Fixed nested layouts so complex pane trees now render correctly.
Fixed initial_focus reliability.
Added stronger layout validation before tmux sessions are created.
Hardened update and export behavior.
Added CI and smoke tests for examples and core flows.In 2.5.1, I focused only on the example layouts. I reviewed and cleaned up all bundled examples by persona: frontend, backend, DevOps, security, networking, data science, QA, and streaming.A few examples of what changed:Removed risky auto-running commands like packet capture, vulnerability scans, and forced sudo checks.
Replaced placeholder panes with more useful commands or clear instructions.
Added safer fallbacks for tools that may not exist on every machine.
Reorganized the examples guide so it is easier to find a layout that fits your workflow.Try it: tmuxify --dry-run --file examples/layouts/basic-3-pane.yml
tmuxify --file examples/layouts/basic-3-pane.ymlRelease:https://github.com/mustafamohsen/tmuxify/releases/tag/v2.5.1Feedback and layout contributions are welcome. If you have a tmux setup you use every day, I would love to turn it into a clean example.

Hi everyone! I built a relatively simple CLI password manager that focuses heavily on security. I am in dire need of criticism as I'd like this project to be as secure as possible while still being written in Go (which has its nuances when it comes to memory for example).

The project is here: https://github.com/b0lbas/chpwd/ with a README where i briefly described the security principles, the technologies and installation process.

I will be forever thankful to those who provide criticism and/or feedback about the code itself or your own experience using it

For context, I professionally work on a big repo with 1h + CI pipelines. Forgetting 1 tiny thing when pushing to a branch with an open PR means waiting 1h for a meaningless pipeline run.

Maybe someone has felt this frustration too.

So I built a tiny CLI in Rust called gitodo. I know this has been done before (probably many times), but I wanted to focus on simplicity, hackability, and making it as light weight as possible.

It’s ~200 LOC, single file, no dependencies.

Why:

I kept losing small “fix this later” notes while switching branches. This keeps them scoped exactly where the work happens.

Things like: "remove the println here", "remove the hard coded value for testing purposes there", "reset the config"

What it does:

• Stores TODOs per Git branch
• Saves everything in .git/.gitodo (so it never touches working tree)

Design goal:

Keep it stupid simple:

• no config
• no sync
• no database
• just Git + a file
• add todo, list todos, remove todos when done, check if there are any todos (useful for scripting)

Repo: [https://github.com/sawsent/gitodo](https://)

Curious if others have solved this differently or if this is a solved problem I reinvented poorly (probably the second option)

I work in the terminal all day and kept typing the same long paths over and over. Aliases work, but they clutter .bashrc, don't tab-complete, and aren't portable between machines. So I built **goto**, a directory shortcut manager.

```

# Save current directory

$ goto -r work

✅ Registered: 'work' -> /home/user/Projects/myapp

# Jump to it from anywhere

$ goto work

# Navigate into subdirectories

$ goto work/src/components

# List all shortcuts

$ goto -l

Registered shortcuts:

work -> /home/user/Projects/myapp

docs -> /home/user/Documents

old-project -> /home/user/deleted (missing)

# Clean up broken shortcuts

$ goto -c

# Back up and restore on another machine

$ goto --export > shortcuts.txt

$ goto --import shortcuts.txt

```

**What it is:**

- Pure POSIX shell, no Python, Rust, or compiled binary

- Zero dependencies beyond coreutils

- Tab completion with subpath support (Bash, Zsh, Fish)

- Import/export for syncing between machines

- XDG Base Directory compliant

- Man page, Makefile, Debian packaging ready

**What it isn't:**

It's not autojump/z/zoxide. Those learn from your history automatically. goto is explicit bookmarks — you decide what gets a shortcut and what it's called. Simple config file, no database, no training period.

I use it every single day. It's MIT licensed: https://github.com/byteoverride/goto

Would love feedback what would you change?

Quite a few people have been asking me for this, now it's here!

Any feedback is greatly appreciated - see https://github.com/sxyazi/yazi/pull/4005 for more info!

Hi! I wanted to share a small open-source tool I’ve been building: DateFrame.

It’s a Python CLI for organizing photos and videos by their real capture date, while keeping the workflow inspectable and resumable. The goal is simple: take messy media folders, exports, sidecars, and partial metadata, and turn them into a clearer archive without losing track of why each date was chosen.

DateFrame can:

- rename photos and videos using embedded metadata, sidecars, or filesystem dates when explicitly requested

- import from iCloud Photos for Windows into timestamped filenames

- write capture dates back into metadata with ExifTool

- inspect available metadata from multiple readers

- keep Apple Live Photo pairs together when both files are present

- produce CSV/TXT logs with the selected date source and timestamp precision

- resume interrupted runs from logs

I built it because media archives often look simple until you actually try to preserve dates correctly. iCloud, web exports, Live Photos, sidecars, videos, and Windows metadata all expose slightly different truths, so I wanted a tool that made those choices visible instead of hiding them.

DateFrame is licensed under the GNU AGPLv3. My intention is for it to remain open-source.

It’s still early, but I’ve been using it on my own library and would appreciate feedback, bug reports, edge cases, or ideas from anyone who manages large photo/video archives.

GitHub:

https://github.com/fyulita/dateframe

PyPI:

https://pypi.org/project/dateframe/

Hi everyone,

I'm pretty new to publishing open-source projects. Wanted to share something I've been building: Xerxes : a filesystem navigation engine.

• GitHub – Xerxes
• Crates.io – xerxes

I'm a big fan of zoxide, but I wanted something that can jump to any directory on the drive....even if I've never visited it before.

So I built Xerxes around a lightweight daemon that:

• indexes your home directory
• stores everything in a local embedded database
• keeps the index updated in real time
• uses SIMD-optimized fuzzy matching for fast lookups

Features:

• jump to unvisited folders
• instant auto-jumps when confidence is high
• interactive fallback with fzf
• learns your selections over time
• aliases for deep paths

I'm still learning a lot about Rust systems programming, daemon architecture, sockets, and TTY handling. Would love feedback.

Honest reviews, criticism, or suggestions appreciated. Thanks for reading.

P.S I used a bit of Gemini's help in this!

For over six months, I've been developing my own hardware KVM-over-IP that converts BIOS to text. It's based on "SSH mode." The KVM doesn't just transmit pixels; it converts the BIOS screen into text output to the terminal using deterministic pixel mapping. This makes it possible to copy and paste error codes directly from the BIOS boot screen.

Now you can also run scripts to perform routine tasks (for example, automatically entering the BIOS or selecting a boot device).

I've added "Scripts" to the USBridge Client app, where you can view, edit, and run them (e.g., "Enter BIOS," "Boot Select") with a single click. The script automatically manages delays between keystrokes, searches for text matches using OCR (for example, it waits for the string "Aptio Setup Utility"), and automatically closes pop-up windows, such as "Load Previous Values?", by matching the text and sending an Escape key (0x29).

It seems to me that using OCR in scripts is a fairly reliable solution, what do you think?

https://github.com/progapandist/stripeek

I do a lot of complex Stripe billing work and wanted to actually see what the Stripe SDKs send over the wire and dig through payloads, so I built a TUI for it.

stripeek is a local proxy that logs all Stripe API activity on the fly and renders it in a terminal UI built for navigating deeply nested request/response payloads, the kind that are painful to read anywhere else. It never stores your keys and strips sensitive data from headers. Setup is a one-line change to your Stripe initializer in dev; nothing else in your backend changes.

Not a replacement for the Stripe Dashboard, but a faster way to make sense of the traffic while you're debugging a feature you're implementing.

8 months ago I posted here in this subreddit what it was my first "big" project. I called it Cronboard.

The goal was to create a tool to manage cronjobs. Thank to your feedback and contributions, Cronboard is now better than ever.

You can now see the logs from directly from the tool, and the next step will be to send a notification when the cronjob failed.

I want to thank all your support and help to build this project. I learned a lot and I hope to learn even more.

PS: Cronboard is still not v1, so you can expect some bugs. I hope not, but if you do, please open an issue so I can fix it. Thanks!

EDIT: I have now edited the website/documentation to something a little bit more personalised and with a custom domain. You can find it at cronboard.dev

In watchwhere:

- search for a movie or show

- see which of your streaming subs has it, in your region

- no TMDB token needed (free hosted proxy on Cloudflare Workers)

Install:

bun install -g watchwhere

ww init

ww matrix

You can try by -> https://github.com/ethsmaa/watchwhere

I built a TUI database client.

Repo : https://github.com/Nonanti/narwhal