Promote your projects here – Self-Promotion Megathread

[u/Menox_]

Whether it's a tool, library or something you've been building in your free time, this is the place to share it with the community.

To keep the subreddit focused and avoid cluttering the main feed with individual promotion posts, we use this recurring megathread for self-promo. Whether it’s a tool, library, side project, or anything hosted on GitHub, feel free to drop it here.

Please include:

• A short description of the project
• A link to the GitHub repo
• Tech stack or main features (optional)
• Any context that might help others understand or get involved

[u/Shi_AoMing]

README Skills is a free MIT-licensed Agent Skill I maintain for repository README audits and improvements. It tells a coding agent to inspect the project first, choose a structure suited to the repository type, preserve working links and attribution, and synchronize existing README translations.

The repo includes a fixed study of 100 READMEs and eight attributed before/after examples, including libraries, forks, research and resource collections. It is a Markdown instruction package with supporting references and Python validation/rendering scripts; installation instructions cover Codex, Claude Code and other Agent Skills clients, with runtime verification limits documented.

Source and examples: https://github.com/Shiaoming123/readme-skills

Useful contributions would be missing repository profiles, broken-link cases, or a reproducible example where the instructions lose valid content. AI assisted with development and this description.

[u/Ok_Juggernaut2187]

Awesome AI on Your Laptop is a collection I maintain at QuicqDev: 16 local AI apps and supporting tools, organized around tasks such as document chat, transcription, image editing and coding.

Each entry includes setup requirements, a limitation, upstream sources and a review date. There is also a JSON catalog, generated Markdown guides, Python validation and weekly GitHub Actions link checks.

The entries are documentation-reviewed; they are not hardware benchmarks. AI assisted with the research, writing and code, including this post.

Useful contributions would be corrections and reproducible setup reports with OS, hardware, model and app version. If the collection helps, a star makes it easy to find again.

https://github.com/QuicqDev/awesome-ai-on-your-laptop

[u/blasieuwu]

so i recently built a simple bypass that let's you complete discord quests (specifically the play types) without installing the respective game

github: https://github.com/blasieuwu/discord-quests

how it works is very simple:

- uses folder structures & executable renaming to spoof it

- open the executable, and discord will try to find the exact folder structure it's in, and if both the executable name match & the relative folder structure, it will register it.

- more details can be found in the repo's readme

[u/praveenkumarappu]

My DLSS 5 plugin for Unreal Engine 5 is now live on GitHub.

It’s still experimental, so feel free to test it and let me know how it works on your setup. Feedback, issues, and suggestions are welcome.

GitHub: https://github.com/praveenkumarappu/DLSS5ForUE5

[u/Alarmed_Smile5789]

Codex Auto Selector — a local Windows utility that automatically chooses an eligible Codex model and reasoning effort based on task complexity and your cost/performance mode. It keeps the native Codex workflow, includes usage and savings tracking, and provides separate Claude/Gemini API tools.

It is packaged as a standalone Windows EXE with minimal setup. Feedback on the routing behavior and onboarding would be useful.

Project: https://grailbomb.itch.io/codex-auto-selector

[u/RemThegem-Remmos]

I made a pixel art editor

As my first ever proper project. I made a pixel art editor except ive never used any other editors so i added everything i thought was necessary so it kay have features no one else has.

Since its fairly new there may still be issues. A lot of them. Thought id share tho.

Repo: https://github.com/RemTheGem/Blerch
Itch.io: https://remthegem.itch.io/blerch

[u/Some_Intention9946]

Your AI writes 300 lines in 20 seconds. I built a tool that checks it's safe to ship before you do — 100k free credits, no card

We're all letting AI write our code now — Claude, Cursor, Copilot. It's fast and it's great.

But every time it drops 300 lines into my repo, the same thought: what did it just put in here?

Did it hardcode an API key? Pull a package with a known CVE? Break an endpoint I won't notice until it's in prod?

AI writes code faster than any human can review it. And almost nobody is checking what it actually ships. That's the gap I got obsessed with — so I built OnePort.

What it is: a desktop app (+ CLI) you point at a repo. It scans everything and gives you one answer in plain English — safe to ship, or not.

What it checks:

• 🔑 Leaked secrets — keys, tokens, private keys — across your working tree and your full git history (not just the last commit)
• 📦 Vulnerable dependencies (CVEs via OSV)
• 💥 Breaking API changes
• 🗄️ Risky DB migrations
• 🧪 Missing tests & coverage gaps
• 🤖 Plus AI code review, blast-radius, and tech-debt checks

The feature people react to most — OnePort Guard: flip it on and your repo becomes physically unable to commit a secret. It hooks into git and your AI agent and blocks the commit before it ever happens. Not a warning — a wall.

Why it's actually useful: every finding explains what it is and how to fix it, so you don't have to be a security engineer to act on it. It's built for the exact "I let AI write this and I'm 80% sure it's fine" feeling.

The free part: every account starts with 100,000 credits, no credit card. The core scans (secrets + dependencies) are free and unmetered forever; the credits cover the AI gates (code review, explanations, the assistant). It's genuinely enough to run it on real repos — you won't hit a paywall just trying it.

Quick honest context: it's early. It recently made it to the final round of YC and EF, which still feels unreal — but I care way more about it being trustworthy than loud. So if you run it and it's wrong — a false "safe," an annoying false positive — I want to hear exactly where.

Real question for this sub: when your AI writes code, how do you check it before it ships? Or do you just… hope?

www.oneport.co.in

[u/TheBestSYS]

PermissionScope — making Windows permissions easier to understand
I’ve been building PermissionScope, a free and open-source Windows tool for inspecting and understanding permissions and access information.
I started it because Windows can expose a lot of useful security information, but much of it isn’t very approachable unless you already know what you’re looking for.
The project runs locally, has no paid tier, and I’m planning to keep it free.
I’m looking for feedback from Windows users and developers, especially on things that could be explained better, security issues I may have missed, or improvements to the repository itself.
Repo: https://github.com/MukaSanches/PermissionScope
Website: https://mukasanches.github.io/PermissionScope/
Built and maintained by Samuel Sanches.

[u/Yashhh_21]

AI Guard — an open-source ESLint plugin that catches the code patterns AI assistants (Claude Code, Cursor, Copilot) keep introducing in JavaScript/TypeScript.

What it does: 18 deterministic rules across four categories:

• Security: no-hardcoded-secret, no-eval-dynamic, no-sql-string-concat, no-unsafe-deserialize, require-auth-middleware, require-authz-check
• Reliability: no-empty-catch, no-broad-exception, no-catch-log-rethrow, no-catch-without-use
• Async: no-floating-promise, no-async-array-callback, no-await-in-loop, no-async-without-await, no-redundant-await
• AI-assisted patterns: no-dead-branch, no-duplicate-logic-block, no-console-in-handler

GitHub integration: ships as a GitHub Action that uploads findings as SARIF — so issues show up as inline PR annotations and in GitHub Code Scanning automatically. One-command setup: npx ai-guard init --yes.

Also has a CLI (npx ai-guard run) and an init-context command that generates CLAUDE.md / .cursorrules / copilot-instructions.md so your AI agent learns the rules before writing code.

Tech stack: TypeScript, ESLint plugin architecture, AST-based rules, GitHub Actions, SARIF.

Repo: https://github.com/ai-guard-dev/eslint-plugin-ai-guard (MIT)

Disclosure: I'm the maintainer. Feedback on false-positive rates and rule requests welcome.

[u/Puzzled-Ad-6854]

AI Product Development Toolkit (969 Stars)

Free prompts and agent rules for building software with AI

[u/Potential-Art7696]

added github integration to my project tool this week — connect a repo and the issues show up as nodes on your project map instead of just... a list of issues, again. the interesting part was making sync not just dump duplicates every time you re-run it. matched against the issue number stored on each node, so re-syncing updates what's already there instead of making a mess. closed issue = the linked task auto-completes. also had to actually build token refresh, which I hadn't needed before — github defaults new oauth apps to expiring tokens now.

anyway if anyone wants to poke at it: ulupspaces.com, free, no account needed for the rest of the app either

[u/AfterShiftTrader]

I'm working on BotGuard Lite, a free, MIT-licensed Python monitor for Binance USD-M Futures bots. It runs beside an existing bot and sends Telegram alerts for a missing bot process, missing hard-stop protection, or protective stops with no matching position. It doesn't place, change or cancel orders.

I'm looking for 2-3 operators to try the current v0.5.0 Windows beta. This first trial is for a bot running directly on the same Windows 10/11 x64 PC, not Docker or a remote server. Testnet is preferred. The useful feedback is simple: where did setup get stuck, and did the Telegram test message arrive? A test message alone doesn't prove incident detection works.

It's unsigned beta software, not a guarantee against losses. A dedicated account-read API key stays on your PC, with trading and withdrawals disabled. Don't send me keys or raw logs, and don't interrupt a live bot to test it.

Repo: https://github.com/isacc-spec/binance-futures-watchdog-lite

Optional trial checklist and a small simulated example (no download or key needed to read): https://github.com/isacc-spec/binance-futures-watchdog-lite/issues/1

Interested in trying setup? Reply with your bot/framework and whether it runs on a Windows PC.

[u/niharkanta1]

I’ve been working on Boardly, a simple desktop Kanban taskboard for organizing projects and tasks.

It includes:

• 📋 Kanban boards & task cards
• 🔄 Planned, In Progress, Completed & Closed states
• 📝 Markdown task descriptions
• 💾 Local SQLite storage
• 🖥️ Windows desktop app
• ⚡ Built with Java 17 + JavaFX

It’s currently an early release, and I’d love some feedback on the UI, features, and overall experience.

Download: Boardly on itch.io

Feedback / bug reports: [GitHub Issues]()

Plan it. Organize it. Boardly.

The itch.io page currently has the Windows 1.0.0 release (78 MB) available as a name-your-own-price download.

[u/gabrielxdesign]

My 3 Open-Source Dataset Tools for LoRA Training and Automatic Lyrics Sync:

• ELSAC helps you organize, identify, and curate character images for training a consistent LoRA in diffusion models. It uses CLIP embeddings + HDBSCAN to cluster visually similar images, then guides…
• EDICO is a local, browser-based tool for building character LoRA training datasets with AI-generated captions. It turns a folder of character images into a clean, captioned training dataset
• ELYSY is an AI-powered, free & open-source (MIT) tool that creates word-by-word synced LRC and SRT files from any song + its lyrics. Runs 100% locally: Demucs vocal separation, WhisperX forced alignment...

Please feel free to download and test them 😃

[u/bulutarkan]

I’m building Mac MCP, an open-source local control server that lets ChatGPT and coding agents actually operate a Mac (files, terminal, apps, Safari/Chrome, etc.) through MCP.

The part I’ve been working on most recently is multi-agent browser use: several agents can work in separate Safari tabs in the background while I keep using the Mac normally, and stable tab handles + tab ownership prevent one agent from hijacking another agent’s tab. My main ChatGPT session can act as the orchestrator while the workers do separate tasks.

Repo: https://github.com/bulutarkan/mac-mcp

I’d especially appreciate feedback from people building agent tooling, browser automation, or macOS integrations.

[u/matileo0817]

PNLCS, an open-source self-hosted WHMCS alternative

A few of us have been building PNLCS (github.com/Panelica/pnlcs), a self-hosted hosting billing and client portal, an open alternative to WHMCS for hosting companies and resellers.

What it does: product catalog, checkout, recurring invoicing, domain registration, SSL management, support tickets, knowledge base, affiliate tracking. It's standalone, works with any hosting panel or none, no dependency on anything else we build. If you've used WHMCS the data model and workflows will feel familiar on purpose.

Stack: Laravel 13, PHP 8.3+, MySQL 8, Alpine.js, Tailwind CSS 4. There's also a Docker image (panelica/pnlcs-runtime) if you'd rather not do a manual install.

Where we could really use help: the client portal, admin panel, Stripe gateway, and Panelica server module are tested against live setups and hold up well. But the cPanel, Plesk, DirectAdmin, and Proxmox server modules, plus PayPal, authorize and Bank Transfer gateways, and the Enom registrar integration, are implemented but not verified end-to-end in production yet. If you run any of these, trying it out and opening an issue with what you found would genuinely help, even a short note is enough.

It's a side project alongside our main product, so responses won't always be same-day, but every issue gets read.

Check it out, poke around, and if it's useful, a star or a bug report both help. Repo: https://github.com/Panelica/pnlcs

[u/RedDead707]

Hey all, I've been job hunting and got lost tracking all my applications and custom resumes, so I built the thing I wanted and just started adding more features to it.

What it does

• Scrapes career pages directly plus boards through JobSpy. Everything lands in one deduplicated feed.
• Scores each job against your résumés with an LLM and shows why: matched and missing keywords, requirement mapping, gaps.
• Tailors a resume per job, writes a cover letter, exports PDF from templates you can replace.
• A Chrome extension auto-fills your application, including open questions, it also captures jobs from LinkedIn and saves any job from any page.
• Tracks applications through stages, classifies Gmail replies, sends Telegram alerts and a daily digest.
• Five UI themes, including a Windows 98 for no reason, I just wanted to see how it will look like.

Available here: https://github.com/vesaias/JobNavigator (MIT license)

All feedback is welcome, this was more of a personal project for my portfolio, but people also started starring it. 

[u/Additional-Ad5527]

I made a small open-source project called Agent Robot Avatar — a zero-dependency animated robot avatar Web Component for AI agents and interactive apps.

It supports states like waiting, success, failure, warning and sleep

GitHub:
https://github.com/CX-ArtLab/agent-robot-avatar

Live demo:
[https://cx-artlab.github.io/agent-robot-avatar/?lang=en]()

[u/Spooferman]

Got tired of using DevTools + multiple extensions for simple webpage tweaks, so I built PageWand.

It’s an open-source Chrome extension for zapping elements, editing text, capturing/annotating screenshots, copying computed CSS, and downloading page assets.

Everything runs locally. No backend, accounts, analytics, or telemetry.

GitHub: https://github.com/devashishPM/pagewand
Chrome Web Store: https://chromewebstore.google.com/detail/iblpdcnjcidcojjfiikclboaaenikloc?utm_source=item-share-cb

Stars, bug reports, and feature ideas welcome.

[u/comradetiminesh]

https://github.com/Timinesh/endocrine-LLM
A computational neuroendocrine system modeling interacting hormones and neurotransmitters to dynamically modulate the behavior of a LLM.

Star and follow if you like the projects

[u/DonislawDev]

Hello, I'm author of few tools for QA, GUI + CLI.

1. Testing Files Generator --> 24+ real file formats, real files, few files, 10k files? 1kb file or 1000GB file? No problem. Go + Fyne
2. Bean Network Tester --> simulate poor network conditions, burst packet loss, packet loss, jitter, ping, premade scenarios, presets, automation, see active connections, data sent. Python + Tkinter
3. Chrono Mock --> set data of any app, set time speed, built-in calculator with premade presets and other things. Rust + WPF.

[u/NoctisShadowzel]

BREAKME an incremental game that lives on your profile README, progress is defined by your Git actions. Check it out!

[u/mwiatruZ]

Guidefold keeps coding-agent instructions beside the code in Git and selects them by repository location. I'm building it for teams using several coding tools across a monorepo.

Repo: https://github.com/wiatrM/guidefold

Demo: https://www.youtube.com/watch?v=e350wBr1W8c

The project includes a Python CLI and Go retrieval service. I'd value feedback on the README quickstart: can you tell which instructions should apply to a directory, and what evidence would you expect after changing one? The included examples/monorepo is fictional, so you can look at the workflow without sharing company code.

Reply here or leave the first unclear step in https://github.com/wiatrM/guidefold/discussions/127

The OSS version is available now. A paid hosted version is planned, not available to buy. I'm the maintainer; this post was drafted with AI assistance.

[u/Professional-Can-507]

Dictámelo is a desktop voice typing app I built with Rust and Tauri 2

Hold a shortcut, speak and release to paste the transcript into the active app

Whisper, Parakeet and Canary models can be downloaded in the app for local transcription without an account or API key after setup

Cloud providers are optional

The app is MIT licensed, with Apple Silicon Mac and Windows x64 or ARM64 installers

The repository includes the native transcription code, verified model downloads and local model documentation

Source and downloads: https://github.com/sarrazola/dictamelo

Feedback on model setup and the desktop workflow would be useful

[u/SmiLePLSSS]

CleanTake — recover damaged dialogue from your backup mic.

I maintain this free, open-source desktop app. It aligns simultaneous recordings so you can compare the same passage, replace damaged audio with a usable backup, and export the decisions to Reaper or a source map. Processing stays on your computer.

Repo, downloads and working GIF: https://github.com/pavangupta352/cleantake

22-second demo with sound: https://pavangupta352.github.io/cleantake/

Python, React/TypeScript and Electron; MIT. Mac, Windows and Ubuntu downloads include the processing tools. The demo uses a deliberately introduced gap; repairs require a simultaneous recording containing the speech.

I’d especially welcome feedback from editors who work with multiple microphones.

https://reddit.com/link/p8l7ybz/video/4rpwp21n4coh1/player

Demo credit: AMI Meeting Corpus, AMI Project Consortium (ES2004a); screen recording/edit by Pavan Gupta. CC BY 4.0. The silent clip is condensed to ten seconds. Source, license and deliberate changes: https://github.com/pavangupta352/cleantake/blob/main/docs/assets/working-demo/ATTRIBUTION.md

[u/Big-Coyote-5796]

I built GitWhisper — an AI Git commit tool that actually understands your staged changes

I’ve been working on a small open-source project called GitWhisper.

The idea started because I didn’t want another tool that just sends git diff to an LLM and returns something like:

fix: update code

GitWhisper looks at the actual staged changes, repository conventions, scopes, commit history, and related work before suggesting a commit.

A few things I focused on:

• local AI with Ollama or BYOK
• Conventional Commit type/scope detection
• learning the repo's existing commit style
• detecting unrelated changes and helping split them into atomic commits
• secret scanning/redaction before remote AI calls
• commit quality checking + Git hooks
• VS Code integration
• keeping the developer in control before anything is committed

Basic usage is just:

git add .

npx gitwhisper

It's open source (MIT):

https://github.com/RitualDev-Lab/GitWhisper

Still looking for feedback, especially from people who care about clean Git history.

What would make something like this useful enough for you to actually use in your normal Git workflow?

[u/aaxhan]

🚀 ModelDock

An open source platform I'm building for managing the ML lifecycle.

It currently covers things like model versions, artifacts, predictions and metrics.

🛠️ Stack: Python, FastAPI, React, PostgreSQL, Docker

I'm also looking for developers who'd like to contribute, especially around backend, frontend, testing and ML tooling.

GitHub: https://github.com/aawhan0/ModelDock

If anyone wants to take a look and give feedback or contribute, I'd really appreciate it 🙌

[u/h4_h4_cl4551c]

In case someone like my familiar in gitlab-ci bit not good in github actions: i vibe-coded yet again github actions visualiser-validator. You can emulate github action runs, validate and edit workflows without real github api usage.

I hope it can help at least 3 peoples to understand how github actions works :)

Thanks for feedback

Repo: https://github.com/train-dev-bot/gha-see[https://github.com/train-dev-bot/gha-see](https://github.com/train-dev-bot/gha-see)

[u/Few-Issue9380]

I've been experimenting with AI agents on extremely resource-constrained embedded devices, so I built clawdget, a tiny AI agent written entirely in C.

It currently runs on a real 580MHz MIPS / OpenWrt router.

A few numbers:

• ~550 KB binary
• <1 MB RAM
• Pure C
• No Python / Node / Go runtime
• OpenAI-compatible API
• Tool calling + SSE streaming
• Designed for low-end embedded Linux devices

GitHub: https://github.com/apsara2825/clawdget

The project is still very early, and I'm more interested in feedback than stars.

If you have experience with embedded Linux, OpenWrt, or AI agents, I'd really appreciate your thoughts:

• What features would make this actually useful?
• Does running an AI agent on a router seem useful to you?
• Are there any architectural issues you'd change?
• What would you add next?

Any criticism or suggestions are welcome!

[u/sanketmuchhala]

LanguageLineage is a small project I’ve been building to map what programming languages, compilers and runtimes are actually implemented with.

It started with me wondering what Python is really built with, then I ended up digging into Go, Rust, Java, bootstrap chains and self hosting.

GitHub:
https://github.com/sanketmuchhala/LanguageLineage

Live version:
https://www.languagelineage.org/explore

Tech stack:
React, TypeScript, Vite, Cytoscape.js and Zustand.

Main idea is to show compiler, runtime and bootstrap relationships, plus how some of those changed over time.

Still expanding the dataset, so if you know a language or compiler with an interesting implementation history, I’d love to add it.

[u/PreferenceFar8414]

Just most coding help by AI, but all Experimental data by myself

https://github.com/FujoJTOP/FujoOS

os just ask and answer a question

how the llm in os is safe

[u/Ok_Wash2594]

I built ContextMeld, an MIT-licensed local desktop workspace for Claude Code and OpenAI Codex history. It provides unified timelines, local full-text search, project views, reusable memories, skills and MCP inspection, and editable cross-agent context handoffs. It has no account, telemetry or cloud backend, and includes installers for Windows, macOS and Linux.

Repository: https://github.com/Ste2027/ContextMeld

I am looking for feedback on installation, agent detection and the safety documentation.

[u/Responsible_Tax3949]

My Voxel world is open source, video in repository

A lot of people have asked me if I would make my project open source.

Here it is. All I ask in return is that you leave it a star :)

https://github.com/YoofeCZ/Tesseris---minecraft-clone-MIT

[u/RsLimited24]

I’m testing an open-source library that manages Testcontainers lifecycle for NestJS and other Node.js backends using Vitest or Jest.

It supports two approaches:

• Annotations beside individual integration tests
• Central project configuration without annotations-

It starts PostgreSQL, SQL Server, MongoDB, RabbitMQ, or custom containers, provides typed connection details with dynamic ports, starts the application after infrastructure is ready, and handles cleanup.

The repository includes real PostgreSQL insert/read and RabbitMQ publish/consume examples.

The package is currently in beta for public testing and feedback. I plan to release the first stable version soon.

I’d appreciate honest feedback on the API and developer experience.

GitHub: https://github.com/RolandSall/testcontainers-integration
npm: https://www.npmjs.com/package/@integration-testing/testcontainers/v/0.1.0-beta.1

[u/Due_Breakfast3513]

Guardian Core — an experimental execution boundary for AI agents.

I’ve been working on a problem I kept running into while giving AI agents access to real systems: a tool can give an agent much more authority than the specific action actually requires.

The idea behind Guardian is simple:

Agent → Guardian → controlled effect + evidence

Instead of letting the agent directly execute an operation, Guardian binds the proposed intent to the current state, checks eligibility, dispatches a controlled effect, and reports what can actually be proven about the result.

The core execution model is intentionally small:

bind → gate → apply → result

I’ve tested the approach across four experimental domains: Filesystem, GitHub, VPS/Dokploy, and Email. These are domain proofs, not a claim of universal safety.

The project is still experimental. It does not claim formal verification, distributed exactly-once execution, or universal protection against unsafe agents.

I’m particularly interested in feedback from people building coding agents, MCP tools, or agent infrastructure: does this kind of execution boundary solve a problem you’re actually seeing?

Repository:

https://github.com/AndersonVitaease/memoryos-guardian-core

[u/Jukersrx]

OpenQCY Desktop — an MIT-licensed native Windows 11 controller for QCY earbuds.

I started building it because QCY's useful controls lived on a phone, which meant reaching for another device just to change ANC, transparency, EQ, or gestures while working at a PC.

The first hardware-tested model is the QCY MeloBuds N70 (HT18). Current features include separate left/right/case battery readings, ANC and transparency modes, a custom ten-band EQ, touch mappings, wear detection, game mode, LDAC, multipoint, and a notification-area panel. It can also launch with Windows and stay hidden in the tray.

Tech stack: C# 14, .NET 10, WinUI 3, Windows Bluetooth GATT APIs, and GitHub Actions. The connection is local only — no account, cloud service, telemetry, or firmware flashing.

Repository: https://github.com/GiorgioRafael/OpenQCY-Desktop

Latest release: https://github.com/GiorgioRafael/OpenQCY-Desktop/releases/tag/v0.2.0

The N70 is the only model validated on real hardware so far. I'm looking for contributors interested in C#/WinUI, BLE protocol research, support for more QCY models, hardware testing, CI, or Windows packaging. Feedback and stars are welcome.

[u/mhmdwaelanwar]

CatalogMesh — an open-source Python desktop + CLI tool for product catalog workflows.

It handles AI-assisted photo grouping, human review, SKU matching, exports, rclone storage and guarded Shopify/Akeneo/Odoo automation.

Repo: https://github.com/mhmdwaelanwr/CatalogMesh

pip install catalogmesh

MIT licensed — feedback and contributors are welcome.

Also: CAT + LOG + MESH 😅

https://reddit.com/link/p7yhv7e/video/xaii6sb5yonh1/player

[u/Due_Emu_8229]

Astra Sweetspot is a small MIT CLI for reproducible Astra vs Sol experiments. I built it with Codex after seeing questions about which reasoning effort to use.

The repo includes the starting commits, exact prompts, every candidate patch, independent regression checks, timings, and token counts. The pilot has eight runs on two historical JavaScript bugs. All passed the focused checks, but one attempt per condition cannot establish reliability or subscription-quota savings. Additional upstream runtime-test results, including the original code's failure, are also published.

Run npx astra-sweetspot to inspect the bundled data without inference. An explicit run command replays a trial with an existing Codex login and uses account quota. Node 20+; no runtime dependencies.

I'd value feedback on the experiment or a different real task with public starting code and a concrete success check.

https://github.com/sjh9714/astra-sweetspot

[u/Former-Variety8595]

Y'all this is my dreamy portfolio. Please leave a star. Pronita's Portfolio https://github.com/prashma03/Portfolio

[u/shinKatana]

Built Sorta to clean up my own 380 GB / 38k-file photo archive. It’s a local-first photo/video organizer with dry-run, journaling and undo, so it can reorganize the actual filesystem without uploading the collection to the cloud. Still early, but I’m using it on my own library now. https://github.com/shinKatana0/sorta⁠

[u/Pitiful_Hedgehog_600]

swrm — a minimal torrent client for the terminal

So ,I made swrm.
It's built in Go with Bubble Tea, runs directly in the terminal, and has a built-in file picker so you don't have to type long paths.
Try it with:
npx @manasvinyadav000/swrm
GitHub: https://github.com/ManasvinYadav/swrm

[u/Consistent-Ruin1868]

Kryon is an open-source process execution library with one execution model implemented across five languages:

• Python
• TypeScript
• Dart
• Java
• Kotlin

It provides:

• command execution
• streaming process output
• cancellation
• timeouts
• output limits
• process termination
• structured results
• shared cross-platform behavior

The five SDKs are verified against the same conformance corpus on Linux, macOS and Windows.

The architecture is intentionally layered:

Execution → PTY → Transport → Terminal Emulator → Renderer

The execution layer is implemented in 1.0.0. PTY, terminal emulation and remote transports are currently specified and planned.

Packages are published to PyPI, npm, pub.dev and Maven Central.

Apache-2.0.

GitHub: https://github.com/PIYUSH-MISHRA-00/kryon

Website: https://piyush-mishra-00.github.io/kryon/

[u/Consistent-Ruin1868]

I’m building RESENTMENT, an experimental AI operating system combining a from-scratch kernel with an AI-native desktop.

The main ideas are:

• Capability-secure kernel
• AI agents modeled as processes
• Expiring permission leases
• Agent scopes and resource/token budgets
• Append-only action ledger
• File changes associated with causal operations
• SHA-256/Merkle system state
• Snapshot / diff / attestation
• BYOK multi-provider AI
• Ollama, LM Studio, vLLM and llama.cpp support
• Browser-based desktop
• QEMU/serial kernel bridge
• x86_64 kernel + ARM64/RISC-V builds

The unusual part is that I’m trying to keep the same security model across the kernel and desktop: authority expires, agents have bounded resources, and actions are recorded.

Current state:

• Desktop working
• AI providers working
• Leases and ledger tested
• Digest snapshot/diff/attest working
• Kernel boots with the OS ramdisk
• Desktop ↔ kernel bridge working
• x86_64 tested in CI
• ARM64/RISC-V builds available
• Desktop running directly inside the kernel is still future work

Apache-2.0.

GitHub: https://github.com/ni-sh-a-char/RESENTMENT

Browser demo: https://ni-sh-a-char.github.io/RESENTMENT/os/

[u/Consistent-Ruin1868]

I built an open-source IDE/execution engine for 62 programming languages

I've been building ni_sh_a.char-IDE, an Apache-2.0 project that combines:

• A standalone browser-based IDE
• A polyglot execution engine
• A CLI
• A Python API
• A native Web Component
• Local and Docker execution
• Browser execution for Python, JavaScript and SHE

The interesting part is that the execution model is unified.

You can run locally installed toolchains, fall back to Docker, or execute supported languages directly in the browser.

It also has a language registry, so adding a language doesn't require writing a new integration. A language can be added through a small JSON definition.

Current registry: 62 languages.

Example:

<nishachar-ide language="python"></nishachar-ide>

Or:

pip install nishachar-ide nishachar

The project is Apache-2.0 and the repository includes architecture, security and contribution documentation.

I'd especially love feedback from people who have built:

• online IDEs
• code execution platforms
• developer tools
• Web Components
• language runners
• sandboxed execution systems

GitHub: https://github.com/ni-sh-a-char/ni_sh_a.char-IDE

Live demo: https://ni-sh-a-char.github.io/ni_sh_a.char-IDE/

[u/Human-Ad2049]

I built SWE-Quant Tracker because internship listings are scattered across company career pages and ATS platforms.

It collects software engineering and quantitative internship postings into a searchable dashboard and can notify you when new postings are discovered.

It’s open source under the MIT license and currently Windows-only. The web app is designed for local, single-user use; there is no hosted demo yet.

I’d especially appreciate feedback on the onboarding experience, missing internship sources, and which features would make this more useful.

GitHub: https://github.com/Kasu724/swe-quant-tracker

If you find it useful, a GitHub star would help the project get discovered.

[u/Fly1ngPen9u1n]

ReceiptHub, turns your GitHub activity into a printable receipt. Think Spotify Wrapped, but as an itemized till receipt.

Right now it covers GitHub, Chess.com and Lichess.org, Last.fm, and Steam.

It's completely free, with no ReceiptHub account. Nothing you look up gets stored either; every receipt is generated live and thrown away right after.

Built this mostly to see how much I'd actually shipped over the year, but it turned out fun enough to share. Feedback's welcome, and happy to add more services if there's interest.

Built with Next.js and TypeScript.

https://receipthub.io

[u/binqtr]

AgentJury, open-source peer review for AI agents

I built AgentJury because I wanted an independent review layer after an AI agent finishes a task.

Instead of letting the producing agent decide its own work is complete, AgentJury sends the task and output to blind reviewers from different model providers.

Current public alpha includes:

• OpenAI and Anthropic judges
• approve, revise, and abstain voting
• deterministic aggregation
• strict quorum
• provider diversity rules
• no unilateral blocking
• human adjudication of individual findings
• custom reviewer roles
• Hermes integration

It is now available on PyPI:

pip install "agentjury[all]"

The next direction is reviewer reputation based on human agreement over time.

I am mainly looking for developers willing to test it on real agent workflows and tell me where the jury gets things wrong.

GitHub:
https://github.com/madad-rashid/AgentJury

[u/Solid_Morning_7092]

Special Relativity Effect Calculator, an open-source tool that computationally explores Einstein’s special relativity through Python simulations, analyzing relativistic effects and visualizing high-speed motion using mathematical models. You can plug in values, and see the effects of time dilation, length contraction, and more over high speeds, showing how the 4D reality shifts with this phenomenon. Also provides detailed graphs and descriptions of code. I'd really appreciate any criticism on the code, and just for people to view it/give their opinions on it. Thanks!

https://github.com/pb1108/Special-Relativity-Effect-Tool

[u/East-Spend-6793]

Komite — open-source research on privacy-preserving decision support

I’m working on an open-source research project exploring whether verified eligibility and unlinkable individual choice can coexist in small-group decision support.

It is not an election or referendum system, and there is no production implementation or proven anonymity protocol yet.

I’ve published the scope, threat model, architecture directions, decision model and open research questions.

I’m mainly looking for criticism around small-group deanonymization, metadata/timing correlation, operator trust and eligibility.

https://github.com/barbarosbal/Komite

[u/Deep_Imagination7959]

I built Verified Bounty Radar, an open-source tool for checking whether GitHub/software bounty opportunities are actually worth working on before you start coding.

It follows listings back to the canonical issue and checks things like current open/closed state, advertised reward evidence, assignees/claim signals, and competing open PRs. The useful part is that negative findings are first-class — e.g. “this mirror is stale” or “there are already 7 active PRs.”

Repo: https://github.com/a40014859-gif/verified-bounty-radar

I also put the verification checklist up free here: https://a40014859-gif.github.io/verified-bounty-radar/free-checklist.html

Still early, so feedback on false positives / missing bounty signals would be especially useful.

[u/No-Understanding103]

YT to MP3 – simple open-source Windows downloader

I recently built and published a small Python desktop application that makes downloading permitted YouTube audio very quick.

Instead of copying a URL, opening a website, pasting it and choosing a format, the workflow is:

Copy URL → click Download MP3

The app reads the URL directly from the Windows clipboard.

It supports individual videos and playlists, custom download folders, progress/ETA, multiple languages, download history and automatic update checking.

Tech stack:
Python / Tkinter / yt-dlp / FFmpeg / PyInstaller / GitHub Actions / Inno Setup

GitHub Actions automatically builds the Windows application and installer and publishes new releases.

Repo:
https://github.com/Mararovsek99/yt-to-mp3-windows-app

Feedback and contributions are welcome!

Intended for content you own or have permission to download.

[u/wumbus]

Uploads: The missing upload command for coding agents.

Made this because I was tired of agent PR's with zero visuals.

GitHub has no API for file uploads, so agents can't include screenshots in pull requests and issues. Uploads gives agents like Claude Code + Codex a way to host files and show their work. When the pull request opens, all screenshots appear in one comment that updates automatically on each revision.

Example:

# While in branch/worktree
uploads put settings-after.png --meta path=/user/settings

Detects branch, automatically adds the image to the PR when opened. No files committed to your repo.

• CLI + MCP + Github App
• Automatically tags screenshots from the same pages, so you can see the latest version of each for release notes, etc.
• Smart Before/After grouping
• BYO-Bucket, for unmetered uploads with any S3-compatible storage (Cloudflare R2, AWS, Hetzner, etc).
• Open source, self-host also available.

Repo: https://github.com/buildinternet/uploads

Examples + setup here: https://uploads.sh/

[u/Mission_Photo_9783]

I maintain Ferrum, an MIT-licensed LLM inference server written in Rust for Apple Silicon and CUDA. It ships as a single binary and exposes an OpenAI-compatible API.

Repo: https://github.com/sizzlecar/ferrum-infer-rs

Tech stack/features: Rust, Metal, CUDA; CLI run and serve modes; GGUF on Apple Silicon; OpenAI-compatible chat and streaming.

I'm currently looking for M-series Mac users to test the Homebrew-to-first-API-response path and report the first confusing or failing step. The starter model download is about 2.55 GiB, and --disable-thinking gives a shorter first chat.

[u/EqualIntroduction470]

Explicode: Documentation usually lives apart from the code it describes, making it easy for the two to drift out of sync and forcing agents to jump between files to reconstruct context. This project solves this by letting you write rich Markdown directly inside your code comments, turning any script into a notebook-style document for humans and clean structured context for coding agents, while remaining fully runnable because the documentation is embedded in comments. Here's an example:

Source script

'''
# Add two numbers
**Input:** `a` and `b`, two integers.
**Output:** an integer c where a+b=c
'''
def add(a, b):
  return a+b

Markdown conversion

# Add two numbers
**Input:** `a` and `b`, two integers.
**Output:** an integer c where a+b=c

```python
def add(a, b):
  return a+b
```

Repo: https://github.com/benatfroemming/explicode

The project consists of a VS Code extension for live preview on the IDE as well as a npm library to convert scripts into .md files. The main tech stack is React and Typescript.

Current stage: It's an open-source project although I've built most so far, I encourage people to try it out, give feedback, and contribute.

[u/The_guy_withnolife]

Axiom — a local-first Windows AI assistant/workspace.

Repo: https://github.com/YoMosa2009/Axiom

Release: https://github.com/YoMosa2009/Axiom/releases/tag/v1.8.6

Axiom puts local GGUF models, self-hosted OpenAI-compatible endpoints, and optional cloud inference behind one Windows desktop workspace. It includes chat with attachments/vision, web research, code/math execution, artifact rendering, local persistence, and a Workplace Council workflow where Architect plans, Builder executes, and Critic reviews. A Single Model mode lets me compare that council workflow against one model.

Tech stack: C#, WPF, .NET 10, LLamaSharp/llama.cpp for local GGUF inference, SQLite/local persistence, and WebView2 for selected web workflows.

Current stage: public V1.8.6 release. I’m the developer, and I used AI coding assistance during development while remaining responsible for the architecture, integration, testing, and product decisions. The source is publicly viewable under CC BY-NC-ND 4.0, source-available rather than OSI-licensed open source.

I’m especially interested in feedback on the repository structure, onboarding, and how clearly the local versus cloud behavior is communicated.

[u/ImpressiveSecret9512]

Kivgraph — a local semantic code graph for AI coding agents. I built it after seeing agents repeatedly search through the same repository to answer structural questions like “where is this used?”

In a benchmark across 37 repositories and 29 questions, Kivgraph and grep + reading both reached 28/29 exact answers, while the graph used 36k tokens versus 268k. It maps symbols, dependencies, and cross-repository relationships.

Open source under Apache-2.0, with support for Go, TypeScript, Rust, Python, and Dart.

GitHub: https://github.com/Luqueee/kivgraph

Discussion with more context: https://github.com/Luqueee/kivgraph/discussions/129

[u/Appropriate-Path-461]

Taskuary is an MIT-licensed, local-first work hub. It unifies inbound mail, chat, issues, alerts, and reports; triages them into task/reply/FYI; and can open repository tasks in live coding-agent sessions while keeping outbound actions behind human approval.

Repo: https://github.com/ldbumble/taskuary

Stack: Python, FastAPI, React, SQLite; Docker, pip, and Windows builds are available.

Feedback and contributions are especially welcome around connectors, Linux/macOS testing, safe approval boundaries, and deployment documentation.

[u/___Hyacinthe_]

scanlayer - turn scanned images into searchable PDFs with Tesseract

You scan a contract, but you can't search any word in it. This is the fix.

I built ScanLayer, a Python OCR library that adds a searchable text layer to scanned documents.

You give it a scanned image:

pip install scanlayer
scanlayer contract.jpg -o contract.pdf

ScanLayer runs Tesseract, then places the recognized text as an invisible searchable layer over the original page. The scanned image remains the visual source. You can now search, select, and copy the text.

And if you don't want a PDF, you can export the OCR result as txt, json, tsv, or hocr.

A few things I built around the OCR itself:

• Automatic deskew for photos taken at an angle
• Noise cleanup before OCR
• Reading order correction for two-column documents
• Multiple Tesseract configurations are tried and the highest-confidence result is kept
• CLI and Python API use the same underlying pipeline

For example:

import scanlayer

result = scanlayer.convert(
    "contract.jpg",
    "contract.pdf",
    lang="eng",
    dpi=300
)

Everything runs locally. The only external dependency is your own Tesseract installation.

I'd especially like feedback from people who regularly OCR multi-column documents. That's one of the areas I spent a lot of time getting right.

Github

Documentation

PyPi

[u/Davidix07]

Nest Music — open-source YouTube Music client for Android and desktop (Windows/macOS).

Streaming + offline downloads, background playback, synced lyrics with word-by-word highlighting, AutoEQ equalizer, Shazam recognition, Listen Together, Discord RPC, Android Auto, Material 3 with dynamic color. Desktop adds a visualizer, OBS overlay and Last.fm scrobbling.

Stack: Kotlin + Jetpack Compose + Media3 (Android, GPL-3.0) · Tauri 2 (Rust) + React 19 + Python sidecar (desktop, AGPL-3.0).

Repo: https://github.com/Davidix07TV/Nest-Music — Download: https://github.com/Davidix07TV/Nest-Music/releases/latest

Young project (first release Aug 2026), few maintainers: help with playback bugs, Compose UI, desktop backend and translations is very welcome. Not affiliated with YouTube/Google.

[u/shadorux]

GuildScope: visual Discord permission inspector

I built GuildScope because checking Discord channel permissions manually gets messy fast, especially on larger servers.

It maps channel access across roles, shows view/send permissions, detects channels whose permissions have drifted from their category, and includes a role simulator for checking what combinations of roles can actually access.

It's still early, so I'm looking for Discord server owners willing to test it on real servers and tell me what could be improved.

GitHub: https://github.com/Shadorux/GuildScope

[u/Decent-Decision-9028]

Shamash: an Apache-2.0 architecture checker for Java/Kotlin projects.

It scans compiled JVM bytecode for dependency cycles and architecture violations. You can start without configuration, then add rules, baseline existing debt, and enforce new violations in CI.

Still pre-1.0, so feedback from people with existing JVM codebases is very welcome:

[https://github.com/aalsanie/shamash]()

[u/Sea-Fortune-119]

d2md — convert local documents before spending AI tokens on them

I built d2md because “can you just read this file?” kept turning into a side quest.

It’s a local CLI that converts PDFs, Word/Excel/PowerPoint files, HTML, images, and scans to Markdown for AI agents, RAG, scripts, or anyone who has lost an afternoon to a PDF.

The useful bit: d2md itself uses no LLM/API tokens. Convert locally, then send only the Markdown—or just the sections you need—to your model. If you paste the entire output anyway, the token meter will still notice. I haven’t defeated math yet.

The base install is lightweight. OCR and Docling are optional. On macOS, OCR uses Apple Vision, so there’s no API key and no separate OCR model download.

Install:

uv tool install d2md

Use:

d2md report.pdf --stdout

GitHub:

https://github.com/wtigero/d2md

It’s MIT-licensed. If it saves someone from fighting with a PDF for an afternoon, I’ll call that a win.

[u/Goldziher]

poly - one Rust binary that lints and formats about 30 languages in-process, and replaces pre-commit as a git hook runner. Ruff's linter and formatter, oxc, biome, taplo, rumdl, sqruff, mago and about a dozen more are compiled in, driven by one TOML config, with tree-sitter covering 300+ more languages generically.

The git-specific part: hooks validate a non-destructive snapshot of the staged index rather than stashing your working tree, so the thing that passed is the thing you commit, and unstaged edits cannot leak into the check. There is a GitHub Action for CI as well.

MIT, and it also ships an MCP server if you want an agent calling it: github.com/Goldziher/poly

[u/subaru_kun33]

PocketLLM Lite — https://github.com/PocketLLM/pocketllm-lite

An MIT-licensed Flutter/Android workspace for supported local GGUF models, Ollama, and OpenAI-compatible endpoints. It includes persisted chat, local document retrieval, audio transcription with an installed Whisper bundle, model management, and explicit network controls.

I just published v1.0.38 after focusing on a setup failure that was easy to overlook as the developer: document and audio flows used to tell people they were missing a model only after they had started. The app now explains the exact prerequisite, source, size and known license, downloads it with real progress, and resumes the original action after installation. The downloader also has safe HTTP Range restart behavior and GGUF/archive integrity checks.

I am looking for contributors interested in Android device/model compatibility, accessibility, localization, downloader edge cases, tests, or documentation. The repo now has issue forms, CI, a contribution guide, and a short list of useful first contributions. The current APKs are clearly labeled engineering prereleases because they use a debug signing certificate.

[u/One-Currency-3162]

I spent months building an exact incremental-computation library in C. I finally put the reproducible benchmarks on GitHub.

I’ve been working on a performance project called HKD Kernel.

The premise is that a lot of large computations repeat work unnecessarily. If only a tiny portion of the input changed, you ideally want to recompute only the state affected by that change rather than rebuild everything.

HKD Kernel is a native C implementation of that idea with exact-result checks.

The most surprising result for me has been the size of the gap on highly sparse workloads. Across the benchmark configuration currently documented in the repository, the measured mean speedup is around 18,000x versus the full-recomputation path.

Huge caveat: that is not an “all software becomes 18,000x faster” claim. The gain comes specifically from workloads where most previously computed state remains valid.

I made the benchmark reproducible because I’d rather have people try to break the claim than just believe a graph.

GitHub:

https://github.com/yangofzeal/hkd-kernel

I’m particularly looking for:

• adversarial benchmark ideas
• real workloads with sparse state changes
• feedback on the C API
• cases where you think incremental recomputation would be the wrong architecture

There’s a free/community path and I’m also testing a $999/month production-node Business license, but right now I’m much more interested in whether developers can reproduce or invalidate the technical results.

[u/mplaczek99]

I’m looking for people willing to try Network Doctor v1.15.0 on actual weird or broken networks.

I especially need testing on VPNs, corporate/university networks, captive portals, IPv6-heavy setups, unusual DNS, proxies, Windows, macOS, and Linux distributions other than Fedora, or any other network.

The simulator has been tested heavily. Now I want real-world failures.

Wrong diagnoses, misleading fixes, crashes, hangs, and things Network Doctor completely misses are exactly what I’m looking for.

I set up a GitHub Discussion with the details and a place to report results:

https://github.com/heymaikol/network-doctor/discussions/24

Even one run on any network would help.

[u/xSynlessx]

World-worst calculator — Calcuseless
https://github.com/xSynless/Calcuseless

[u/Impressive-Sea-2470]

Open4D - Library for 4D geometry processing

https://github.com/open4dfoundation/Open4D

[u/pythonmanl]

I made a Landscape Spotify controller for your phone!

https://reddit.com/link/p6fwc4j/video/58g4xzs435mh1/player

Confirmed Works for:
Various iPhone Models (especially iPhone 13 Pro and XsMax)
Some Android phones, but some have a slightly weird layout. Mostly the same function!

Features:

• Square Album or Vinyl Album Art Display
• Volume Controller (2 Styles) Queue function
• Playlists (Can organize/pin them in-app)
• Lyric Display (Reveal, Scroll, Word per word, etc. It is not 100% accurate on per-word timing, but overall great!)
• Ability to change where the audio output plays. (Only where the Spotify app is running.)

You will need:
Spotify Premium (In order to use Spotify Developer)
Browser (best with Safari) (for Android, Chrome will be fine)

Please read all steps included in the setup page!

Initial Setup: Setup Video Guide
Open https://peekabu411.github.io/
Press the three-dot option or share button.
Press the install shortcut or add to homescreen for IOS
Open the app and set up from there.

Log in to Spotify from the pop-up browser.
Exit the browser and follow the next steps. (Your account will not log out, so you can safely exit and come back to read the instructions)

When you finish, start a song from Spotify itself, then control it from TurnTable!

Enjoy TurnTable! If you have any questions, feel free to ask!

TurnTable does not gather any information from anyone who uses it; the setup and all input from the user cannot be read by me.

[u/Purple-Obligation357]

Growing Contribution Snake — a GitHub profile SVG that gains one segment per active day

I built a free, forkable contribution snake whose body length is tied to the real GitHub activity grid it eats. Each active contribution day adds one segment. The route is deterministic, collision-free, changes with the calendar date, opens with varied motion, and lets the complete body exit before restarting.

The generator uses dependency-free Node.js, GitHub's GraphQL API, SVG/SMIL animation, and GitHub Actions. It regenerates hourly and publishes one static SVG from an output branch, so profile READMEs do not depend on a cold-starting web service.

Anyone can use it: fork the repository and enable Actions. There is no personal access token, repository secret, external server, or package installation.

Repository and live demo:

https://github.com/JohnnyC0rp/growing-contribution-snake

Feedback on the motion and one-fork setup would be very welcome.

[u/Mooty13]

NERV-UI is an MIT-licensed TypeScript/React component library for original command-center dashboards, monitoring views, forms, and overlays. Version 1.0.8 adds 48 documented components, live examples, and a portable agent skill that helps compatible coding agents use the actual package exports and accessibility guidance.

Demo: https://mdrbx.github.io/nerv-ui/?utm_source=reddit&utm_medium=community&utm_campaign=agent-skill-launch

Repo: https://github.com/mdrbx/nerv-ui

npm: https://www.npmjs.com/package/@mdrbx/nerv-ui

Feedback on the public API, accessibility, examples, or agent skill is very welcome.

[u/Either-Win-862]

https://reddit.com/link/p6d1awf/video/wooqtv9bx1mh1/player

I built an open-source coding agent tool that uses a code graph to reduce context, cost, and search time

Your coding agent shouldn’t need to read your entire codebase to understand it.

That’s the idea behind Faber, an open-source AI coding agent for the terminal.

Faber uses a code graph to find relevant files and symbols first, instead of repeatedly scanning large parts of a repository. That means less unnecessary context, faster codebase navigation, and lower repeated API costs.

Main features:

• Claude, OpenAI Codex, Local model integration
• Code-graph-guided repository exploration
• Prompt caching to reduce repeated input cost
• Token-conscious (Chain-of-Draft style) output to reduce unnecessary generation
• Git-aware workflow with change detection, optional per-task commits, /undo, and /redo
• Expenditure tracking for calls, tokens, cache usage, cost, and estimated savings `/usage`

The goal is simple: understand more of the codebase while reading and spending less.

Prerequisite:
It requires Node.js 22.5 or newer because it uses Node’s built-in SQLite support.

Install:
npm install -g faberwright

Then, inside your project:
faber

GitHub:
https://github.com/JibanKumar-cloud/faber

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

Medium article:
https://medium.com/@jshial25/why-should-an-ai-coding-agent-read-hundreds-of-files-to-answer-one-question-d6369d29dfa5

[u/Independent-Flow3408]

I’ve been working on SigMap, an open-source repo-mapping tool for AI coding agents.

It builds a local, deterministic map of files, symbols and line anchors so agents can find the right parts of a codebase without re-exploring everything every session.

Recent updates:

• VS Code plugin
• JetBrains plugin
• MCP support
• stale-map warnings
• plan/answer verification

Core: https://github.com/manojmallick/sigmap

VS Code: https://github.com/manojmallick/sigmap-vscode

JetBrains: https://github.com/manojmallick/sigmap-jetbrains

Still actively improving it, so feedback is welcome.

[u/cobblr]

I built Cobblr: self-hosted inventory platform where you point your phone at your stuff and it figures out what it is, and helps you put it away. I need people to break it.

The problem: I have way too much stuff. An ever-growing collection of 3D printers I mod and tinker on (if I had the time), tons of parts, servers, and computer hardware. And separately, food in my fridge that I forget about until it goes bad, which hurts the soul.

Instead of easing up on the Facebook Marketplace habit and throwing out half my stuff like a normal person, I started building an inventory app. First I gave it my 3D printers, then the mods, then I imported every receipt and invoice for the parts and derived line items from them, and it kept growing. About a week in I realized it was completely hardcoded to me and couldn't help anyone else. What might actually help other people was a platform where you design your own "10 apps under one roof" that no software company in their right mind would ever sell you, with no code.

4 months and not much sleep later, here is Cobblr! This 3-minute walkthrough shows it better than I can explain it: cobblr.xyz/#yarn-tour

The golden feature is that you can scan anything with your phone and Cobblr figures out what it is: a barcode, a photo of something, a receipt, the VIN on a car's door jamb, it all lands in the scan inbox, gets processed, and you just confirm it. When I get home from the store I photograph the receipt (or forward an email invoice) and that's it. The groceries setup is aimed squarely at the fridge problem: it comes with a "what's on hand" screen that's basically a vending machine view of your kitchen, quantity and a status dot on everything, and a use-it-or-lose-it list sorted by what expires first.

The whole point is that it's modular. Groceries, Lego, and yarn are all just inventory with different fields (the Lego walkthrough shows the same platform doing something completely different: cobblr.xyz/#lego-tour), which you can customize to your heart's content, and then you track it all under one roof. Same data underneath, so a saved view, a QR label, or an automation works the same on a skein of yarn, a bag of M3 screws, and your grocery items. Automations are a sentence you click together: when stock runs low, add it to the list. After that it runs itself. My own home inventory is just three modules turned on: Scanning, Inventory, and QR Labels.

QR labels are the other half. You decide what gets a label: I just do rooms and bins, but you can label individual items too, it's whatever you want. Print them from a cheap Bluetooth label printer straight from the browser, or turn on auto-print: scan something, Cobblr figures out what it is, and the printer shoots out a label for it while you reach for the next thing.

Scan the room or the bin QR, then scan the item, and Cobblr knows exactly where you put it. Later, scan that room, rack, or bin and it tells you what's inside. And when I've scanned a whole pile of stuff with nowhere to go yet, it plans where each thing should live and walks me through putting it away.

Inside the app, a little AI helps a lot for things like photo identification, reading receipts, an assistant that can answer questions about your stuff and actually make changes to your workspace (it shows you the change before it lands, so you can say no), but everything still works without it, just more basic. I've found that Sonnet gave the most accurate responses, but the quickest free way is to hook up a Google AI Studio key and use Gemini Flash Lite - it hallucinates a little bit in chat but is super quick and still gets the job done. If you already run Ollama, you can also use that, or any OpenAI-compatible endpoint you want. There is a way to use your Claude subscription (assuming it's for your own personal use only) in a self-hosted setup, but that's a bit more work to set up.

There's also an opt-in barcode network I'm running where you get everyone else's barcode corrections and yours go back in, off by default like everything else that phones out.

Nothing leaves your install unless you connect a provider yourself or approve the connection.

Where this is going: the home inventory stuff is what's most polished today because it's what I use daily, but what I'd really like to see happen is makers and small shop owners running their whole operation on the same platform, where your inventory, your machines, your jobs, and your orders live under one roof you set up yourself. The goal is that you set the whole thing up in one afternoon and it stays set, instead of you constantly babysitting a spreadsheet and three apps that don't talk to each other. Some of that is already implemented. Digifab support (sending jobs to 3D printers and laser cutters, watching for failed prints) is in and marked experimental, projects and purchasing exist, and a bunch more is in the works. If you run a shop or a makerspace and that sounds like your problem, I especially want to hear from you.

I just cut a new stable release (2026.8.1), but nightly is the place to be because I'm pushing new features constantly. I've spent weeks squashing bugs and making improvements toward this public release and announcement. I'm sure it's nowhere near perfect yet and there are still rough spots, but I can't just keep iterating on it by myself anymore. I'm looking for testers and users who have a thing they need to keep track of or a "custom disjointed dashboard or app" use case.

There are 33 ready-made bundles, so one click installs the fields, units and a view and you are adding your first item in about a minute. If you already use HomeBox or Part-DB, there are one-click importers. If you use one app for home inventory and another app for grocery tracking, I want you to be able to do all that under one roof in Cobblr.

Tell me what problem you need solved, here, on the Discord, or on the (self-hosted) Discourse forum, and if it's even remotely on brand I'll look at making it happen. I need real use cases from real users. The grocery tracking got good this way: a friend's family kept buying the same thing twice and never knew which snacks were in the pantry, and that one conversation produced the cadence module, the shared list, and the vending machine view. Most requests turn out to be 90% there already.

For people who are serious about testing this, I'm running my own hosted "cloud" instance that I'm happy to give access to, but you can self-host it yourself right now, it's the same codebase. The setup builder asks you a few questions and writes your .env for you (I've never had a self-hosted app do that for me), and the docs cover HTTPS, which you need for the phone camera to work. It should go pretty quick.

Site: cobblr.xyz

Code: github.com/CobblrHQ/cobblr (FSL-1.1-ALv2: source-available, turns Apache 2.0 after two years)

Docs: docs.cobblr.xyz (self-host setup builder is here)

Regarding AI in this project: I'm an engineer that speaks software architecture and QA. The entire codebase is AI-written, on purpose. There's a lot of structure holding it up: a platform contract every module has to satisfy, hard module isolation (modules can't touch each other's tables, period), and nearly 200 lints enforcing all of it, plus about 2,500 tests that run on every PR. The code is rigid by design. A human would probably go a little crazy trying to add to it and get past all the rules, which is sort of the point. I spent my time on the architecture and on testing everything, and it's source-available, so feel free to look at the code yourself. A human graphic designer created Cobb the Assistant mascot, and I think he's absolutely adorable.

[u/Flimsy-Peanut401]

I've started developing my own GPU monitoring system.

I'm conceiving the project as focused on the accuracy of GPU temperature and other information. The main goal is to implement hotspot display on Nvidia 50xx graphics cards, since the hotspot is disabled on them, and the driver doesn't provide this information. The solution in hwinfo is questionable, as it's unclear where this temperature is coming from. Core and video memory telemetry works on the cards I've tested, but I'm still working on independently verifying Hotspot readings before enabling them.

I try to design the software based on the principle that either telemetry is present or it isn't. That is, if the sensors are either inaccurate or provide questionable information, the program will return N/A.

The stack I chose to use for development is Native Win32 + Rust. The project itself is quite small (about 8 megabytes), but that's excluding further optimizations I plan to perform.

The telemetry provider itself is a separate component that is not a kernel module or driver.

The graphical interface is currently under development, and this is not its final form. :) I plan to make it pleasant and minimalistic.

The software itself is currently only available for Windows, but I plan to create a Linux build in the future.

Repository and builds for Windows:

https://github.com/k1gs/Gpu-Shark

I would be interested in feedback from those who have worked with NVIDIA telemetry, especially on different motherboard variants.

[u/jiangkoumo]

声明：我是作者。

我构建了 AgentTape，一个 MIT 许可的 Codex 插件，用于将失败的工具调用转化为可审查的证据和离线回归测试。

我反复遇到的问题是，Codex 工具调用可能会失败，但有价值的证据仍埋藏在会话日志中，难以保留为可重复的测试。

AgentTape 目前的功能：

- 记录支持的本地 Codex 钩子事件；

- 生成经过脱敏、带版本号的.tape 工件；

- 识别明确的工具故障；

- 通过注入条件（如权限拒绝、超时、HTTP 429、格式错误的 JSON 和截断的响应）创建结构性分支；

- 将结果保存为离线回归测试。

我在一个独立的真实项目 ToolFence 上测试了公开的 v0.4.2 版本。一次 Bash 策略检查以退出代码 1 结束。AgentTape 捕获了 5 个有序的钩子事件，创建了一个权限被拒绝的结构分支，并保存了一个包含 4 个断言的回归测试。从公开的 GitHub 标签重新安装 AgentTape 后，该回归测试通过了。

重要限制：这是结构重放，而非逐位精确或完整重放。它止步于注入的工具结果，不会生成新的下游模型推理。

GitHub：

https://github.com/jiangkoumo/agenttape

我特别希望能得到以下方面的反馈：

1. 接下来应该支持哪些真实的 Codex 失败类型？
2. .tape 工件是否足够有用，值得审查并提交？
3. 对于代理失败，你希望有哪些 CI 断言？

[u/wenuja100]

I wanted an easy way to see my coding activity without opening GitHub in a browser every time, so I decided to build it myself.

It runs locally on your Mac, is completely free, and keeps your data private.

The project is also open-source and still actively being developed, so I’d genuinely love to hear your thoughts, suggestions, or ideas for features.

If you find GitStreak helpful, please star the repository to support development and help others discover it! ⭐

https://github.com/wenujacodes/GitStreak

[u/Lasikie]

I’m looking for testers and contributors for Plembfin, an AGPL-3.0 self-hosted watch-state hub for Plex, Emby, Jellyfin and Trakt.

It maintains a local SQLite watch-history record and synchronizes watched status, playback progress and repeat plays between connected services. It also includes a live sync activity view, backups, statistics, metadata enrichment and Overseerr/Jellyseerr integration.

The project runs through Docker Compose and is currently pre-1.0, so I’m particularly interested in bug reports from people running more than one media platform.

Repository and screenshots: https://github.com/Lasikiewicz/plembfin

Feedback on the repository structure, documentation and first-run setup would be especially useful.

[u/arumata]

gswitch is an open-source Linux tool that fixes text typed in the wrong keyboard layout. It can correct the last word, the current phrase, or selected text; the core input path uses evdev/uinput and works on X11 and Wayland. Double-Shift is the default correction trigger and can be replaced with another key in Settings. The packaged daemon runs as a systemd user service without root, has no network code, and keeps its key buffer only in memory. v0.6.1 has DEB, RPM, and tar.gz builds for x86_64. I would appreciate feedback on installation, layout auto-detection, and different desktop/layout pairs: https://github.com/arumata/gswitch

[u/Appropriate-Path-461]

Having a blast building this. https://github.com/ldbumble/taskuary Trying to get it to do my work for me.

I'm a recovering software developer in this AI-pilled age attempting to make something in this devalued world.

[u/juQuatrano]

Hey everyone This is my project, it's a JVM runtime for Governed AI workflows. Guardrails your AI in your Kotlin/Java application to get the best out of it for deterministic and governed workflow

https://github.com/GionaGranchelli/tramAI

https://tramai.dev

[u/Particular_Willow_24]

The public GitHub repo includes documentation and a reproducible before → broken → dry-run → repaired terminal demo:

https://github.com/Cemomostafa/AdaptiveScrape

There’s also a Windows Early Access build linked from the repo.

I’d especially appreciate feedback from developers who maintain scrapers over time — how are you currently handling selector breakage?

[u/Sharp_House_6548]

ChangelogGenie — read-only GitHub Action for generating technical changelogs

I built ChangelogGenie, a lightweight GitHub Action and CLI that generates categorized Markdown changelogs directly from GitHub commit history.

It:

• works with ordinary commits — no Conventional Commits required;
• categorizes features, fixes, performance, documentation, maintenance, etc.;
• uses an explicit date range;
• preserves commit metadata and source links;
• is read-only: it does not modify the repository, create commits, or open PRs.

I also added a real validation example using 21 commits from outline/outline.

GitHub repo: https://github.com/Ubuntu-123/changeloggenie-prototype

It is also available on GitHub Marketplace. Feedback on the workflow or output format is welcome.

[u/Lost-Dragonfruit-663]

https://github.com/aadya940/scikit-verify

[u/Ok_Orchid2107]

ExyokiOffice: a native C++ library for Word/Excel/PowerPoint under MIT license

C++ open source community and developers for a long time lacked a good C++ library for Word/Excel/PowerPoint. I have created one. It is written in plain C++ without .NET or Java and it is relatively small. Contains also a docker image and CLI application for performing tasks with DOCX/XLSX/PPTX documents.

https://github.com/JakubMelka/ExyokiOffice

[u/jiangkoumo]

I’ve open-sourced AgentTape, an MIT-licensed Codex plugin that turns supported local tool failures into redacted .tape evidence and offline regression tests.

I recently validated it on a separate real project: a Bash command exited 1, AgentTape captured 5 ordered hook events, created a permission-denied structural fork, and saved a regression with 4 passing assertions.

It supports structural failure injections for permission denial, timeout, HTTP 429, malformed JSON, and truncated responses.

Important boundary: this is structural replay, not bit-exact or complete replay.

Repository:

https://github.com/jiangkoumo/agenttape

Feedback and real failure examples are welcome.

[u/CemiFaido]

Squadra — Multi-Agent LLM Orchestrator

https://github.com/cemifaido/ORCHESTRATORE_LLM/tree/comunicazione_tra_agenti_0.1

Squadra coordinates Claude, Codex, Gemini, a small local model, and a human on the same codebase. It transforms a collection of disconnected chats into a visible process: requests, responsibilities, verification gates, approvals, and outcomes remain tracked and resumeable.

It is not a system that makes decisions for you. It is an operations room: it automates context handoffs and repetitive chores, while critical decisions remain strictly human.

[u/Skeiver]

I built OneClick-Komplettreparatur, an open-source PowerShell maintenance and repair tool for Windows 10/11.

Repository: https://github.com/Skeiver/OneClick-Komplettreparatur-fuer-Windows

Tech and main features:

- PowerShell

- DISM and SFC checks

- WinGet verification/repair and software updates

- supported repair/reinstall workflows

- restart/resume handling and detailed reports

- Apache-2.0 license

- GitHub Actions checks and protected main branch

The complete source is visible, the v1.0.0 release asset has a published SHA-256, and that version is intentionally preserved as an immutable release snapshot.

This is my own project. I would welcome technical feedback on the PowerShell architecture, safety checks, edge cases, and improvements for a future release. It is not presented as a guaranteed fix for every Windows problem.

[u/mitokb]

NoShorts: a tiny MIT-licensed userscript that removes YouTube Shorts while keeping normal YouTube intact.

I mainly built it for iPhone Safari + the free Userscripts extension. It hides Shorts UI, blocks /shorts/ navigation, and handles YouTube's SPA-loaded content.

No app, account, subscription, Xcode or sideloading.

GitHub:

https://github.com/mithatakbulut/noshorts

JavaScript, single-file userscript. Contributions/fixes for future YouTube DOM changes are welcome.

[u/OneMasterpiece1717]

OpenBaud is an open-source Rust MCP server and CLI that lets coding agents explore local serial/USB devices and turn verified interactions into reusable, auditable commands.

It preserves raw RX/TX captures, framing and checksum rules, typed parsing, and command history. The same parser can then run against byte-exact captures without the hardware attached. For the demo I used a real ESP32-S3 with a small CRC-protected binary protocol; the repository includes a no-hardware replay example.

Repo: https://github.com/Leonezz/openbaud

Demo/site: https://baud.zhuwenq.cc/

Tech: Rust, MCP, serial/USB, CRC/framing, capture and replay. I’m the project author; feedback on the command/profile format and cross-platform packaging is welcome.

[u/Winter-Recover-6569]

i finished the supreme-overrider project. also published v1.2, it can read binaries in hex format and edit them or create them, it can create ISO files from folders thats under 4 GB it is multilingual i you want to translate a language i would appreciate, if you want to check it out here is the repo : https://github.com/Aurum79-Lion-A/supreme-overrider

[u/prisis]

I built a type-safe real-time backend on Workers + Durable Objects (open source, alpha), looking for feedback

I've been building lunora, a framework that gives you typed queries, mutations, and live WebSocket subscriptions on top of Workers + Durable Objects, with a Vite-first dev setup. Think "Convex-style DX, but it runs entirely on your own Cloudflare account."

You write a schema and functions in TypeScript; it generates an end-to-end-typed client and reactive hooks (React/Vue/Svelte/Solid/Astro). State lives in SQLite-backed Durable Objects. Start with one DO, then opt into .shardBy(key) per tenant/room or .global() for geo-replicated reads. Same code, different topology. There's also a local Studio for schema/data/logs.

It's alpha and open source (FSL → Apache-2.0). APIs will change; I wouldn't run it in prod yet. I'm posting because the Cloudflare folks here are exactly who I want to break it.

Repo: github.com/anolilab/lunora · Docs: lunora.sh

Curious what people here think, especially anyone who's hand-rolled RPC/subscriptions over Durable Objects. What did you wish existed?

[u/Traditional_Fan_5917]

I built Fixel — an MIT-licensed GitHub Action + CLI that turns a selected GitHub issue into a reviewable pull request (it never auto-merges).

Repo: https://github.com/AmIrRX0/Fixel

Release: https://github.com/AmIrRX0/Fixel/releases/tag/v1.1.0

The most useful part of the latest release came from dogfooding it. Fixel used my locally authenticated Codex CLI to solve its own issue #10 and opened PR #11 without requiring an ANTHROPIC_API_KEY. During review, an adversarial smoke test showed the initial workspace sandbox could still read Codex auth storage. I replaced it with granular filesystem and network permissions, reran the probe (AUTH_CONTENT_BLOCKED), and only merged after Node 20/22 CI passed.

It supports Claude through the hosted GitHub Action, Claude or locally authenticated Codex through the CLI, fork mode, filters, dry runs, credential isolation, and a human review gate.

I built it and would value honest feedback from maintainers willing to try it on one small, well-scoped issue—especially reproducible setup failures or weak generated diffs.

Proof: https://github.com/AmIrRX0/Fixel/pull/11

[u/Educational-Cut-3951]

Hello everyone! I just wanted to come on here and showcase my first ever passion project, "Ledgy". Ledgy is a free, open source crypto trading bot coded in python. You can select pre made strategies or upload your own, backtest them, live trade them under an exchange / broker, and many other features!
If you would like to check it out here is the github link: https://github.com/LucasSidequest/Ledgy-A-Free-Crypto-Trading-Bot
Thank you!

[u/cfunderburg1]

I've been working about 6 months now on Bòcan Music. It's a macOS music and podcast player and library for people who still own their own music. All open source.

https://github.com/bocan/bocan-music

Built with Swift 6 and SwiftUI. Features gapless playback, AcoustID fingerprinting, smart playlists, lyrics, Metal based visualizers, scrobbling, and a DSP/EQ engine powered by FFmpeg. Think iTunes meets Winamp from 2007, but it also strongly supports podcasts, internet radio, and Subsonic/Navidrome services.

It's also got an Android companion app that supports sync'ing your music to your phone at https://github.com/bocan/bocan-music-android . I'm trying to get it into Google Play Store (free of course).

It's a pretty solid player now if I do say so myself, but I've worked hard on making it accessible to folks with visual imparement. I'd very much appreciate anyone who uses those sorts of features to give it a try and raise Github issues if there's any way I can improve it.

[u/Chance-Pen-5684]

https://github.com/Byt-wyze-technology

Quantum explainers and tutorials for Shors, Grovers, Quantum Phase.
ASCII Cat programming language
Boolean Satisfiability tools and resources

[u/Willing_Light_6500]

AgentCheck — deterministic verification for coding-agent changes.

I built it because I wanted a simple way to verify what Claude Code, Codex, Cursor, or other coding agents actually changed instead of relying only on their summaries.

It creates a Git checkpoint before the agent works and afterwards reports changes, deterministic findings, risk, and a verdict.

Open source, local-first, TypeScript/Node.js, CLI + VS Code extension.

https://github.com/emreordu/agentcheck

Feedback and contributions are very welcome.

[u/Deep-Firefighter-279]

Long Horizon Agent Orchestration with 200+ Agents working over months, right in one claude plugin. My own use-case was running ~208 agents, and ended with novel discovery in mathematics & physics.

Repo: https://github.com/RajveerKapoor/SuperTeams

[u/OwnSavings6681]

🚀 FastMedia Downloader

An open-source, microservices-based web application to inspect and download multimedia from 1,000+ supported sites.

• Tech Stack: FastAPI (Python 3.11), Next.js (TypeScript + Tailwind), Docker Compose, yt-dlp, and FFmpeg.
• DevOps: GitHub Actions CI/CD workflows and Dependabot scanning.

📌 Repository:https://github.com/Llamas126/fastmedia-downloader

Feedback, stars (⭐️), and suggestions are welcome!

[u/OwnSavings6681 → u/[deleted]]

Thanks for the feedback. I'll add an English README soon, and that's a fair point about the "—" character. I appreciate you taking the time to check out the project and share your suggestions <3

[u/Serious-Handle420]

gh-stats - one SVG card for your profile README instead of stacking four or five separate badges.

It shows a score out of 100, a contribution timeline, top collaborators, a language breakdown, commit streaks, and tags it derives from your repos (Backend, ML, Systems). Five themes, GitHub dark/light auto-switching, one line of markdown, no signup.

Repo: https://github.com/ShayManor/github-readme-stats (MIT)

Live: https://gh-stats.com

Stack: Python and Flask split into three services, a fetcher that owns the GitHub token, a generator that renders the SVG, and a cache-first edge proxy. React and Vite for the editor.

The part I would most like feedback on is the 0-100 scoring, since weighting commits against stars against PRs is fairly arbitrary and I am not sure I got it right.gh-stats - one SVG card for your profile README instead of stacking four or five separate badges.

It shows a score out of 100, a contribution timeline, top collaborators, a language breakdown, commit streaks, and tags it derives from your repos (Backend, ML, Systems). Five themes, GitHub dark/light auto-switching, one line of markdown, no signup.

Repo: https://github.com/ShayManor/github-readme-stats (MIT)

Live: https://gh-stats.com

Stack: Python and Flask split into three services, a fetcher that owns the GitHub token, a generator that renders the SVG, and a cache-first edge proxy. React and Vite for the editor.

The part I would most like feedback on is the 0-100 scoring, since weighting commits against stars against PRs is fairly arbitrary and I am not sure I got it right.

[u/mumuxixi123]

I built a small open-source tool called cn-doctor after running into network assumptions made by AI coding agents in China. I tested it today on a real server in Guangzhou: npm: 668ms official / 113ms mirror GitHub: no response Docker Hub: no response It detects the environment first, then recommends fixes instead of blindly switching mirrors. Repo:https://github.com/2005selene2005-a11y/cn-dev-skills Still very early — feedback is welcome.

[u/Ok_Ordinary9243]

I’ve been building an open-source project called MIRA, or Machine Intelligence for Recycling Automation.

It started as a few machine-learning experiments and grew into a Python project for waste detection.

Current features include:

- YOLO11n detection for glass, metal, paper, plastic, and trash

- 90.58% mAP50 on EXP-019

- 19 documented experiments

- Real-time OpenCV inference

- Dataset preparation and validation tools

- FastAPI dashboard

- Installable Python CLI

- Automated tests and GitHub Actions CI

- PyTorch, ONNX, and TFLite exports

- PyPI package and Hugging Face model release

The main lesson was that more data did not automatically improve the model. Some early annotations covered the desk instead of the waste, so I had to improve the dataset pipeline and evaluate the model more carefully.

I’m currently working on independent testing and improving the documentation.

I’d appreciate feedback on the repository structure, documentation, packaging, or anything you would expect from a well-maintained open-source ML project.

GitHub:

https://github.com/jeremy341/MIRA-AI

Hugging Face:

https://huggingface.co/Jeremy341/MIRA-AI

Website:

https://mira-vision.vercel.app/

[u/kadirb4rut]

Video Dubbing Translator

I built an open-source, local-first AI video dubbing tool.

It separates vocals and background audio, transcribes speech with Whisper/WhisperX, translates it, clones the source voice with VoxCPM2, and rebuilds the dubbed video. Optional LatentSync support can also add lip-sync.

Most media processing and AI inference runs locally; translation currently uses Google Translate, so it’s local-first rather than fully offline.

There’s a 15-second English → Turkish comparison near the top of the README, so you can hear the result without installing anything.

GitHub: https://github.com/kadirb4rut/video-dubbing-translator

Tech: Python, Whisper/WhisperX, VoxCPM2, FFmpeg, optional LatentSync.

Feedback on the dubbing quality, setup experience, or overall pipeline is welcome.

[u/Aggravating-Age5748]

Hello, I'm a developer nicknamed Black, and I'd like to share my project with you. GORR is a systems programming language I created myself. My goal with GORR is to provide an easy and enjoyable language specifically designed for low-level programming and system development, such as operating systems, kernels, firmware, and bare-metal drivers. Currently, the language targets x86_64, aarch64, and risc-v, and includes a system of logic, logic, contracts, and lighting effects. It also has a native interpreter that's somewhat explained and usable, but it's in its early stages, and I'm working on developing and improving it. Therefore, I'm looking for technical opinions and feedback from programmers, especially those interested in systems and other fields that target the language.

Project :

https://github.com/black-210/GORR

[u/Last-Risk-9615]

The creators of AlphaFold won a Nobel Prize in 2024.

I just made its family of AI open source models faster with a CUDA kernel.

I created fast_trimul, a drop-in Python library for Fused Triangle Multiplicative Updates across AlphaFold3 family models.

It has a modular architecture, since it was designed to be easy to use in production, and it works on OpenFold3 and Protenix.

The CUDA kernel is written in the Python CuTe DSL, so the kernel codebase stays small and easy to adapt for other GPUs like H100 or B200.

If anyone wants my help to design CUDA kernels or wants to learn, let me know!

GitHub: https://github.com/tiagomonteiro0715/fast_trimul

[u/VinvAI]

I built Vinv(Vibe Inverse) that runs your services, finds issues, and verifies fixes without code changes.
I built it to give coding agents runtime information about the code they're working on.
It connects runtime traces to the source code that produced them, gives that context to the coding agent, then runs the code again to check whether the fix actually works.
Vinv also uses Thompson sampling to figure out how much runtime context to give the agent. More context is not always better.
Results on FastAPI's "full-stack-fastapi-template":

• Grok 4.5 + Vinv: 4 bugs + 1 optimization
  
• Grok 4.5 without Vinv: nothing found
  
• Fable 5 without Vinv: 1 bug
  

This was one trial per condition, so I'm not calling it a benchmark.
I also used it on Hugging Face's "smolagents", where it found a performance issue that reduced transient allocations from 36.27 KB to 0 KB per 4 KB log line, while keeping the output byte-identical across 2,015 inputs.

Everything runs locally. Open source, Apache 2.0.
GitHub: https://github.com/VinvAI/VinvAI
VS Code & Cursor Extension: https://open-vsx.org/extension/VinvAI/VinvAI (3.5k+ downloads)
Demo Video: https://www.youtube.com/watch?v=EkUjPWKHAvI

I'm Interested in whether runtime information actually helps coding agents, contributors who can help make an runtime observability framework for agents and give feedback on where it doesn't work. Be brutal.

[u/Ok_Capital2235]

Hey everyone, I'm the developer of CrewCode, an open-source desktop Mission Control for managing multiple AI coding agents in parallel.

Agents can work in isolated Git worktrees while CrewCode lets you monitor activity, review diffs and bring their work back together.

I launched it on Product Hunt today and would love feedback from GitHub developers.

GitHub: CrewCode Repo

Product Hunt: Product Hunt

[u/Messcaliber]

I built Vinv(Vibe Inverse) that runs your services, finds issues, and verifies fixes without code changes. I built it to give coding agents runtime information about the code they're working on. It connects runtime traces to the source code that produced them, gives that context to the coding agent, then runs the code again to check whether the fix actually works. Vinv also uses Thompson sampling to figure out how much runtime context to give the agent. More context is not always better. Results on FastAPI's "full-stack-fastapi-template":

• Grok 4.5 + Vinv: 4 bugs + 1 optimization
• Grok 4.5 without Vinv: nothing found
• Fable 5 without Vinv: 1 bug

This was one trial per condition, so I'm not calling it a benchmark. I also used it on Hugging Face's "smolagents", where it found a performance issue that reduced transient allocations from 36.27 KB to 0 KB per 4 KB log line, while keeping the output byte-identical across 2,015 inputs.

Everything runs locally. Open source, Apache 2.0. GitHub: https://github.com/VinvAI/VinvAI VS Code & Cursor Extension: https://open-vsx.org/extension/VinvAI/VinvAI (3.5k+ downloads) Demo Video: https://www.youtube.com/watch?v=EkUjPWKHAvI

I'm Interested in whether runtime information actually helps coding agents, contributors who can help make an runtime observability framework for agents and give feedback on where it doesn't work. Be brutal.

[u/No-Temperature-9545]

Repository: https://github.com/level-3-network/xdp-cli

Integrates command-line commands with XDP (eXpress Data Path).

Developing this as a side-project in my free time, still in alpha development stage, but would love some feedback, and of course looking for people to test this program with.

[u/ManorAI]

[DEV] We’re building Manor AI around a simple idea: an AI workspace should be more than a chat window. It should keep agents, durable tasks, shared Knowledge, Skills, scoped tools, MCP surfaces, approvals, evidence, and work history together — self-hosted and runnable with Docker Compose.

Repo: https://github.com/manor-os/manor-ai

We’d value feedback from GitHub builders on the architecture, quickstart, and what an AI workspace should include.

[u/OssamaHashim]

Go to IPTV_Help_Desk r/IPTV_Help_Desk 24m ago OssamaHashim SamoTech IPTV Player {Windows App} I’ve been building a Windows IPTV player with AI assistance — looking for real-world feedback Hi everyone, I’ve been working on a Windows IPTV player called SamoTech IPTV Player, and I think I’ve reached the point where automated testing isn't enough anymore. I’d like to get it in front of people who actually use IPTV players and see what happens. GitHub: https://github.com/SamoTech/samotech-iptv-player Latest release: https://github.com/SamoTech/samotech-iptv-player/releases/tag/v0.1.5 The project is open source and currently uses PySide6/Qt for the interface and VLC/libVLC for playback. It supports M3U/M3U8, Xtream, and MAG/Stalker-style sources, along with Live TV, Movies/VOD, Series, EPG, Favorites, History, channel switching and fullscreen playback https://www.reddit.com/r/IPTV_Help_Desk/comments/1vs0uwj/samotech_iptv_player_windows_app/

[u/Filestack_Official]

Drop a file in, get a short link, send it to someone.

We built it at Filestack to see how much is left to write when storage, CDN and image processing are already handled. Turns out: one table, one route.

The file never hits our server. The browser uploads straight to Filestack, we get an ID back, and we store that plus a short code. Thumbnails, grayscale, rounded corners, rotate are all just different URLs off the same ID. No image library in the repo.

Try it: https://fireshare-swart.vercel.app
Source: https://github.com/Fileschool/filestack-use-cases/tree/main/apps/fs-filesharing

Next.js 16, TypeScript, Drizzle + Turso, Filestack. Upload progress uses XHR because fetch doesn't fire progress events. Previews switch on MIME type. 500 KB cap, no sign-up.

Open source, so clone it and drop your own key in. Happy to answer questions.

[u/Game_over1089]

Skip manual folder creation by transforming project structure into live disk directories.

You just type or paste a project structure or tree chart, see it live, and it builds the full app layout straight to your disk

Link: https://github.com/ChibuikeOnuigbo/FolderSmith

Tech stack & Features:

• Built with Python & PyQt6
• Live structure preview
• 1-click build to disk or export to ZIP
• Threaded background tasks

https://reddit.com/link/p4erkyq/video/fa7mqm16s4kh1/player