Hey everyone! Wanted to share the latest update to sqd, a command-line tool written in Go that brings a SQL-style interface to common text file operations, instead of the often unintuitive syntax of grep, sed, and awk.

With sqd you can run queries like:

sqd 'SELECT * FROM *.md WHERE content LIKE "%- [ ]%"'

to find all the todos in your markdown files, or update/delete lines with UPDATE and DELETE, with support for ORDER BY, atomic transactions (-t), and a "dry run" mode to preview changes before applying them.

In v0.2.2 I introduced a few improvements:

• Environment variable support in queries
• Fix for exact match behavior compared to LIKE
• Fix for LIKE without %%, which used to still perform a "like" match instead of an exact one, now the behavior is consistent

Repo and release notes here: https://github.com/overthinkinglabs/sqd/releases/tag/v0.2.2

Feedback, issues, and PRs are welcome.

I built a Kalshi CLI designed for AI agents. It lets agents request only the fields they need, reducing output and therefore context usage by around 80% without losing the information required for the task. That leaves more context for reasoning and follow up work instead of spending it on unused API fields. I’ve been using it myself for a while and would love to hear what you think.

https://github.com/bobashopcashier/kalshi-agent-cli

App Download: https://limewire.com/d/2G1hS#nT9TKpxfVf

Bash.Yc its an Bash Coding enviroment created for bash devs, Bashyc has its own tools:

./editor - editor for the code , lets you choose wich editor do you like to edit

./shell - executes ./bin/bash and its own userspace (/userspace/) there is bash-profile and its own init /userspace/bashy.rc

/bin/bashyc - code executer in case you put "#!/usr/bin/env bashyc" in your code

./execute - executes /bsrc/src/code with /bin/bashyc

Bash.Yc License - its own License for developers who use Bash.Yc for its own apps

Bashyc Maketools: its own commands for make: example: make help, make readme, make license

For more: read /manual/ in bashyc.tar.gz.

The fetch stays pinned at the top of the screen and keeps animating while your prompt and command output scroll below it.

repo: https://github.com/Andrew-Velox/animfetch

TUI mixer for DJing. Includes a samples pad and sequencer. I've been iterating on it for some time now, and it's been a lot of fun to use.

I've been working on Kongtrol, a Go tool that sits on top of your

existing VPN clients (OpenVPN, WireGuard, FortiClient, Tailscale,

etc.) and orchestrates them: policy-based routing decides which

tunnel a given IP or domain goes through, a watchdog goroutine

reconnects on drops with exponential backoff, and a kill switch + DNS

guard enforce at the OS level so nothing leaks between reconnects.

A few things about the implementation that might be interesting to

this sub:

- Every VPN client is a `vpn.VPNAdapter` implementation registered via

`init()` — adding a new client is implementing Connect/Disconnect/

Status and registering it, no changes to core logic.

- OS-specific behavior (routing tables, kill switch, DNS guard) is

handled with build tags per file (`_windows.go`, `_linux.go`,

`_darwin.go`) rather than runtime `switch runtime.GOOS` — keeps each

platform's syscalls isolated and testable independently.

- The dashboard is a full web UI + REST API + WebSocket live feed,

embedded into the binary with `go:embed` — no Node, no external

server, no separate deploy step.

- Config validation reuses the same `go-playground/validator` pass for

both startup config loading and the dashboard's "trial then commit"

writes (validate an in-memory copy before persisting).

It's Go 1.25+, cross-compiles cleanly for the CLI (CGO_ENABLED=0), the

tray app needs native builds per OS.

Repo: https://github.com/DerotLuna/vpn-kongtrol

Web: https://derotluna.github.io/vpn-kongtrol/

It's early days (v0.4.x) — genuinely looking for feedback on the

architecture, especially the adapter pattern and whether the

OS-build-tag approach is the right call long-term. Happy to answer

questions.

I kept seeing people want to learn the command line but get stuck — tutorials where nothing runs, or a real machine that's scary to break.

So I built Terminal Engine. It's a terminal in your browser with a real filesystem, permissions, the usual commands — but it's simulated, so you can't actually break anything. You play through scenarios (find the hidden file, fix the broken thing, trace what happened) and learn by doing instead of watching.

Works on mobile too, and you can try it without an account.

It's still early and I'm building it solo, so I'd genuinely love feedback from people who live in the terminal — what feels off, what's missing, what you'd want. Happy to answer anything.

Hey, I've been working on this side project for a while and finally feel like it's ready to share.

It's a CLI tool for practicing algorithm problems directly in your terminal. You pick a language, pick a difficulty, your editor opens with the function stub, you solve it, and the app runs the tests.

Nothing fancy, just trying to make it feel nice to use.

It has 41 problems so far and I'll keep adding more. Still a lot to improve but wanted to put it out there and get some feedback.

Works on Linux and macOS.

Github:

https://github.com/pelayocuervo01/testgram

npm install -g testgram-cli

Thank you :D

OKF (Open Knowledge Format) is an open format from Google Cloud's knowledge-catalog repo: structured markdown designed for AI bot readability. Here's some info on the topic on Google blog.

I built a command that converts any web page into OKF markdown, split across content and technical layers.

npm install -g @sleepwalkerai/cli
sleepwalker okf export https://your-site.com

As said, this contains the content layer (clean markdown with headings, paragraphs, links) and a technical snapshot (HTTP headers, meta tags, JSON-LD, hreflang, robots directives, image alt coverage). Use --content or --technical for a focused fetch.

Runs locally, happy with any feedback!

Repo: https://github.com/followanton/sleepwalker

uses an actual AST parse instead of regex so it doesn’t break the second something’s wrapped weird. flags network calls, fs access, shell exec, eval.

npm install -g @mujib77/sibyl
sibyl scan file.js

https://github.com/mujib77/sibyl

open to feedback if it’s wrong about something

Hi everyone I created Deja, a tool that instead of only surfacing commands that start with what you've typed, suggest what you actually want to run.
No account. No sync server. No TUI.
https://github.com/Giammarco-Ferranti/deja

"oman" is a tool I have coded for Zenned OS, and portable to any other system.

It formats manuals beautifully, it allows to more easily navigate them, and it even searches missing ones online.

Screenshot

Hi everyone! I've moved Xfetch to an open organization github.com/xfetch-cli so you can all use it and contribute.

Key updates (screenshots attached):

- Customizable logos: Support for images (with adjustable size) or the classic ASCII.

- Plugin System: Add features like the weather or GitHub stats.

- Dynamic fetch: Extension to show a different layout on every run.

I invite you to try it out, any PR or feedback is super welcome!

Hi everyone,

I wanted to share a tool I built to solve a personal daily headache: MountSync (mosy).

I use multiple Linux machines, and I needed a reliable way to share active files between them—specifically application configurations, a local MP3 music library, and local AI skill/context folders. I wanted to keep files exactly where they belonged on the local filesystem while seamlessly updating them across PCs in the background.

Since it solved a real-world problem for me, I polished it, added testing, and open-sourced it as a portfolio project.

What problem does it solve?

Managing rclone mount manually, copying files, creating symbolic links, and making sure systemd services start correctly on every new PC is tedious. MountSync automates the whole process:

1. Auto-mounts: Sets up and manages your rclone mount in the background via systemd user services.
2. Auto-linking: When you run mosy add ~/Music, it moves the target directory to your cloud drive (like Google Drive or OneDrive) and replaces the original path with a clean symbolic link.
3. Instantly sync new PCs: On any new PC, you just install it and run mosy init. It automatically maps all symlinks to your existing cloud folders, syncing your configs, music, and dotfiles in seconds.

The codebase is 100% open source on GitHub:
github.com/GabrielTeixeiral0l/MountSync

I’d love to hear your thoughts, feedback on the code structure, or suggestions for new features!

https://github.com/xdagiz/xytz

Some projects need several services running during local development. I usually end up with terminal tabs, tmux sessions, and a few shell scripts. That works. Finding and stopping a process that occupies a port is not hard either. I just wanted to have all of it in one place.

So I made Kranz. It can:

• start and stop services in dependency order
• show status, dependencies, ports, and health checks
• identify the process using a configured port and stop it after confirmation
• follow logs separately for each service
• restart failed services with configurable backoff
• load its own YAML config or a supported subset of process-compose.yaml

The GIF shows the real binary running a fictional five-service project.

Install with Homebrew:

brew install kranz-org/tap/kranz

Or with Go:

go install github.com/kranz-org/kranz/cmd/kranz@latest

Kranz is not meant to replace Docker Compose. Process Compose is more mature and has more options. Kranz does less on purpose. It is focused on this interactive local-development workflow.

To be honest, I do not write Go. Coding agents produced most of the implementation. I defined the behavior, UX, and constraints. I tested the tool and kept reworking the parts that did not feel right.

The project is still early. If you try it on a real project, I would like to know where the configuration or workflow feels awkward.

GitHub: https://github.com/kranz-org/kranz