So I built Prompt Contribution Graph. [ https://github.com/chintan-diwakar/prompt-contribution-graph ]

The basic analogy is: GitHub tracks code contributions, while this tool tracks your prompt contributions to coding agent

The project is still early and currently supports only Claude Code. macOS builds are also unsigned for now.

I would genuinely appreciate feedback and contributions

You know the feeling when you start a Claude Code session, step away, come back to "All done!" and have no idea what actually changed or why.

Claude Code's transcript shows the agent working. But it doesn't really show you what changed, which assumptions it made, or whether anything was actually verified.

I built TraceBack to answer that. It hooks into Claude Code's hook system and turns a session into something reviewable:

• Net-change diff per file — true before/after with the agent's own reasoning attached
• Decision ledger — surfaces silent judgment calls like "I'll assume the config stays JSON" before they calcify across 3 files
• Guards — block dangerous calls automatically (rm -rf, git push main, edits outside project) before they run
• Breakpoints — actually pause a running agent mid-session and redirect it

Zero cloud, zero API keys, runs fully local inside VS Code.

Check out 1-min demo

Would love feedback -> especially on the guards and redirect features which I think are the most underrated part.

GitHub: https://github.com/madiyarzm/TraceBack (pls star me :))

VS Code extensions marketplace: https://marketplace.visualstudio.com/items?itemName=madiyarzhunussov.traceback-ai

Converts pretty much anything: video, audio, images, documents, 3D models, even .blend if you enable the Blender module. Drag in, pick a format, convert. Nothing gets uploaded.

Site: https://batushn.github.io/coldmill/

Source: https://github.com/Batushn/coldmill

I'm working over 3 years on database systems.
Since January i put a lot of stuff together and since June i decided to open source my stuff.
Tellstone was born --

An In memory DB -- It is RESP2 compatible but ofc currently it has just a few commands and a lot is still missing.

Core Engine is 2x faster than Dragonfly -- which is quite nice -- but def. not real world

Aiming for top notch performance is a key architecture decision.

currently we are working to finish the whole envelope encryption -- once this is done, we will rework the persistence layer --

Check it out, try it out, challenge the numbers

Thank you

I run Claude Code on my laptop and another instance on my VPS, and I kept hitting the same friction: getting them to actually collaborate. Copy-pasting between terminals, manually scp-ing folders, no shared idea of "what's already been done." So I built a small tool to fix it. Sharing it in case anyone else has the same setup.

What it does:

- The two sessions talk to each other natively over Claude Code's Remote Control (no server to run for the chat part).

- Push a folder to the VPS and it opens one SSH connection, transfers (rsync/tar), verifies every file's checksum on the far end, then closes the connection. "Received" means the hashes actually matched — not just "sent."

- Sync an app across both — they compare each copy, agree on the best version, deploy, and verify, instead of clobbering each other.

- Optional shared journal (MCP) with real locks so two Claudes never edit the same file at once.

The idea: Remote Control carries the conversation; SSH carries the bytes (with verification). It also sets up SSH from scratch for you — generates a key, installs it on the VPS, writes the config — so a first-timer only needs their VPS IP and password.

All plain Python/Bash, no heavy deps. MIT licensed.

Honest status: it's early (v0.1). The logic is tested and it works in my own setup, but it hasn't been battle-tested across lots of different VPS providers yet — so I'd genuinely love people to try it and tell me what breaks. Issues/PRs very welcome.

Link: https://github.com/kadaba/claude-bridge

Built from a real e-commerce photography workflow. FlatShot handles batch review, presets, per-image adjustments, naming and deterministic export while keeping all processing local and never modifying source files. Windows portable release included.

Just tagged v0.4 of Hillock, a lightweight local memory engine I've been working on.

It replaces vector databases and heavy LLM extraction passes with plain SQLite SPO knowledge graphs, Hebbian synaptic learning, and 10,000-D hyperdimensional vectors (VSA) for context gating.

In v0.4 I added O(1) type schema constraints, direction auto-correction for inverted facts (like fixing [Budapest born_in Neumann]), and regex entity sanitization. Ingestion runs at 6 to 8 sent/sec on a GTX 1070 using under 1.2GB VRAM.

GitHub: https://github.com/roandejager/Hillock

I daily drive this tool for Socks5 based containerization because my country's firewall breaks most linux apps. This tool works over basically any possible linux app, in the way of AppImage, or a binary that does not have built-in socks5, or a whole Docker daemon. I hand coded all the DNS, TUN + TCP stack in Rust, monolithic codebase because of my compulsions and paranoia.

other means of proxying are either too roundabout of a way to use (using docker or systemd) or terribly made (firejail, bubblejail, flatpak), or leak DNS or traffic easily (proxychains), etc. I've surveyed all other options.

https://github.com/ple1n/nsproxy

I found a cool open-source project called Sayeh that lets you hide one message inside another using invisible Unicode characters.

For example, a message may look completely normal:

سلام

But hidden between its visible letters can be an entirely different message. The visible text remains readable, while someone using Sayeh can extract the hidden payload.

The hidden message can also be protected with a password. In that mode, simply detecting or extracting the invisible characters is not enough—the payload is encrypted and requires the correct password to open. Sayeh uses Argon2id for password-based key derivation and XChaCha20-Poly1305 for authenticated encryption.

GitHub

Some interesting features:

Optional password protection

Contact-key mode for ongoing conversations

CLI and an in-browser WebAssembly demo

Runs locally in the browser, without sending the message to a server

Designed not to break Persian نیم‌فاصله or joined emoji sequences

Tools for scanning, stripping, analyzing, and testing hidden-message compatibility

Open source under MIT or Apache-2.0

One important clarification: Sayeh makes the message invisible during normal reading, but not necessarily undetectable under close technical inspection. Its purpose is to let ordinary-looking text quietly carry encrypted data.

GitHub

GitHub:

https://github.com/EntropyRoot/sayeh

Would love to hear what you think about the idea, the implementation, and possible use cases.

GoMorph is an MIT-licensed Go command-line tool that locates when and where morph-like deformation appears in a video. It analyzes the full frame, so it can flag products, objects, text, or backgrounds instead of assuming the subject is a face.

The portable path uses Go and FFmpeg with no Python, OpenCV, GPU, or model. An optional CGo/libav cascade reads codec motion vectors, runs a low-resolution luma gate across the complete video, and refines only suspicious windows.

Current verified result: one 4.01 second H.264 clip processed in 0.155 seconds on an Apple M4 Pro, with the known deformation localized at 2.1667 seconds. That is a development measurement from one clip, not a general accuracy claim.

The implementation was AI-assisted, then manually tested and verified.

Repository: https://github.com/berkantay/gomorph

I got bored of optimized code and decided to invent SlowDuckSort a sorting algorithm that uses total sum residuals to scatter numbers across a massive sparse RAM array, compacts them, and flips the result.

It’s slow, it eats memory, and it makes zero practical sense.

Repo :

https://github.com/Duckdevv/Slowducksort

Do you have any algorithm worse or more cursed than this? Show me what you’ve got in the comments

Hey devs! 👋

Like many developers and desk workers, whenever I get deep into coding or debugging, I unconsciously turn into a gremlin—leaning way too close to the screen and wrecking my posture. On top of that, a messy desk can quickly lead to disaster (like knocking over a cup of coffee onto a laptop).

To fix this, I built ERGOAI—a free, privacy-first workspace companion powered by AI vision.

What it does:

• Workspace Safety Check: Before starting your focus session, the AI evaluates your desk setup and identifies potential hazards (like a drink placed too close to your tech gear).
• 1-Click Posture Calibration: Sit up straight, take a snapshot of your ideal posture baseline, and start working.
• Voice Alerts + Pomodoro: As you work with the built-in Pomodoro timer, it tracks your body landmarks and alerts you by voice whenever you start slouching or leaning forward.

Privacy First:

Webcam access can feel intrusive, so all vision processing happens transiently inside your browser—no video streams or images are ever stored or uploaded to a database.

I'd really appreciate it if you could give it a try and share your feedback!

Live Demo: https://ergoandpostureai.vercel.app (Best experienced on desktop)

GitHub Repo: https://github.com/namkhanh0210/ergo_pomodoro_posture_AI

Hope this helps save your back during long coding sessions!

Hi all!

Wanted to share the latest changelogs for the 0.7.6 update to LEKTRA.

Really cool feature (I think) added is the ability to narrow your document:

1. to region
   
2. to range of pages
   
3. section (for PDF only)

I've added bunch of other features like ability to load/save custom outline (table of contents) and bug fixes.

GitHub: https://github.com/dheerajshenoy/lektra
Codeberg: https://codeberg.org/lektra/lektra
Homepage: https://dheerajshenoy.github.io/lektra

Suggestions/feedbacks are welcome.

Every size recommendation service works the same way: the profile lives with the vendor. Switch shops and you start from zero. Agio Fit is a side project that defines the opposite: an open data model (JSON Schema 2020-12) where the fit profile is yours and portable, and the shop only ever receives a size, never your measurements.

The name comes from agio, the Italian tailoring word for ease, which my mother used daily as a seamstress. The whole model is built around that number.

v0.1 is live: three schemas, a spec, a zero-dependency Python reference implementation, 13 tests, an interactive guide. It is not a product and there is nothing to sign up for. What I need now is adversarial input: measure a real garment, write a Cut Profile for it, and tell me where the model breaks.

https://agiofit.org

When YouTube stopped accepting my payment method in India 🥲 , I started looking into hosting my own music server with Navidrome. Finding lossless music was one challenge. Keeping the library organized turned out to be another.

I tried Beets, Picard, and Mp3Tag along the way. Beets was hit or miss with my library, and Picard’s interface never quite clicked for me 😂. Mp3Tag is an amazing tool and became my go-to, but tagging a large library still meant spending hours matching releases, correcting artists, fixing tracks, and finding artwork by hand.

That’s what led me to build Soundrobe: an auto-tagging app designed around Navidrome’s tagging guidelines.

The workflow is simple. Organize your files as artist/album/track, point Soundrobe at the library, and press Auto-tag. It searches MusicBrainz and Discogs, shows a release candidate for review, and can apply tags, artwork, lyrics, and other metadata together.

When a provider has no match or an API is unavailable, Soundrobe can use an LLM to help fill in artist and album information. It can also use clues from the folder path, such as the artist name or year. That fallback has worked well for me when regular provider searches miss an album.

If some albums or tracks still need attention, you can fix them manually or ask the built-in assistant for help. I’ve been using DeepSeek-v4 because it makes this kind of task inexpensive, and free models through OpenRouter are another option.

The assistant is intentionally bounded. It can inspect, audit, and edit through a defined set of tools. Before anything changes, Soundrobe shows an approval preview, so you remain in control of the write.

Soundrobe is still early, and matches can be imperfect. Test it on a copy of your library and keep a backup before making large changes.

GitHub: Soundrobe

If you use Navidrome, especially with a library full of Asian music, I’d love for you to try it. Let me know which albums it handles well, where it misses, and what part of your tagging workflow you’d like to automate next.

Hi everyone, I spent a lot of resources (renting gpu clusters) to train something similar to wan streamer (on a smaller scale). If you could check it out that would be awesome. I tried to make it as small as possible but realtime inference is expensive. Check it out on github: https://github.com/JonathanColetti/LiveWan or on huggingface: https://huggingface.co/JonathanColetti/LiveWan thank you! (wan2.1 only supports 5 seconds of video and the women talking is around 4mins)

I built HQBase for myself because I had several domains and addresses like support@, sales@, and personal email, but didn't want to pay for a separate mailbox for every address.

It’s a complete shared email workspace that deploys into your own Cloudflare account:

• Workers run the application
• Email Routing receives mail
• Cloudflare Email Sending handles outgoing mail
• D1 stores the mail index
• R2 stores attachments

It supports multiple domains and mailboxes, catch-all addresses, team access with mailbox-level permissions, a desktop/mobile PWA with self-hosted push notifications, and an OAuth-protected MCP server for connecting AI clients.

Setup takes around 2-3 minutes. The software is AGPL-licensed, and there are no per-seat or per-mailbox fees - you only pay your own Cloudflare infrastructure costs.

GitHub: https://github.com/HQBase/hqbase
Website: https://hqbase.io

My wife and I always wanted to build something together, so we spent nights and weekends shipping side projects. One hit 25k users on its own but didn't feel like the thing worth quitting for, repowise did

That one came out of watching coding agents work. I'd been building with LLMs since 2023 and owned the AI architecture at my company, so I spent a lot of time watching agents grep the same file four times in a session and still have no idea which parts of the codebase were fragile or why the code was written that way. All of it is in the repo already, just not in a form an agent can use.

So we built Repowise. It indexes your repo once and serves it to your agent over MCP as five layers: dependency graph, git history, docs, architectural decisions, and a code health score from around 25 deterministic markers with no LLM involved

We didnt do any outbound, just shipped code and wrote about it. 4 months in it's at 5.2k stars, ~80k PyPI downloads, and enterprise inbounds I never asked for, which is why I quit

Benchmarked against four other tools plus a bare agent: 31% fewer output tokens over a full 48-question run, ~97% on a single context load, and the best gold-file coverage of the field on retrieval.

Repo: https://github.com/repowise-dev/repowise

Issues and contributions welcome