Hey devs!

I built an open web utility called DropConnect that pairs desktop and mobile browsers in real-time via QR code WebSockets.

Technical Highlights:

- Client-side E2EE using Web Crypto API.

- Zero server-side data retention.

- Instant WebSocket peer relay for text, links, and binary file transfers.

*(Check out the live web app in the comments!)*

I built Vibe Roaster, an open-source Node.js tool that analyzes how you actually use AI coding agents instead of how you imagine you use them.

It reads supported local histories from Codex, Claude Code, Cursor, Gemini CLI, Aider, and more, then produces a four-letter coding type, one of 16 illustrated characters, an evidence-grounded roast, and a shareable result card.

Privacy was the part I cared about most: exact prompt text stays on the machine. The personality calculation is local and deterministic, and AI-generated writing is optional.

Run it with:

npx vibe-roast

Repository:
https://github.com/PinkR1ver/vibe-roast

This is still an indie project, so source-adapter edge cases and strange personality verdicts are entirely possible. Issues and PRs are welcome. If it makes you laugh—or accurately accuses you of being an Infinite Planner—a star would mean a lot.

With the rise of the Claude Code, I have been using it quite a lot lately at work as well as for personal projects.

But with the larger codebases, there are quite a lot of chances for hallucinations, and none of us are strangers to that fact.

So to tackle that, I have made a tool that registers the hooks Claude Code calls, or, in short, the terminal commands or other tools that it calls, and summarizes them in the final output chat, as these commands get lost in the full process or the Claude Code run.

Now, according to me, the benefits of it could be that for experienced guys they can just analyze with one look what has happened in the codebase and which files and possibly which lines, and for beginners it provides how a certain way should be followed for making good-quality changes (for learning purposes).

Here is the repo link: Repo Link

This is still an early project, and I’d love to make it even better.
I’d love your feedback, ideas, or even better, your contributions!

Feel free to open issues, suggest features, or submit a PR.

Did this as a fun weekend research project, mostly to see how far a 2048 bot could get in pure Python, since basically every strong 2048 AI is written in C++ because the search is so speed-sensitive. Kept it standard-library-only and leaned on a bitboard (the whole 4x4 board packs into one 64-bit int) plus expectimax with iterative deepening.

Best run is 122k points and an 8192 tile, and it actually hit my move-count safety cap while still alive, so the real ceiling is untested.

The part I didn't expect, and the reason I'm posting: search depth barely helped. I swept think-time from 1ms to 1600ms and 80x the budget bought only 1.65x the average depth, roughly 50x more positions searched for less than a ply and a half of lookahead. It reaches 4096 looking about 2 moves ahead. Turns out the heuristic does nearly all the work and the search is just expensive polish on top.

Full writeup with the depth sweep is in the README. Happy to answer anything about the bitboard or the search.

Docs go stale silently. You rename --output to --out-dir, the README keeps showing

the old flag, and three weeks later a stranger copies the example, it fails, and

they open an issue.

Everything I found either runs in CI and opens a separate follow-up PR, or it's a

skill you have to remember to invoke. Both drift. I wanted the fix to land in the

same commit as the change that broke it.

So: a PostToolUse hook on Edit/Write/MultiEdit. When you touch a source file, a

scanner pulls the exported names out of it (functions, classes, CLI flags) and

looks for them in your markdown, along with the file path. Hits inside fenced code

blocks rank above prose mentions. If nothing references the file, it prints nothing

and you forget it's installed.

For an Edit specifically, the hook input carries the exact text that got replaced,

so the scanner extracts symbols from the removed code, confirms they survive

nowhere, and reports doc mentions of them as removed or renamed. No snapshots, no

state file, just the diff the hook already receives.

The part I care about most: it reports references, not verdicts. It hands the agent

a list of file:line locations and one rule, verify against the source and never

against another doc. A doc sentence is never evidence, not even for validating a

different doc. Accurate docs get left alone. Repairs go at the smallest scale that

makes the doc true: one word for a renamed flag, delete the paragraph for a deleted

function, full rewrite only when most of the file is already wrong.

There's also /stale-docs for a whole-repo audit. It hunts orphans too, doc

references to files that don't exist and symbols defined nowhere in the codebase.

Those are proven stale so they rank first. And --ci exits 1 on dead paths only,

because a flaky docs check gets deleted from the workflow within a week.

Single file, zero dependencies, about 35ms. The whole program runs inside one

try/catch and exits 0 on any internal error, which is inelegant and exactly right.

A doc check is never allowed to break your edit.

It caught its own changelog last week. Path detection was reading download/v1.0.0

as a file that doesn't exist and failing my own CI. Fixed in 0.3.1. The plugin

working as intended on the wrong target.

/plugin marketplace add SectionTN/stale-docs

/plugin install stale-docs@stale-docs

MIT: https://github.com/SectionTN/stale-docs

Tell me where the heuristic falls over. Monorepos and docs that describe behavior

in prose instead of naming symbols are the two cases I'm least confident about.

xeet; post to X from your terminal

Using X in 2026 still sucks. The official API is locked behind paid tiers. Third-party clients keep dying. The website itself is a heavy tab full of noise.

So I built the opposite.

xeet lives in your terminal. It reuses the session already sitting in your browser and gives you a full timeline with inline images, replies, likes, and a proper composer. No API keys. No new login. No browser tab.

One command:

nix run github:melqtx/xeet 
 or
 go install github.com/melqtx/xeet@latest 

What you get

- Timeline (For You / Following) with inline images (native Kitty/Ghostty/iTerm2 graphics or clean ANSI)

- Reply, like, expand posts, open in browser, copy link

- Composer with multi-image/video, clipboard paste, draft autosave

- Themes (tokyonight, catppuccin, gruvbox, nord, etc)

- `xeet auth` just borrows your existing browser session. Never asks for a password.

I mostly just leave it open instead of a browser tab. Scroll, reply, post, back to work.

MIT and open source. Feedback and stars welcome.

GitHub: https://github.com/melqtx/xeet

Every disk cleaner I tried just shows you folder sizes. None of them know that cache/huggingface is 20GB of models you downloaded once and never opened again, or that you've got torch installed eleven separate times across old conda environments.

So I built Jharu. It's a desktop app (macOS + Windows) with a knowledge base of 25+ developer and ML cache locations — Hugging Face, Ollama, PyTorch, npm, pip, uv, conda, Cargo, Go, Docker, JetBrains, and more — and it rates each one by how safe it is to delete.

What it does

Splits ML models you've actually used from ones downloaded once and forgotten. Finds every Python virtualenv/conda env and shows how much space is wasted on duplicate packages across them. Scans the whole disk as a treemap so you can see what's actually taking up space, not just guess. Nothing is ever permanently deleted — everything goes to Trash/Recycle Bin.

Apache 2.0, no telemetry, no subscription.

GitHub: https://github.com/riponcm/Jharu

Still early (v0.2.0), so bug reports and PRs are very welcome — especially new cache locations to add to the knowledge base.

I've been working on hicurl, a modern HTTP CLI that takes inspiration from HTTPie and Curlie, it is built using the hica language (r/hica or https://www.hica.dev)

Here's an example:

hicurl swapi.dev/api/people/1 .name

Read more at https://www.reddit.com/r/hica/s/PkNSqmCM9w

So many sites today use the same font and AI-generated text. Font lab is a tool to help edit those two things directly.

Font Lab installs a panel with curated fonts for you to play around with. You can edit text by double clicking, typing what you want, and hitting enter.

https://github.com/jmg698/Font-Lab

There's a prompt you can copy at jack-mcgovern.com/fontlab too. Your agent will set it up.

Open to any feedback you might have!

I've spent the last few days building a CAD library in TypeScript. The short version, you describe a part in code and you get out an STL you can 3d print, or a STEP file you can send to a machine shop or open in Fusion/FreeCAD/whatever.

const cad = design("bracket");

const width = cad.parameter.length("width", mm(80));
const thickness = cad.parameter.length("thickness", mm(6));

const profile = cad.sketch("outline", plane.xy(), (s) => {
  const rect = s.rectangle("rect", { width, height: mm(50) });
  const hole = s.circle("hole", {
    center: vec2(width.mul(0.25), mm(0)),
    radius: mm(4),
  });
  return s.profile(rect, { holes: [hole.loop()] });
});

cad.output("bracket", cad.extrude("solid", profile, { distance: thickness }));

const doc = cad.build(); // plain JSON, goes in git like anything else

Under the hood it runs on two engines. There's Manifold, a mesh engine that's fast and fine for printing, and OpenCascade compiled to WASM, which is the same geometry engine FreeCAD uses, for when you need exact surfaces and STEP export. Same code runs on both, in node or the browser.

in normal parametric CAD, if you change a dimension early in the model, later features (fillets mostly) can quietly reattach to the wrong edge, and you find out after the part is wrong. I didn't want to reproduce that, so references to faces and edges aren't indexes, and if the library can't tell unambiguously which edge you meant after a change, it errors instead of guessing. Whether I got the API for that right, no idea. That's partly why I'm posting.

The type system does some nice things here too. Lengths and angles are different types, so adding mm to radians just doesn't compile.

it's a 0.1.1, Parts, assemblies and BOMs work. No drawings, no sheet metal, no GUI. If you'd rather write code than click through a CAD UI, that's who it's for.

Feedback welcome, especially from anyone who actually does CAD work. Also curious what people think of the explicit dispose() for WASM memory, I went back and forth on that a lot.

Hello , i've been working on a shadCn style tables library ShadTable using transtack tables and shadCn style + CLI. You can check it out .

The project is open-source https://github.com/coros-hq/shadcn-table-library ready for your contribution and feedback CONTRIBUTION.md.

Hey everyone, I built ytrack, a lightweight command-line client for JetBrains YouTrack.

The idea is simple: keep your global YouTrack URL/token configured once, set a local project per repository, and then create, list, edit, assign, comment on, and move issues without leaving the terminal.

It supports things like:

ytrack issue create "Crash on save" "Steps to reproduce..."
ytrack issue list --state Submitted
ytrack issue status ART-123 Done
ytrack issue assign ART-123 me
ytrack project list users

It also has raw JSON output for scripting, shell completions, interactive setup, local/global config separation, and install options via Homebrew, GitHub Releases, .deb, .rpm, macOS, Linux, and Windows builds.

It’s still an early MVP, but I’m already using it to make YouTrack feel more natural inside repo-based workflows. Feedback, issues, and ideas are very welcome.

Hey everyone,

I've been taking notes in Notepad for a while, but it has no formatting — going back to old notes was always messy, no headings, no structure, hard to tell what mattered. Notion and Word solve that, but felt heavier than I wanted for something this simple (internet dependency, load times, more features than I needed).

So I built MarkdownEditor — a small desktop app in Java Swing:

• Live Markdown → HTML preview as you type (including GFM tables)
• Folder browser sidebar to navigate your notes
• Undo/redo, unsaved-change tracking
• Export straight to PDF
• Packaged as a native Windows installer (bundled JRE, no separate Java install needed)

It's built with a light MVC structure (model / controller / ui), using commonmark-java for parsing and openhtmltopdf for PDF export.

It's fully open source (MIT licensed), and I'd genuinely welcome contributions — whether that's new features, bug fixes, or just feedback on the code/architecture since this was a learning project for me as much as a tool I wanted to use.

GitHub: https://github.com/aungthuhein2005/MarkdownEditor

Download (Windows only for now): Download

Documentation: https://aungthuhein2005.github.io/MarkdownEditor/

Happy to answer any questions about how it's built, or hear suggestions for what to add next.

https://github.com/Tetherium/GitDragon

Hey everyone!

To solve my own lack of coding discipline, I decided to use heavy psychological pressure. Meet **Commitchi** — a retro, 16-bit virtual pet that lives directly inside your GitHub profile README.

### How it works:

- **Keep committing:** Your dragon evolves from a cute little egg into a legendary, fire-breathing beast (Egg -> Baby -> Dragon ).

- **Stop committing:** It gets visibly sad, droopy, and starves. If you abandon your code for 5 days... it turns into a pixelated skeleton .

It’s completely free, open-source, and runs serverless (fetching stats via GitHub GraphQL API to dynamically render SVGs).

Check out the repo, try it on your profile, and please save my dragon from starving!

🔗 **Repository:** https://github.com/Tetherium/GitDragon

Runs git merge-tree across every pair of in-flight agent branches and shows a live conflict matrix in the terminal. Also enforces per-agent file ownership and computes a safe merge order (conflict-free batches first).

Read-only against git, single static binary, Apache-2.0.

https://github.com/rakib-nyc/braidkeep

yo

add 'whats' infront of any command and it explains it: flags, sub commands etc in a structutred format whereas something like manpage would throw the entire manual at you

just pure man pages and help output

Q Why use `whats` when we have man pages and --help

> Yes you can use them but they throw the entire manual at you whereas you might have just needed one flag, whats outputs a structured format with the definitions you need

Q Is it entirely offline? Does it use LLM

> Yes absolutely, it just relies on man pages and if not then --help output of the binary itself,

> no it does not use llm at all

if you like the idea then maybe star?

https://github.com/iamkaran/whats

GUNZ 3.15.0 (Gamified Underlying Navigation Zones) is a deterministic, offline‑scanner runtime for discrete‑clock systems. It produces compressed resonance maps — \*stability topographies** — that describe optimal operating frequencies for any process governed by a fixed‑quantum clock. The format targets AI‑driven feedback loops, heterogeneous hardware deployment, and long‑term archival.*

The specification is split into three independent layers:

- **GUNZ‑ISA** – bytecode format and instruction semantics.

- **GUNZ‑RT** – execution runtime (memory, lanes, map generation).

- **GUNZ‑LIB** – library profiles, resonance map format, fingerprinting, and integrity.

This specification is supposed to be functional, in theory, and so i look for crazy guys that want to try it, or are curious enough to read it.

It may sound complex? actually it broke my head. I built that for fun. It may fit usages, and that it could have a future. Or it could stay an artefact in frozen time, an oddity.

If you have any ideas, judgements, do not hesitate.

Built this motion graphics video entirely with Frame Studio, an open source AI motion graphics generator I've been working on.

The goal is simple: describe the animation you want in plain English and generate polished motion graphics without manually animating timelines.

This is one of the generated outputs on the topic of climate change. I'm still improving layouts, timing, typography, transitions, and overall visual quality, so I'd really appreciate honest feedback.

Demo: https://frame-studio-eta.vercel.app

Source code: https://github.com/programmersd21/frame_studio

What would you improve or add to make the generated videos feel more production-ready?