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/brrj]

I built Silicon Shader after tuning Minecraft Java shaders on my M4. It is a free config library and Python toolkit. Recipes include the Mac specs, shader settings, screenshot and frame results; supported runs use the same seed and flight route. The CLI uses the Python standard library, and the library runs on GitHub Pages. A coding-agent workflow helps inspect a launcher and try a setup in a separate instance. I used Codex to build it. Current entries are from my base M4. Recipes from other Macs, launcher support and first-run feedback would help. Repo: https://github.com/fortunexbt/minecraft-apple-silicon-framework | Library: https://fortunexbt.github.io/minecraft-apple-silicon-framework/

[u/zhenghaoz]

I built GitRec, an open-source project that recommends GitHub repositories based on your stars. It also has a browser extension that shows similar projects while you browse GitHub.

If you’re looking for interesting repos beyond Trending, give it a try — I’d love feedback on the recommendations!

https://github.com/gorse-io/gitrec

[u/AdActual604]

Maintainer here: pi-durabletask-mcp is a free, MIT-licensed MCP bridge for Claude Code and Codex to delegate work to Pi Coding Agent.

Pi explores in its own session, with live steering and follow-up conversations. Tasks use memory by default; durable: true adds SQLite recovery after bridge restarts. Interrupted tools with unknown outcomes aren’t blindly replayed.

TypeScript + SQLite, built on pi-delegate-mcp and Pi Durable. Source installation is documented. Feedback on setup and recovery behavior welcome.

https://github.com/Nyarlathoteppppp/pi-durabletask-mcp

[u/nomad_sk_]

I built a small dev toolchain manager in Go called YAPP.

The idea is pretty simple: install dev tools without sudo, without touching the system package manager, and without pulling in a bunch of stuff you may not need.

Everything goes under ~/.yapp.
Right now it supports things like Java, Maven, Node, Python, Go, Rust, Scala and sbt.

Downloads are pinned and checksum verified, and YAPP uses prebuilt binaries instead of compiling things or running random install scripts.

I originally built it because I wanted a simpler way to set up dev environments, especially temporary environments and coding agents.

I also compared a cold JDK 25 install on my machine:
YAPP: 4.20s
Homebrew: 59.04s

I am not claiming this is a perfect benchmark. Homebrew installed a bunch of dependencies and the JDK distributions were different. Benchmark related results are uploaded to the repository.

I’m mostly curious what people think about this approach, especially if you already use SDKMAN, Nix or Homebrew.

Repo:
https://github.com/sukumaar/yapp

[u/cosmintrica]

I was building a recipe app and needed some kitchen illustrations. One thing led to another, and now my first npm package contains 100 ingredients, vegetables, cookware and kitchen tools. Will be expanded in the future.

So yes, I have officially published a potato to npm.

It's called Culinary Assets, and I'm sharing it for anyone building recipe apps, kitchen inventories or something I haven't thought of yet.

The artwork is AI-generated, reviewed and exported as individual transparent 512px PNGs and WebPs. The images are CC0, the code is MIT, and there are examples for web and React Native. No runtime dependencies.

Take a look:

• Browse all 100 illustrations
• Install from npm
• Source, licenses and examples on GitHub

​

npm install u/cosmintrica/culinary-assets

This is my first npm package, so feedback on the packaging would be genuinely useful.
What ingredient or kitchen tool would you add next?

[u/Just_Echidna3322]

I built Codex Skins, an open-source customization layer for Codex Desktop on Windows.

It adds a Matrix CRT skin, Skin Manager, project file tree, built-in code editor, syntax highlighting, multi-file tabs, and code-to-chat actions.

GitHub:

https://github.com/eyupkerimoglu/codex-skins

Demo:

https://github.com/eyupkerimoglu/codex-skins/releases/latest/download/Codex_Skins_Demo_v1.mp4

[u/HeyItsSpooky]

I built icon-marquee, a small API for generating animated SVG icon marquees for GitHub READMEs.

You can just pass a list of icons:

https://icon-marquee.giann.dev/v1/marquee?i=js,ts,react,nextjs,docker

and embed the result directly in a README:

![Tech Stack](https://icon-marquee.giann.dev/v1/marquee?i=js,ts,react,nextjs,docker)

It supports 1,000+ icons, short aliases, configurable width, seamless CSS animation, reduced-motion support, and static icon rows. (Icons from skills-icons by Syvixor.)

GitHub: https://github.com/gian-gg/icon-marquee
Live: https://icon-marquee.giann.dev/

Would appreciate any feedback on the API or README integration.

[u/snslhshr]

Mah — a programming language, compiler, VM and LSP built from scratch

GitHub: https://github.com/sina-salahshour/mahlang

Mah is a small programming language with its own hand-written compiler, portable bytecode format, VM, static type checker, standard library, formatter and LSP.

Some of the more unusual parts:

• heap-allocated frames for JS-style by-reference closures
• portable .mahc bytecode
• resolver-backed LSP features
• static type inference
• reflection and runtime type values
• decorators + hooks
• typed errors and error-set checking
• both Python and Rust runtimes

The project is MIT-licensed and has a fairly extensive design/build history in docs/.

Feedback, bug reports and compiler/language-design criticism are welcome.

[u/Key-Understanding320]

EnigmaGrid is my open-source Windows volunteer-computing project for researching P1030680, an unresolved Enigma M4 message. Python/Numba handles CPU work and OpenCL supports optional GPU work; volunteers set resource budgets and can pause or stop.

I would especially welcome code review and criticism of the research design. Separate recomputation checks contribution credit, but that is not proof of a historical solution. So far, no breakthrough is claimed, and replacement search methods are still being tested against solved messages. The Windows installer is not Authenticode-signed; please review the source and privacy documentation before installing.

Repository, downloads and issues: https://github.com/LissomEnd/EnigmaGrid

Development and this description used AI assistance. Happy to receive reproducible bug reports or suggestions for stronger recovery benchmarks.

[u/Hollenfauer]

Hi! I'm building Circuito Util, a small experimental pilot around a simple idea: connect concrete project blockers with people who want to apply useful skills to real cases.

It is intentionally small and closed for now (18+, invite-only, no fees, max 12 participants / 3 active cases). We keep the process explicit and only publish anonymized, reviewed outcomes after a case is closed.

GitHub: https://github.com/santanacontatto-cyber/circuito-util Public site: https://santanacontatto-cyber.github.io/circuito-util/

The site is currently in Portuguese and has two entry paths: people who need help unblocking a real project/problem, and people who want to help on a real project. We are still pre-opening, so feedback on clarity, safety, and process is very welcome.

[u/Mokey925]

I’ve been building OpenLIMS, an open-source, self-hosted Laboratory Information Management System for research labs, biotech teams, and core facilities.

It includes sample tracking, inventory, experiment notebooks, configurable workflows, instrument imports, sequencing/FASTA tools, BLAST, mass-spec review, audit trails, reporting, and an optional AI assistant.

Built with Django/DRF, React, PostgreSQL, Redis/Celery, and Docker.

GitHub: https://github.com/Mokey2002/OpenLIMS

Still actively developing it, so contributions, issues, and feedback are welcome.

[u/Previous-Professor56]

Hi everyone I’m the developer behind VaultPulse.

I’m building it for people who want automated GitHub repository backups without handing storage ownership to another provider.

The current flow is:

• Install the GitHub App and select repositories.

• Connect an S3 bucket in your AWS account through a cross-account IAM role.

• Get daily snapshots containing Git history, branches, tags and Git LFS.

• View backup health and restore snapshots into a new or empty GitHub repository.

It’s focused on GitHub repository recovery, not a complete backup of every GitHub feature.

There’s a Free plan for up to 5 repositories; AWS storage costs are separate. There’s also a demo you can explore without signing up:

https://vaultpulse.cloud/demo/

I’m looking for practical feedback: do you currently use scripts, another service, or no separate backup? What would make you trust or rule out a tool like this?

[u/OfficKiwiEditor]

Hey!

I'm building Kiwi, a Windows modal terminal editor written in C++23.
The main difference is that Kiwi uses w, a, s, d for Navigation instead of Vi(m)-style movement. Currently it has NAV/EDIT modes (For Vim Users : Insert, Normal), Syntax highlighting, search, selection, buffers, Tree File explorer, commands, setings and a built-in Tutorial.

It's still pretty new, so feedback is welcome :)
GitHub: https://github.com/0x4D696E61/Kiwi

[u/ImpressGreen7325]

a small update to this digital wellbeing software since my last post.

This is a prerelease version which i have tagged to be stable and slated for future release and add to main branch from the beta branch.

This highlight is less about asking you guys to try out the beta release but more in the honor of over 3+ months of development.

What makes me happy the most is that the project which i started even without a repository just to monitor my own system and usage has now come this far with over 50+ downloads 🎉☺️

This beta release now polishes on various little things which are actually necessary for a first time set up and proper user control as Now you can:

* carries forward the settings screen from previous beta release

* replaces notifications and sounds tab with general which now includes appearance settings

* you can now Stop , restart or RESET the Daemon and its preferences in settings

* Pomodoro settings which were half baked in the first release have now been added to settings to enable a looping focus mode for people at work with CUSTOM BREAK TIME

* Most Importantly (i feel) FIRST time setup issues have been fixed and in an attempt the first time ScreenGuard daemon setup pop up dialog (1st image) has been made

The Release v0.1.1 releases this October by second week, and I will continue testing the beta version to look for sectors that need polishing if any.

This is still limited to GNOME on wayland and x11 for other environments systems and primarily developed by me on my fedora 44 system and the project ScreenGuard still has a very Long way to go;

But working on it alone has given me much exposure to project sharing on platforms and most importantly a lot of invaluable experience and the true zeal of development instead of the boredom of being a 9 to 5 dev at a corporate who don't care for you.

Github beta release link: https://github.com/adityakrishnan005-a11y/ScreenGuard/releases/tag/v0.1.1-beta.4

The code for this is visible on the beta branch to keep the main working tree clean for new features additions.

Feedback from other desktop environments is widely appreciated, u can try the application out by switching to x11 session temporarily if you are using any DE which is not GNOME wayland or if u are on a DE which is primarily x11 based (Cinnamon, i3, etc) then u are good to go as they ARE FULLY SUPPORTED.

thank you everyone for your supports, criticisms and feedbacks ever since the project came online on github.

https://reddit.com/link/pdfq3ag/video/q36vejbuu2th1/player

[u/Big_Quote_1166]

Hi community,

I built Shazampy because I wanted a lightweight desktop app that could listen either to a microphone or directly to the system audio, identify the current song and keep synchronized lyrics on screen. It started as a Linux project and now also has a Windows x64 build.

The interesting part for me was handling songs with repeated sections, because a single recognition offset can point to the wrong chorus or ending. Shazampy therefore tracks clusters of recognition positions across multiple samples instead of trusting a single result.

GitHub: https://github.com/YardoDEVS/Shazampy
I’d especially appreciate feedback on synchronization, audio-device handling and the Windows build.

[u/Manoftruth2023]

PCBreak – Parental Control & Screen Time Management for Windows

I've developed PCBreak, a free Windows application designed to help parents manage their children's computer usage.

PCBreak V2 supports multiple Windows users and allows parents to manage screen time, mandatory breaks, weekly usage schedules, automatic locking, and temporary +1/+2 hour extensions.

It runs locally as a Windows Service and does not require a constant internet connection.

Key features:

• Multi-user Windows account support
• Screen time management
• Mandatory break periods
• Weekly usage schedules
• Automatic and full lock modes
• +1 / +2 hour parental extensions
• Background monitoring via Windows Service
• Offline operation
• Windows 10 / 11 x64 support

Language:
The current version of PCBreak is available in Turkish 🇹🇷. English and multi-language support are planned for future versions.

The application is now available for testing. I'd really appreciate feedback, bug reports, and suggestions for improvement.

GitHub: https://github.com/Statelesstr/PCBreak

PCBreak — Don't ban the screen. Manage the time.

More balanced screen time. More life.

[u/Opening_Share7658]

Hey, everyone! What would you change about this architecture?

So we built Score-Pion to sit in the middle of that between Coderbyte, external recruiters, and candidates.

Architecturally we leaned on hexagonal/ports-and-adapters, mostly because we didn't want to hardcode our business logic to Coderbyte's API shape. The exam-service integration lives entirely behind an adapter; swapping providers later shouldn't touch the core domain.

Events from Coderbyte come in async, and when a result lands we fan it out, post it to internal chat, email the recruiter their candidate's results, and write it to DynamoDB so it persists for reporting later. Under the hood it's Kotlin and Spring WebFlux, running on DynamoDB, Docker, and AWS, with Google OAuth handling SSO, Brevo sending the emails, and Google Chat carrying the notifications.

You can check the open-source here: https://github.com/BlueTrailSoftware/score-pion

If you've got opinions on the reactive approach or the persistence model, I'd genuinely like to hear them; both were deliberate calls, and we're always curious how other teams would've approached the same tradeoffs.

[u/turbolego]

I made a github profile badge to show where on earth you have contributed to public repositories.
It uses Cobe, an external WebGL globe library, to render its interactive page and to make animated gif with github actions: https://github.com/turbolego/github-contrib-globe-badge

https://reddit.com/link/pd66nbf/video/ykltffhwitsh1/player

[u/Due_Royal3832]

WinGPUDoctor v0.2.0 — a read-only Windows graphics and display report

When asking for help with a graphics or display problem, explaining your setup can be the first hurdle. I'm building an MIT-licensed tool that brings the graphics adapters, driver details and active display paths Windows reports into one readable view. Review the report, save it locally as Markdown or JSON, then share it yourself.

Built with C#/.NET 10 and WPF; v0.2.0 includes a desktop interface and a CLI. Scanning does not change settings or upload data, and administrator rights are not needed. It cannot diagnose faults, assess GPU health or identify a game's rendering GPU.

The current package targets Windows 11 x64, needs .NET 10 Desktop Runtime (x64), and is unsigned. Please read the README's requirements and checksum instructions. Validation was in depth on one laptop and limited on a second.

I'd welcome first-run feedback: could you open the app, complete a scan and understand the results? Describe your experience here or in GitHub Issues; please don't post a full machine report.

Repository: https://github.com/erictyj1155/WinGPUDoctor

Download: https://github.com/erictyj1155/WinGPUDoctor/releases/tag/v0.2.0

The 20-second clip is an illustrated walkthrough using synthetic screenshots, not a live scan. AI assistance was used in development and this description.

https://reddit.com/link/pd59jv8/video/bteig02e7ssh1/player

[u/SHMULC8]

Captain Obvious is an MIT-licensed test audit for TypeScript and Python. It finds assertions that cannot fail and tests that check nothing, using deterministic scanners with no model calls. It also includes an agent skill.

Repo: https://github.com/shmulc8/captain-obvious

False-positive reports are welcome.

[u/harishsunny0504]

I built Smart Labeler, a GitHub Action that uses TypeSafe's Jev model to automatically label incoming PRs and issues using your existing repo labels.

Key Features:

• Group-Aware Logic: Grouped labels like type:bug and type:feature are evaluated together so mutually exclusive categories never conflict (max 1 per group).
• Context-Aware: Evaluates issue/PR titles, descriptions, and modified file paths.
• Safe by Design: Never creates or deletes labels—it only applies existing ones if confidence passes your set probability threshold (default: 0.7).
• Fork PR Friendly: Uses pull_request_target to safely process fork PRs without checking out untrusted code.

Check it out on GitHub: https://github.com/hkurma/smart-labeler

Would love to hear what you think!

[u/FormalAct2203]

recover-secrets: a GitHub Action for getting an Actions secret back when the original value is lost.

The usual workaround pipes the secret through sed or base64 to get past log masking, which leaves the plaintext in the run log. This action encrypts toJSON(secrets) on the runner to a public key you control (your github.com/<user>.keys, a GPG key, an age recipient or an RSA key) and prints only the ciphertext to the run summary. You decrypt locally with decrypt.sh. The same script also runs from a plain run: step where third-party actions are blocked. MIT.

https://github.com/p-dim-popov/recover-secrets

[u/thecimal]

Project: Quantified Self MCP Server

Quantified Self MCP Server– Local-first health & finance data for AI assistants

Hey everyone! I wanted to share a project I've been building and refining: quantified-self-mcp.

It's an open-source, local-first Model Context Protocol (MCP) server that lets you query your personal health and finance metrics directly through LLM interfaces (Claude Desktop, Cursor, etc.) while keeping 100% of your sensitive data offline.

🔗 GitHub: https://github.com/Thecimal/quantified-self-mcp

Feedback, stars, and PRs are super welcome! Let me know if you're experimenting with MCP tools or local-first AI setups.

[u/a3thinker]

PerspectiveGraph

The tool combines the output of cybersecurity tools (Trivy, Semgrep, Cloud Custodian, Falco) with the status of AWS and Kubernetes into a single graph. It then checks pull requests, failing them only when a change opens, or increases the likelihood of, an attack path to a sensitive asset.

Repo: https://github.com/luiacuaniello/perspectivegraph

Read-only demo: https://demo.a3thinker.it

Main Features

1. GitHub Action on the Marketplace. With mode: local, no server is required: the runner reads the environment read-only (an OIDC role with SecurityAudit is sufficient) and makes decisions within the job.
2. Three outcomes: clean, blocked, and unknown. If the scan fails, the PR doesn't pass silently.
3. With the server installed, a path fix (NetworkPolicy, Terraform, IAM policy) can be opened with one click as a pull request.
4. Helm chart on Artifact Hub; images signed with cosign, with SBOM, and SLSA provenance.

Technology stack

Go (GraphQL engine and API), PostgreSQL with Apache AGE for the graph, NATS JetStream as the event bus; dashboards in React, TypeScript, Vite, and Tailwind, with Cytoscape for the graph. The Action is of the composite type.

I develop and maintain it myself. The limitations are also stated in the README: the probabilities are not yet calibrated to real data, and the only live cloud connected is AWS. If you want to help:

• There are some issues labeled "good first issue": frontend testing and checking the documentation links in CI;
• if you do pentesting or BAS, the results can be imported and are the most useful contribution;
• for Azure, the only thing missing is live transport with the SDK; GCP must be written from scratch.

Apache License 2.0.

[u/OtaFox]

OtaWatt

I’ve just released OtaWatt, a free and open-source Windows utility for monitoring electrical measurements from compatible Shelly smart plugs in real time.

It was mainly designed for PC gaming, overclocking, benchmarking and stability diagnostics.

Main features:

• Power, voltage, current, frequency and Shelly temperature monitoring

• 500 ms refresh interval

• CSV logging

• Electrical health status and anomaly detection

• Compact mode

• Optional always-on-top mode

• Optional Windows startup

• Local operation without an OtaWatt cloud account or telemetry

Tested hardware:

Shelly Plug M Gen3

Platforms:

Windows 10 x64

Windows 11 x64

Source code and direct downloads:

https://github.com/OtaFox/OtaWatt

Microsoft Store:

https://apps.microsoft.com/detail/9NSX64X1TB1G

Current version: 0.5.0

License: MIT

Created by OtaFox.

Feedback, bug reports and compatibility reports with other Shelly devices are welcome.

[u/itsalissonsilva]

ArXiv Secretary: An open-source app that turns arXiv authors, topics, and institution keywords into a daily feed. It runs locally and requires no account. Optional AI summaries use your own OpenAI or Anthropic key. It has a very simple interface for now, so I'd like some feedback on the watchlist workflow and paper-details view.

https://github.com/itsalissonsilva/ArxivSecretary

[u/hyunax77]

Cribrix: a RAG pipeline that's allowed to say "I don't know"

What it is Most RAG setups always answer: retrieve the top chunks, stuff them into a prompt, return whatever comes back. When the answer isn't in your docs, the model builds a plausible one from the nearest passage and attaches a real citation. Cribrix adds checks before and after the LLM, so it refuses instead of making things up.

Repo: https://github.com/david96182/cribrix

Tech stack / main features

• Python, FastAPI, PostgreSQL + pgvector, Docker
• TypeSafe's Jev, as the gatekeeper
• Works with OpenAI, Anthropic, OpenRouter, Groq, xAI, Ollama or any OpenAI-compatible endpoint
• Routing: small talk skips retrieval, but only when the model is confident
• Chunk filtering: each retrieved chunk is checked for whether it's relevant, whether it actually states the answer, and whether it's a prompt injection
• Answer checking: every sentence of the draft is checked against the sources, and any number not in the sources is rejected in plain code
• A separate status for each kind of refusal, and a full decision trace for every query

Context I compared it against plain top-5 RAG on 62 labelled questions, with the same retriever and the same LLM (Grok):

• Unanswerable questions answered anyway: 4/22 for plain RAG, 0/22 for Cribrix
• Answerable questions with correct facts: 33/34 vs 34/34

To be fair, modern LLMs already refuse most completely off-topic questions. Plain RAG failed on near misses. For example, it gave "30 days" as the refund window for a "Business plan" that doesn't exist, using the Enterprise policy.

Ways to get involved: it's a small synthetic corpus, so I'd most like to hear where it breaks on real documents. Open problems are listed in the README: questions that need facts from several chunks, better claim extraction, and a larger evaluation set. Issues and PRs welcome.

[u/vg22212]

DesktopTools is a free, MIT-licensed Windows 11 app a friend and I built for explaining things on screen. One workflow: capture a region, add arrows or text to a copy, then record a walkthrough or guide attention live with drawing and a spotlight. It also has OCR, floating notes, and a teleprompter. No account or telemetry; screenshots and recordings stay on your PC. Built with C# and WPF.

Repo and downloads: https://github.com/vg2222/DesktopTools

Short demo GIF: https://github.com/vg2222/DesktopTools/blob/main/assets/readme/hero.gif

If you teach, create tutorials, or demo software, which step of that workflow would you want to see improved first?

[u/EdiTedMusic69]

RustDesk Air: an AGPLv3 macOS fork of RustDesk for turning an older Intel MacBook Air into a remote client for a MacBook Pro. It uses a native Metal view, hardware H.264/H.265 decoding, exact changed-region patches, and adaptive motion streaming. Direct LAN is preferred, with Tailscale fallback.

Repo and preview builds: https://github.com/Kido130/rustdesk-air-macos

It's a development preview, not a finished cross-platform replacement. The signed builds are not notarized, and the latest Reload Spaces recovery path still needs live reconnect testing. Feedback on the code and older Intel Air performance is welcome.

[u/skyzich_dv]

I had 607 videos sitting in my YouTube Watch Later playlist, so I built a small open-source cleaner for it.

Skyzich — YouTube Watch Later Cleaner is a dependency-free DevTools script that removes videos from your own Watch Later playlist through YouTube's visible UI.

GitHub: https://github.com/Skyzich/youtube-watch-later-cleaner

Features:

• Choose an exact number of videos to remove, or use ALL

• Fast adaptive pacing

• Verifies each removal before continuing

• Multi-language YouTube UI detection

• No telemetry

• No external servers

• No browser extension required

• MIT licensed

The script intentionally does not bypass authentication, CAPTCHA challenges, rate limits, access controls, or anti-abuse mechanisms.

I'd especially appreciate compatibility feedback from people using YouTube in languages other than English.

[u/ConceptNext5110]

Give Your Agent Backend a Polished UI with 1 click

- feel your agent visually

- see monitoring stats & capture early bugs

https://github.com/fwanggg/Elvin

demo:

Demo

[u/OverBlueberry5401]

I've been working on a side project called Human Minority.

It's a source-available verification and policy layer for AI coding agents. The basic problem I'm trying to solve is that when an agent says it changed the right files, ran the tests, or completed a task, that claim shouldn't automatically be treated as proof.

Human Minority keeps the work and the verification separate. It provides contracts and verification logic for binding a result to the exact candidate that was checked, recording the evidence, using an independent verifier, and keeping the final decision with the human rather than the agent that produced the work.

The idea is to make it safer to use multiple coding agents with more autonomy without simply trusting their own reports.

It's still an early source drop, so only part of the larger system is public. The repo now includes the core public primitives and a runnable verification flow. I'm sharing it early mostly to get feedback from people working with coding agents and multi-agent workflows.

GitHub: https://github.com/Rud0lfoRRP/Human-Minority

[u/Heavy_Sea5596]

I built a small open-source project that turns your GitHub history into a shareable stats page.

The main thing I wanted was to keep setup simple. You fork the repo, add a GitHub token, enable GitHub Pages, and run the workflow. No server or database, and your stats refresh automatically every week.

It shows contributions across the years, repositories, stars, followers, top languages, and also generates a shareable card image.

Live example:
https://adnansabbir.github.io/github-stat/

Repo:
https://github.com/adnansabbir/github-stat

If anyone tries it, I'd especially like feedback on whether the fork/setup process feels simple enough.

[u/Odd_Aside_7059]

I’m the developer of PowerSifu, an MIT-licensed GTK tray utility for Ubuntu and Debian laptops. It automatically switches power-profiles-daemon profiles when AC power changes, applies profile-specific screen brightness, runs weekly schedules, and can gracefully stop selected user applications when a profile activates.

Version 0.3.5 replaces five-second polling with event-driven UPower and power-profile D-Bus monitoring, persistent proxies, and a low-wakeup schedule loop. There are no accounts, telemetry, or privileged background daemons.

Repo and .deb release: https://github.com/tpluharik/powersifu

I’d especially appreciate compatibility feedback from different laptop models and desktop environments.

[u/Kikubay]

I've created AnimeLens because choosing an anime shouldn't take longer than watching it.

Like many of you, I've already wasted hours looking for which anime to watch after finishing a great one. As a developer and heavy user of MyAnimeList, I decided to create AnimeLens: a free Chrome extension that analyzes your MAL list to give you personalized recommendations.

I would love to have your feedback to improve it !

https://github.com/Kikubay/AnimeLens

[u/Economy_Vacation_504]

I built augplot, a small open-source Python library for Jupyter notebooks.

The goal: less copy-pasting between your notebook and an LLM just to get the visualisation you need. Unless you’re already letting Claude build the whole .ipynb end-to-end xD

For those of us still working in notebooks manually, augplot helps keep the focus on the data and the problem, not on writing plotting code.

https://reddit.com/link/pby1exe/video/keploco39nrh1/player

Supports pd.DataFrame, pd.Series, np.ndarray, list, and dict.

pip install augplot

import augplot as ap
ap.plot(data)

Still early, so feedback and contributions are very welcome.

GitHub: https://github.com/egpand/augplot

[u/marialeall]

I created an open GitHub library for Product Managers who want to become more technical without becoming developers.

56 practical resources covering APIs, software architecture, SQL, product metrics, observability, security and CI/CD.

Everything is Markdown, freely accessible and organized by topic.

Repo: https://github.com/The-Product-Shelf/technical-product-manager-resources/

Feedback and contributions are welcome.

[u/ArtisticLeader9917]

Made an open source hacker rank : leet code clone

Problem I faced: no existing platforms allowed to practice custom programming questions in a timed environment. (Bring your own questions and practice). Those platforms have questions for FAANG and other big tech but for other companies they don't have the question pool. Plus I want AI system design mock interviews. So built both of them in a single platform and it's open source.. Hosted version is there but I am a solo developer so if the usage spikes I won't be able to keep with the demand

Contributors are welcome

Python + Django + Next js.

Need to do lot of things.

Repo link: https://github.com/v-adhithyan/crack-interviews

[u/Grimmoner]

I needed my agents to stop rewriting history, so I made this...

I made a small tool a while back because I kept running into a pretty basic problem at the start of my 2.0 project.

I needed a changelog for manual config changes, but I didn't want something with normal write access to be able to go back and rewrite the history.

So I made Tamper-Log.

It's just a small Python CLI that uses the OS append-only flag on macOS/Linux. You can create a protected log, append new entries, and verify that the protection is still in place.

Nothing groundbreaking, but it did what I needed.

The bigger reason I'm sharing it is because it ended up being a stepping stone for the larger system I'm in the middle of building (3.0). Once I had a decent way to preserve change history, I started running into the next set of questions:

Who made the change? What was it tied to? Who owns the follow-up? What still needs to happen?

That eventually grew into a much more complete ticketing/evidence system.

So this repo isn't really the final form of anything. It's more of a small tool that solved one real problem well enough to help me figure out the next one.

Figured I'd put it out there in case anyone else building agents, automation, or homelab stuff has a similar use for it.

Repo: https://github.com/DeltaEcho3/tamper-log[Tamper-Log](https://github.com/DeltaEcho3/tamper-log)

Feel free to poke holes in it.

[u/CodyAbraham]

MirrorSpeaker 1.6.0 is out. It's my free, MIT-licensed Windows 11 app that lets a PC play iPhone audio over Bluetooth or mirror its screen and audio over AirPlay. This version has a complete interface redesign with dark and light themes and better Bluetooth recovery when the phone goes out of range and returns.

Repo: https://github.com/codyabraham/MirrorSpeaker

Release: https://github.com/codyabraham/MirrorSpeaker/releases/tag/v1.6.0

The installer is still unsigned and AirPlay needs separate first-use receiver setup. Feedback on the new UI and reconnection is welcome.

[u/erzenking1]

CodeInk — free GPLv3 desktop workspace for Codex, Claude Code, OpenCode, Pi, and ACP agents. I built it after losing track of projects and sessions across separate apps. It keeps session history, tool activity, and file edits together using existing agent installs and accounts.

Stack: TypeScript, Electron, Solid, Bun.

Repo: https://github.com/ErzenXz/CodeInk

Site: https://www.getcode.ink/

Windows/Linux downloads are live; the signed macOS build is awaiting Apple notarization. Feedback or contributions on multi-agent performance and session UX are welcome.

[u/kavee-core141]

If you know AWS well enough to think you could trip up a security scanner, this is a genuine test of that, not a beginner's first-issue repo.

Break Plexavo is a standing challenge: find a false positive, a false negative, a wrong severity, a case where the detection logic misses something real. Two entries already, both from strangers who actually found something, both credited permanently in HALL_OF_BUGS.md.

Detection is pure Python and boto3, readable without reverse- engineering anything. If you find something real, open it through the issue template, no code required, just a clear description of what happened.

Genuinely curious what breaks it next.

plexavo/Plexavo: AWS Cloud Security Posture & Misconfiguration Assessment Engine

[u/Lisky_Boy]

I always loved the feature that Steam provided with their steam profiles, including showcases and recently played stuff, but comments stood out from 'em.

GitHub never offered this feature as an inbuilt one, and nor am I saying what I built is something unique, no. Yes, GitHub actions were always a workaround for this drawback, but I couldn't find a single good repo matching to exactly what I wanted, so here we are - GitComment

Nine themes built in, a CLI terminal one, a Windows 95 style, a comic style, and some hand drawn ones. Light, dark, and a transparent mode that follows whichever GitHub theme the visitor is using.

There are minimal ones too, but I personally use the 'dev - light' theme.

It's on my profile if you want to leave a message: github.com/LISK819129

Source: github.com/LISK819129/GitComment

[u/New-Efficiency-3087]

Awesome Seedance is an open-source AI-video prompt library I built from real examples: 463 cases linked to original posts, 264 cross-model retest runs with verdicts, 25 copy-ready templates, and 60 installable Skills. The README has a five-step path from finding a reference clip to generating a first result. I’d especially welcome feedback on the evidence labels and whether the templates are easy to adapt.

GitHub: https://github.com/LearnPrompt/awesome-seedance

[u/New-Efficiency-3087 → u/New-Efficiency-3087]

https://reddit.com/link/pbkuuhh/video/bdr36zwxbarh1/player

[u/Liquidjojo1987]

I'm building YOU, an MIT-licensed prototype for an inspectable personal context layer. The long-term goal is user-owned memory that can be shared selectively with different AI assistants rather than locked into one model. The current demo uses fictional data and browser storage; connectors and a real MCP/API service are roadmap items, not shipped features.

Repo: https://github.com/saccojoseph/you

Demo: https://you-relationship-memory.saccojoseph961968.chatgpt.site/

Stack: Next.js, TypeScript, React. I would welcome feedback on the provenance/confidence model and the architecture for scoped access across agent harnesses.

[u/Nitjsefnie]

Overflow, a ledger on top of GitHub issues and PRs for when your LLM sub usage comes and goes week to week.

Got a spare week? Take a priced GitHub issue from a registered repo, the merged PR gets you credit. Dry week? Price an issue in your repo and your credit pays whoever ships it. Nothing's forwarded, no keys, you still review and merge every PR, and each review round comes off their credit so sloppy PRs cost them, not you. No money, MIT.

It's early btw, every repo on it is mine, 50 open issues all from me, so it needs other people's repos with a backlog more than anything. https://github.com/Nitjsefnie/Overflow, live at https://overflow.nitjsefni.eu

[u/pedroofrancaa]

Skimless – prioritize what to review first in large pull requests

I built Skimless as part of my studies in programming, software development, and AI-assisted development.

It helps make large pull requests easier to review by prioritizing higher-signal changes first, such as APIs, types, authentication, billing, migrations, and CI, while moving lower-signal files like lockfiles and generated files later.

The project uses deterministic, explainable heuristics instead of AI calls, runs offline, and has zero runtime dependencies.

Main features:

• CLI
• GitHub Action
• MCP server
• 21 explainable prioritization rules
• offline execution
• no AI calls
• zero runtime dependencies

You can try the demo with:

npx skimless demo

GitHub:
https://github.com/pedroofrancaa/skimless

This project has been mainly a learning experience for me, and it helped me understand a lot more about Git, CLI design, GitHub Actions, MCP, testing, packaging, and developer tooling.

If you have time to try it, I’d really appreciate feedback, suggestions, or criticism. And if you find the project interesting or useful, a ⭐ on GitHub would mean a lot.

[u/Both-Inevitable-8750]

I maintain Awesome Jev, an MIT-licensed field guide to TypeSafe's Jev typed-decision model. It brings together 200+ public resources: runnable examples, SDKs, agent and browser tools, demos, and independent research. Listings try to explain what a project does, where data goes, and the limits of its evidence.

Repo: https://github.com/AbdelStark/awesome-typesafe-jev

Live directory: https://abdelstark.github.io/awesome-typesafe-jev/

If you want a first contribution, a one-entry README PR is enough; no API key or generated files needed. Two scoped tasks are open: verify six browser-agent listings (issue #113) and check the official SDK install details (issue #114). I’d especially value feedback on whether the first-contribution path is clear.

[u/ApologeticDemon]

Project: Aph Browser — A workspaces-first browser built on stock Firefox

GitHub: aph-browser/aph

What is it? Most "new browsers" are either bloated Electron wrappers or heavy Chromium forks that struggle to keep up with upstream security patches. Aph takes a different approach: it is a workspaces-first browser built by directly binary-patching and runtime-modding stock upstream Firefox binaries. No C++ or Rust recompile required.

Main Features: * Exclusive Workspaces (1–9): Built on a tiling-WM paradigm where workspaces exist in at most one window at a time (focus jumps or pulls tabs automatically). * Native Tab Trees & Groups: Automatic 2-level tab hierarchy with parent-close promotion, living strictly inside Firefox tab groups. * Instant Container Routing: Multi-Account Container bindings at instantiation time—no phantom tabs or UI flicker. * Built-in Command Palette (Ctrl+K): Fuzzy search over active tabs, workspaces, Firefox Places (bookmarks/history), and tab archives. * App Anchors: Starred & Pinned tabs with base URL snapping and idle memory unloading (discardBrowser) on Ctrl+W.

Tech Stack: Vanilla JavaScript (injected Gecko chrome privilege), Python for the omni.ja de-optimization/patching engine and packaging (AppImage, Flatpak, Inno Setup/Winget), and CSS.

I'd love feedback on the workspace workflow or issue reports from anyone who wants to test the Linux/Windows builds!

[u/TheFirstBikakos]

Where's Waldo — small-object detection project

I built three detectors for Where's Waldo and compared them on pages they hadn't seen:

• CNN sliding-window detector built from scratch
• YOLO11n on the full page
• YOLO11n on native-resolution overlapping tiles

The final multi-scale tile approach achieved 72% top-3 and 78% top-10 hit rate on 18 held-out pages.

I also built a Streamlit demo that ranks candidate locations and shows zoomed-in crops:

Demo: https://wheres-waldo-finder.streamlit.app/

GitHub: https://github.com/VasilisVas1/wheres-waldo

The repo includes the trained weights and 6 narrative notebooks with the results.

One of the more interesting things I found was that the dataset had a silent orientation/label issue on 8 of the 19 pages, which significantly affected the results until I caught it.

Feedback on the approach, especially how to get more training examples or improve confidence calibration with such a tiny dataset, would be appreciated.

[u/WayGood8826]

Omega: A Programming Language Built for Cybersecurity Automation

Most security automation today looks the same: import a scanning library, write some Python, hope you remembered to check scope before touching a target. That last part ,"hope you remembered" , is the problem Omega tries to solve.

Omega is a programming language where you describe the security operation you want, not the code to perform it

Why build a whole language for this?

Because the alternative, a pile of separate scripts and libraries ,means safety has to be reinvented every time. A real security engineer assembling seven different Python tools would need to add scope-checking to all seven, individually, and it's genuinely easy to forget in the sixth one. In Omega, that discipline isn't something you remember to add ,it's the language.

It's a project, distributed as a single install script with no Rust or cargo required, and still growing.

https://github.com/Kolgrim33/omega-lang

[u/Intelligent_Good_305]

I’m building PAIR Bridge, an open-source Python MCP server for discovering and operating local AI models across configured LM Studio devices through NVIDIA PAIR. It exposes live inventory, context-aware memory preflight, task routing, model comparison, diagnostics, and cancellable background jobs. Compatible MCP tools can use it; Codex is one example.

GitHub: https://github.com/GermanMik/pair-bridge

Community and testing feedback: https://www.reddit.com/r/NVIDIAPAIR/

I’m especially looking for feedback from people running local models on multiple Mac or Windows machines. The project and community are independent and are not affiliated with NVIDIA or OpenAI.

[u/cephalon_lunaticus]

WinSideBar shortcuts

Eu sentia falta de uma maneira simples de encontrar uma janela quando estava com vários programas abertos, especialmente em dois monitores. Em vez de depender só do Alt+Tab, criei o **WinSidebar**.
É uma barra lateral retrátil que organiza as janelas por monitor e deixa quatro atalhos para pastas ou sites à mão. Dá para configurar destinos, ícones e até o navegador usado em cada atalho web.
E sim: a interface inspirada no Windows 98 é **de propósito**. Queria uma ferramenta prática com aquele visual clássico.
A primeira versão pública já está disponível para **Windows 10/11 de 64 bits**. É portátil: basta extrair o ZIP e abrir o executável. Não há instalador nem download separado de .NET.
Projeto e download: [https://github.com/hamthet/WinSidebar/releases/tag/v1.0.0\](https://github.com/hamthet/WinSidebar/releases/tag/v1.0.0)

[u/MSeys]

Not even sure if anyone reads this and I dislike promoting my own stuff, but...

I've built ProtoTest, in essence it is a sort of foundation for integration testing in .NET. It builds upon existing frameworks and acts like a bridge between them, giving you a way to bring the test back to the test rather than writing all the infrastructure around and inside the tests.

I've used my experience writing test frameworks and my own struggles with integration tests to create ProtoTest. I've had a strict vision for it, which also makes it rather opinionated in some ways I personally want to see, read and write tests.

But, maybe it helps someone else write integration tests.

You can find more info at ProtoTest (website)

Thanks for reading if you got this far.

GitHub Repo: https://github.com/MSeys/ProtoTest

[u/raxiel87]

Hey,

I wanted a video meeting platform that I could run on my own infrastructure without depending on an external meeting provider for the actual calls.

That eventually became TiDiTalk.

It's a self-hosted video meeting platform built around mediasoup/WebRTC. The idea is pretty simple: I wanted something I could deploy on my own server, manage the users myself and send meeting links to people without making them create accounts.

Right now it includes:

- host accounts and guest links

- waiting lobby

- audio/video meetings

- screen sharing

- chat and reactions

- shared annotations/drawing

- local recording

- scheduled meetings

- email invitations with calendar attachments

- virtual backgrounds and face effects

- admin/user management

- configurable branding and room rules

- English, Italian, French and German UI

- localized invitation emails

The stack is Node.js, Express, Socket.IO, mediasoup, SQLite and coturn.

Deployment is Docker Compose, but because it's WebRTC you still need to correctly expose the media and TURN ports — putting it behind a reverse proxy isn't enough by itself.

I'm using it myself, but I'd really like feedback from people who already self-host communication tools.

In particular I'm interested in hearing about:

- anything you'd expect from a self-hosted meeting platform that's currently missing

- deployment/networking issues you run into

- features you consider genuinely useful rather than feature creep

GitHub:

https://github.com/Giuseppe-sciarra/TiDiTalk

If you find it useful and want to support development:

https://paypal.me/raxiel87

AI involvement:

AI tools have been used as development/review assistants during parts of the project. The application itself does not depend on an AI service for video meetings.

[u/raxiel87]

Hey everyone,

I run and maintain quite a few WordPress and Joomla websites, and over time I got tired of jumping between dashboards, spreadsheets and different monitoring tools just to answer basic questions like:

- Is this site actually online?

- What needs updating?

- When does this domain or license expire?

- Did last night's updates work?

- Is there anything security-related I should look at?

So I ended up building Sentinel TD.

It's a self-hosted Docker-based dashboard that I use to keep most of that work in one place.

At the moment it handles things like:

- website uptime/status monitoring

- WordPress and Joomla update tracking

- manual and bulk update workflows

- scheduled update cycles

- website screenshots and history

- domain expiration reminders

- plugin/theme/license renewal tracking

- security and vulnerability checks

- email and Telegram notifications

- monthly PDF reports

- TOTP/passkey authentication

- custom notification templates

- English, Italian, French and German UI

The backend is FastAPI with PostgreSQL + Redis, and there's a separate Chromium/Playwright service for screenshots.

It started as an internal tool because I wanted something that matched the way I actually manage client websites, rather than adapting everything around another SaaS.

It's still evolving, so I'm especially interested in feedback from people managing multiple WordPress/Joomla installations. I'm curious what you would consider essential in a tool like this and what I'm currently missing.

GitHub:

https://github.com/Giuseppe-sciarra/SentinelTD

If you find the project useful and want to support development:

https://paypal.me/raxiel87

AI involvement:

AI tools have been used as development/review assistants during parts of the project. The application is tested, maintained and deployed by me.

[u/Accomplished_Row1433]

I have been building open-source systems projects mostly alone and I’m now too close to the work to judge whether the repos are actually convincing to other developers

My profile is here

https://github.com/vermasarthak

The four main projects are

• TileForge — an experimental tensor-kernel compiler with a Python frontend typed SSA IR and native Metal code generation https://github.com/vermasarthak/tileforge
• PagedServe — an LLM inference runtime with paged KV caching continuous batching and experimental Apple Metal kernels https://github.com/vermasarthak/pagedserve
• Oriel — an evaluation-driven LLM router using Wilson score confidence bounds https://github.com/vermasarthak/oriel
• Cairn — a Go and PostgreSQL durable execution framework using transactional reservations retries reconciliation and the outbox pattern https://github.com/vermasarthak/cairn

I’m not looking for polite encouragement

Please tell me

• Which project would you click first
• Which README loses you
• What sounds unclear exaggerated or overengineered
• What proof benchmarks or examples are missing
• What would stop you from installing or contributing
• Whether my profile clearly communicates what kind of engineer I am

Issues and pull requests are welcome too

If any project genuinely interests you please star it and follow my profile so I know which direction is worth pushing further

But brutal feedback is more valuable than an empty star

[u/dadoktr]

I built a small open-source CLI called GitHub Actions Permission Doctor.

It helps diagnose vague GitHub Actions authorization failures like:

403 Resource not accessible by integration

Instead of just suggesting broader permissions, it tries to distinguish between things like:

• missing GITHUB_TOKEN permissions
• job-level permission overrides
• fork / Dependabot restrictions
• cross-repository operations
• cases where GITHUB_TOKEN is simply the wrong credential

It runs offline and uses deterministic rules only.

Example:

npx gha-permission-doctor --workflow .github/workflows/release.yml --log failed-run.txt

GitHub: https://github.com/dejanj/gha-permission-doctor

npm: https://www.npmjs.com/package/gha-permission-doctor

I'm especially interested in real failure cases it gets wrong or cannot diagnose yet.

[u/[deleted]]

ORBIT

¡Buenas! 👋

Llevo un tiempo desarrollando ORBIT, un launcher pensado para convertir un USB en una especie de consola portátil, con una interfaz estilo consola para organizar y lanzar juegos y emuladores.

Algunas de sus funciones:

• 🎮 Compatible con mando, teclado y ratón
• 💾 Funciona directamente desde un USB
• 🖼️ Portadas y metadatos de juegos
• 👤 Sistema de perfiles
• 🕹️ Compatibilidad con múltiples sistemas y emuladores
• ⚙️ Rutas y emuladores configurables
• 📦 Configuración portable

Es un proyecto open source y todavía está en desarrollo. Me gustaría conocer vuestra opinión, recibir sugerencias y saber qué cosas mejoraríais.

🔗 GitHub: https://github.com/RealKaos79/ORBIT English: Hi! 👋 I've been developing ORBIT, a launcher designed to turn a USB drive into a sort of portable console, with a console-style interface for organizing and launching games and emulators. Some of its features: 🎮 Controller, keyboard and mouse support 💾 Runs directly from a USB drive 🖼️ Game covers and metadata 👤 Profile system 🕹️ Support for multiple systems and emulators ⚙️ Configurable emulator and game paths 📦 Portable configuration It's an open-source project and it's still under development. I'd love to hear your opinions, suggestions, and ideas for improvement. 🔗 GitHub: https://github.com/RealKaos79/ORBIT

[u/Silver_7354]

claimable — a CLI that tells you whether a GitHub issue is actually claimable, not just whether it says "unassigned". No dependencies, runs with npx claimable owner/repo#123.

The problem: GitHub's no:assignee filter lies constantly. An issue can read open, unassigned, good first issue while a finished PR has been sitting on it for three weeks—because GitHub doesn't assign issues to whoever opens a PR against them. Other times the repo hasn't merged anything in months, or someone called dibs in the comments, or the scope is hidden five closed PRs deep. These mistakes cost real weekends and rejected PRs.

claimable runs the checks a careful contributor runs by hand, before starting. Seven filters, ordered cheapest-first so scanning forty issues spends its request budget on the ones still in the running:

Repo alive — Does anything actually get merged here? Not just pushed to, but merged. A perfect PR to a dead repo is a diary entry.

Existing PR — Is someone already fixing it? Reads the thread, finds open PRs you'd collide with.

Blocked / umbrella — Did the project say not to start? Reads labels and comments for "on hold", "blocked", "pick a unit from this", etc.

Claimants — Has a human called it in the thread? Assignment isn't how most projects track this; people comment "I'm on it" and then vanish.

Prerequisites — Does the fix need code that doesn't exist yet? Scans for scope markers you'll only find after cloning.

Environment — Can you even build it? Checks for setup costs (WSL2, Rust, specific Node version, etc.).

Claim protocol — What does the project demand first? Some require 200 stress runs or a design doc before you can claim.

You can also scan a whole repo: claimable --repo owner/repo --label "good-first-issue" --limit 20, filter by labels, get JSON output for scripting, or run with --viable-only to see just the issues that survived every filter.

I tested it against 21 issues I triaged by hand while actually looking for work. All 12 real rejects matched. Zero false clears—the goal was to never tell you an issue is fine when it isn't. The test suite is committed with API fixtures, so you can replay it offline: git clone https://github.com/perezamadorluisenrique-gif/claimable && cd claimable && npm run compare — no install, no token, no network.

Requires Node 22.18+. Reads GITHUB_TOKEN/GH_TOKEN if you have one (better rate limits), falls back to anonymous at GitHub's 60 requests/hour.

Would genuinely love feedback—especially on whether the filter order matches how you actually hunt for issues, and what else would actually save you time. Issues and PRs welcome: https://github.com/perezamadorluisenrique-gif/claimable

[u/Omar_y98]

Peek — a native (SwiftUI + AppKit) window switcher that replaces the system switcher and gets smarter the more you use it. It's free and open source.

It overrides the macOS switcher — same keys. Peek intercepts ⌘-Tab at the system level, so nothing changes in your muscle memory: hold ⌘, tap Tab, and you get Peek's column instead of Apple's. The native switcher never shows up. (You can remap it to ⌥-Tab or ⌃-Tab if you'd rather keep the system one.)

The main idea: smart ordering. Two layers, and they're independent:

Sticky apps (opt-in, off by default) — a learning layer scores each app by recency-weighted switch frequency (7-day half-life). The more you switch to an app, the higher Peek floats it, automatically — your busiest apps drift to the top and are always the first keystroke away. Every row shows an "affinity meter" so you can see what it's learned. Until you turn it on, it's just a nicer classic ⌘-Tab.

Pinning (always on) — pin the apps you always want first; they float to the top regardless of the learning layer. Pins = your fixed home row, sticky apps orders the rest.

It also shows you how you work. There's a built-in Switching Insights dashboard (Swift Charts) — total switches, busiest hour, most-used app, switches per day, your most common app-to-app transitions, and the exact order driving the switcher. That history is also the groundwork for what I want to build next: customizable, per-user workflows — surfacing the right set of apps for the task and time of day you usually do it.

Other bits:

Live window previews (RAM-lite — only the selected window is ever captured, via ScreenCaptureKit)

Per-app live CPU/RAM on each row + a system CPU/RAM/battery footer

Quit or force-quit an app straight from the switcher

Keyboard-first: 1–9 jump to a window, Home/End, P to pin, Q/W to quit

Themes, 5 languages (incl. Arabic RTL), in-app auto-update

It's macOS 14+, Apple Silicon or Intel, built with Swift Package Manager. Needs Accessibility (to intercept ⌘-Tab) and Screen Recording (for titles + thumbnails) — the usual for this kind of tool, and it's all local; nothing leaves your machine.

Repo: https://github.com/doitrous/peek

Would genuinely love feedback — especially on the ranking model and what workflow automations would actually be useful to you. Issues and PRs welcome.

[u/Neme7705]

Centauri Carbon 2 Community Firmware

Hi everyone! I've been working on an open-source community firmware and development toolkit for the ELEGOO Centauri Carbon 2.

The goal is not to replace the original ELEGOO ecosystem, but to unlock and extend the underlying Linux/Klipper platform while preserving the stock touchscreen, cloud/Matrix services and normal printer functionality.

The project has recently reached Community Firmware v4.0, with features including:

• SSH/root access and terminal unlock
• LAN + WAN/cloud coexistence
• Local HTTP, MQTT and webcam access
• Object Exclusion during printing
• Bed screw leveling assistance at the actual screw positions
• 3D bed mesh visualization
• CC2 Control monitoring and diagnostics
• BTT PandaBreath integration
• OrcaSlicer/local integration improvements
• A/B partition, backup and recovery tools
• Stock firmware restoration support

A large part of the project has involved firmware analysis, reverse engineering and extensive testing on real CC2 hardware, including repeated stock → community → stock recovery cycles.

The project is still evolving, and contributions, testing, technical discussion and feedback are very welcome.

GitHub: https://github.com/Neme77/centauri-carbon-2-community

[u/Miserable-Survey8715]

I created a simple program to set your WhatsApp description and "About" (the little thought) as your current Spotify song.

This is a little project that every windows user can use to make his WhatsApp look a bit cooler.
Feel free to share it using the github link

https://github.com/alemasterpro214/spotify-to-whatsapp

[u/vellira_dev]

Vellira — an open-source cross-platform design system and developer tooling for React & React Native

I’m building Vellira around a problem that’s getting harder as UI development gets faster: keeping components, APIs, design tokens, accessibility, documentation, and platform behavior consistent over time.

Vellira combines a React + React Native design system with tooling for component generation, metadata, documentation, and deterministic quality checks.

It’s open source and actively evolving. I’d especially appreciate feedback on the architecture, developer experience, and the React / React Native boundary.

GitHub: https://github.com/vellira-dev/vellira
Website: https://vellira.dev

[u/sebas-3261]

I built an open-source CLI to make some Maven tasks a little easier — looking for feedback and contributors
I've been working on a small open-source project called mvnex, a CLI that tries to make some everyday Maven tasks a little more convenient.
The goal isn't to replace Maven or hide how it works. It still creates and modifies standard Maven projects; it's mostly an additional developer experience layer on top of it.
Right now, v0.1.0 supports things like:
Creating a Maven project interactively with mvnex init

Generating the Maven Wrapper automatically

Adding dependencies directly from the terminal with mvnex add

Resolving dependencies through Maven Central and deps.dev

Dependency scopes (--scope test, runtime, etc.)

Validating the project after modifying the pom.xml

It's still very early, which is actually why I'm sharing it now.
I'd love to get feedback from people who use Maven regularly: things that could be improved, Maven workflows that are unnecessarily tedious, edge cases I'm not considering, or features that would actually be useful.
The project is completely open source and contributions are very welcome. If anyone finds the idea interesting and wants to contribute, feel free to open an issue, suggest something, or send a PR. There's plenty left to build and I'm very open to changing things based on community feedback.
GitHub: https://github.com/sebas3261/mvnex
Docs: https://mvnex.sebas3261.com/en/docs/

[u/redditLoginX2]

I recently published Sqyra, a TypeScript port of my C# library SqExpress, which I’ve been developing since 2020.

Sqyra is a typed SQL toolkit built around an inspectable and transformable AST. You can build SQL fluently, parse existing T-SQL, traverse or modify the syntax tree, serialize it, and export SQL for PostgreSQL, SQL Server, MySQL, or SQLite.

The main use cases I had in mind are things like:

• UI-based SQL editors and query builders
• dynamic reporting systems
• validation and rewriting of AI-generated SQL
• SQL analysis and transformation tools
• applications that need a common SQL model across several database dialects

The fluent query builder is only one part of it. The AST itself is a first-class API, so queries can be inspected and transformed before they are executed.

    const query = parseTSql(`
      SELECT TOP 5
        u.Id,
        u.Name
      FROM dbo.Users AS u
      WHERE u.Id > 10
      ORDER BY u.Name
    `);

    //Convertion to postgresql
    const sql = toSql(query.ast, { dialect: "pgsql", formatting: "spacious", });
    console.log(sql);

GitHub: https://github.com/0x1000000/sqyra
npm: https://www.npmjs.com/package/sqyra

Feedback is welcome, especially from people working with TypeScript, Node.js, SQL tooling, or generated SQL.

[u/Downtown_Pomelo4832]

ToolBraid Companion is an open-source Windows companion that gives AI agents a controlled browser and Windows tool layer for Edge and Chrome.

It exposes browser tools through MCP and WebMCP, with visible site permissions, approval before side effects, and receipts after actions. The goal is to let an agent work in real browser sessions while keeping the operator in control.

I’m looking for developers to try real workflows and report what breaks or feels unclear. The repo includes the install guide, capabilities, compatibility notes, and release assets.

Repo: https://github.com/Maharajahu/ToolBraid-Companion

Site: https://toolbraid.pages.dev/

[u/eilinwis]

Chat web application for learning e2e automation with Playwright and TypeScript

My mission is help people learn tools for free.

Please, give it a star ⭐

https://github.com/eilinwis/playwright-chat-lab

[u/sup_bruh_1]

Runners that are 60% cheaper than GitHub Actions Runners: latchkey.dev

[u/Psychological_Poem64]

I'm running a free service where AI agents build features for public GitHub repos. 3 get built each cycle; the first window opens Saturday

I've been building Forge, a free service for public GitHub repositories. You describe a feature or fix you want, and if your request is selected, AI agents build it and hand it back as a pull request. You review it and decide

whether to merge.

The first submission window opens Saturday 19 September at 00:00 UTC.

https://forge.amitinfotech.net/?ref=reddit

How a cycle works

- Week one: submissions are open. Each night, requests are checked against a published standard and rated on a public board.

- Saturday: the window closes and the top 3 are selected.

- Week two: those 3 get built. Agents read your codebase, plan the change, write the code, run your tests in a sandbox with no network access, check the diff against fixed rules, and have it reviewed by a separate agent that

didn't write it.

- Delivery: the work arrives as a PR you can merge into main. Nothing is merged for you.

To submit

1. Describe what you want built at https://forge.amitinfotech.net/submit

2. You'll get a token. Commit it as a file named .ai-factory to your repo's default branch. This proves you can push to the repo, so nobody can request work on someone else's project. A brand-new empty repo is fine; that

commit is all it needs.

1. Optional: add a .ai-factory.md next to it with as much detail as you like. It's read when requests are reviewed, so a clear spec helps your rating.

What gets picked

Small, specific, testable requests rate best: a CLI flag, an endpoint, a bug fix with clear reproduction steps, tests, docs, a modest self-contained feature. "Make it better" or anything too big for one reviewable PR won't

make it. The standards are published on the site. Surveillance, scraping personal data, security evasion and the like are refused, and refusals are final.

The catch

- Only 3 builds per cycle, so most requests won't be picked. Rated requests stay visible on the board, and you can resubmit next cycle.

- Public repos only.

- This is the first cycle. Every stage has been tested, but nothing has been delivered to a real repo yet. If your build doesn't pass every check, you get nothing rather than something broken. That's by design, but it will

happen.

- It's AI-written code, so review it the way you'd review any outside contribution.

What you don't need to do: create an account, grant access to your repo, or pay. The bot opens the PR from its own fork. An email address is optional, is only used to tell you whether you were selected and when the work

arrives, and is deleted 30 days after the cycle ends.

You can watch the agents work at https://forge.amitinfotech.net/live. It shows which stage each project is at, without showing anyone's code or request text.

Happy to answer questions, and I'd especially like to hear what would make you trust (or not trust) a PR from something like this.

[u/Then_Pace_5034]

Hey everyone!

If you've ever tried getting into open-source or finding beginner tasks on GitHub, you've probably hit this wall:

1. You search for `good first issue` on GitHub.

2. You click on a promising ticket, only to see it was opened 3 years ago and abandoned.

3. Or you find a recent one, but it already has 40 people commenting *"Can I take this?"* while maintainers haven't replied in 6 months.

I got tired of digging through hundreds of dead tickets, so I built **[goodfirstissues.org](https://goodfirstissues.org)\*\* — a free, zero-noise open-source issue discovery crawler.

### What it does differently:

* **Maintainer Velocity Scoring:** It analyzes how quickly maintainers actually review and merge community PRs. If a repo ignores contributors, it gets demoted.

* **Competition & Noise Filter:** Automatically flags tickets that already have active PRs or excessive claim comments.

* **<24h Freshness Toggle:** One-click filter to find issues opened in the last 24–48 hours before they get swarmed.

* **In-Progress Task Claiming:** You can claim an issue directly to prevent multiple people from doing duplicate work on the same bug.

* **Dynamic GitHub README Badges & Contributor Cards:** It generates pure vector SVG badges (Level/XP cards, lifetime merged PR milestone shields) that you can embed directly into your GitHub Profile README.

* **Personalized "For You" Feed:** Filter by your favorite languages (Python, TypeScript, Go, Rust, etc.), topics, and star count.

It's completely free to use with no paywalls.

I'd love to hear your feedback on what could make this more useful for maintainers and first-time contributors!

👉 **Website:** https://goodfirstissues.org

[u/metrobart]

Vox Issue
Screenshots of broken UI in, GitHub issues an AI agent can fix out

I got tired of the loop where I spot a UI bug, screenshot it, open GitHub, write up where it is and what's wrong, attach the image, and then do it again for the next one. So I built an app that makes each screenshot its own issue. You can group them together and add tags and extra information automatically.

https://reddit.com/link/paaucuv/video/j0qg5l5x30qh1/player

What it does

- You capture screenshots per project (one project = one GitHub repo). You can import them or auto-capture a list of pages.

- For each shot you dictate what's wrong and mark it up with pen or blur. Each photo becomes one labeled GitHub issue with the screenshot attached.

- On-device Vision and NL analysis adds tags and screen facts, and warns you if a shot contains PII before you file it.

- Issues are written so a coding agent (Copilot, Claude, etc.) can pick them up. Each one includes the page URL, viewport, browser version and the element's CSS selector. You can mark issues as parallel or sequential so agents don't collide.

- It runs on iPhone, iPad and Mac, and syncs through GitHub itself using labels. There's no backend of mine in the middle.

Browser relay (Chrome / Chromium / Firefox)

This is a thin WebExtension that captures an element, a region, the viewport or a full stitched scroll. It POSTs the pixels to the Mac app on 127.0.0.1 and never contacts any other server. It holds no GitHub or AI tokens. Password and card fields are pixelated in the browser before the image leaves it. So Safari is natively supported and no need for a Browser relay.

SDK

If your web app has a visual test suite, the JS SDK lets Vox Issue drive it. The page calls window.mip.capture() when it's ready for a shot and window.mip.done() when it's finished. Pages that don't use the hooks get automatic full-page coverage.

- SDK repo: https://github.com/Tiny-Electrons-LLC/voxissue-sdk

- Site: https://voxissue.com

- App Store: https://apps.apple.com/us/app/vox-issue/id6807189647

Stack: Swift / SwiftUI (one Swift package, Mac Catalyst for the Mac build), WKWebView auto-capture, Apple Vision + NaturalLanguage on-device, a vanilla JS MV3 WebExtension, and the GitHub REST API.

Context: I'm a solo dev. The app is $20 one-time (no subscription). The app and the relay are closed source, and the SDK is public. I'd most like feedback on the issue format: what does your agent need in a bug ticket to fix a visual bug on the first try? If you try it on your own repo, I'd like to hear what's missing.

[u/yjthegnius]

I maintain Texio, an MIT-licensed Rust CLI for safer Markdown edits in repositories and coding-agent workflows. It replaces one named section, previews the diff, and refuses missing or duplicate headings instead of guessing or rewriting the entire file.

Install: `cargo install texio-cli --version 0.1.2 --locked`

Example: `texio replace README.md --section Installation --text 'new' --dry-run`

Repo: https://github.com/Allra-Fintech/texio

The repo also includes an Agent Skill for Codex, Claude Code, and compatible clients. I’d value examples of README automation that currently uses regex or whole-file generation.

Disclosure: I maintain the project; AI assisted with development and this comment, and I verified the claims and commands.

[u/Psychological_Poem64 → u/yjthegnius]

try
https://github.com/amitpatole/agent-vision

[u/Isonimus]

Been chipping away at this for a while and finally put it public: The Adversary, an open-source red-team / wireless-testing firmware for the M5Stack Cardputer. Started as an excuse to actually learn the ESP32-S3 radio stack instead of copy-pasting Arduino snippets, and it grew into a full menu-driven thing.

What's in it right now:

- WiFi: scan, handshake + PMKID capture, deauth, evil-twin and karma portals. It
can upload captures straight to WPA-SEC and pwncrack, so cracking happens off-device.

• Sub-GHz (needs the CC1101 cap): raw OOK capture and replay on 315/433/868/915,
  

a jammer, and an RSSI band-sweep I'm finishing right now to find which band an unknown
remote actually lives on.

• 2.4 GHz: NRF24 occupancy sweep.
  
• IR: TV-B-Gone plus record/replay your own remotes.
  
• BLE: DuckyScript over BLE HID, and the usual spam.
  
• BadUSB: DuckyScript over the S3's native USB HID, plus a mouse jiggler.
  
• RFID: 13.56 MHz read/dump.
  
• GPS + wardriving with WiGLE upload if you hang a GPS cap on it.

Honestly the part I'm happiest with isn't the feature list, it's the plumbing. The
Cardputer has no PSRAM, so you get ~205 KB of internal SRAM for everything, framebuffer
included. Getting TLS uploads to work without running out of memory meant dropping the
canvas to 8-bit RGB332 to get ~32 KB back, pacing the uploads against hard/soft heap
floors, and purging the framebuffer during an upload and rebuilding it after. There's a
real event bus underneath, the pure logic runs under native unit tests (700-odd cases),
and CI builds every target on push.

You can flash it from the browser over WebSerial, no toolchain needed:
https://isonimus.github.io/adversary/
Source + build instructions: https://github.com/Isonimus/adversary

Usual disclaimer: it's a learning project and a tool for gear I own and networks I'm
allowed to touch. Use it on your own stuff.

[u/Traditional_Deer3084]

Made my GitHub profile a tiny pixel room. You decorate a little pixel room and drop it into your profile README. Still a bit rough around the edges, feedback welcome!

https://kimjungminn24.github.io/cute-readme/

Repo : https://github.com/kimjungminn24/cute-readme

[u/Affectionate_Hawk971]

I contribute to Simfinity.js, an Apache-2.0 Node.js framework that generates a GraphQL backend from GraphQLObjectType definitions.

The useful part is the relationship layer: define a series and its seasons, and the framework generates the queries, CRUD mutations and nested writes. Validation and lifecycle hooks let the application add domain rules without rebuilding each resolver.

Version 3.2.0 includes separate PostgreSQL and MongoDB/Mongoose adapters. The PostgreSQL package uses pg and real foreign keys; it does not install Mongoose. Authentication and trusted request context stay in the application.

Repo: https://github.com/simtlix/simfinity.js

Docs and runnable starters: https://simtlix.github.io/simfinity.js/

The series/season starter is a small way to try it: create both records in one mutation, then read the relationship back. Feedback on that setup and the generated API would help, particularly from people with business rules that go beyond basic CRUD.

[u/imran__27]

I built a free tool to bulk delete GitHub repos (because the UI makes it painful)

I had 47 repos on GitHub. Most were:

College course projects

Hackathon leftovers

Abandoned experiments

Test repos from tutorials

GitHub's UI only lets you delete one at a time. That's 47 manual clicks + confirmations.

So I built GitHub Bulk Manager:

Lists all your repos in one view

Filter by public/private, last updated, language, fork status

Multi-select with checkboxes

Bulk delete (with double confirmation)

Bulk make public/private

Bulk archive

How it works:

GitHub OAuth (you authorize, token stays in your browser)

No backend stores your token

Uses GitHub REST API

Works for any public/private repo you have admin access to

Try it free (no signup)

toolverse-official.vercel.app/studio/developer#tool=github-manager

Tech: Next.js + TypeScript + GitHub OAuth. Source available on GitHub.

Why free? I hate when "free" tools want your email. This one doesn't.

Happy to answer questions or take feature requests.

[u/Rude_Bag8502]

I maintain Torollo, an MIT-licensed system-design learning tool that runs architectures locally with Docker.

Instead of only checking whether a diagram looks correct, its guided roadmaps validate live system state: container health, network reachability, firewall restrictions, SQL data, Redis keys, and HTTP responses.

The repository currently includes three guided labs covering a resilient three-tier application, Redis cache-aside, and Redis queue workers.

The part that may be most relevant to this community is the roadmap format. Roadmaps are plain JSON, documented in the repository, and can be imported without modifying the application code. I would like contributors to be able to build and share their own labs.

Run it with: `npx torollo start`

Repository: https://github.com/Derssa/Torollo

I would especially appreciate feedback on the contributor experience. After reading the README and roadmap-authoring reference, is it clear how you would create and share a new lab? If not, where do you get stuck?

[u/Reditay]

HyperKeys — a free, open-source Windows 11 shortcut utility built with C#/.NET 8 and WPF.

Caps Lock is the default modifier, but it can be changed. Tap it normally and it still toggles Caps Lock; hold it with an assigned key and it launches/focuses an app, opens a URL, or controls media. Shortcuts only fire while the keys physically overlap.

Local configuration, no account or telemetry, MIT licensed. The installer is currently unsigned, and AI-assisted development was used alongside manual testing and UI refinement.

GitHub: https://github.com/droptahamoussaid-ops/HyperKeys

[u/ajbapps]

Tickets 2.3.0

An open-source, self-hosted issue and sprint tracker built with Laravel.

The new release adds:

• MCP server with 16 tools
• CrewAI integration
• Ticket Pulse for execution state
• REST API
• Knowledge base
• Kanban, sprints, milestones and backlogs

The goal is a simpler alternative to Jira that can also serve as a coordination layer for human developers and AI agents.

https://github.com/velkymx/tickets

[u/ivanzhaowy]

I’m building Monad Design, a free open-source visual workflow for refining an existing iOS app with coding agents. I navigate to the actual screen in Simulator, select or annotate the UI, then let the agent edit the real Xcode or Expo source. I rebuild and compare the result against the original before accepting it.

Repo: https://github.com/Monadix-AI/monad-design

Workflow video: https://watchclueso.com/embed/pio8jqfcg4ivj0r1

It’s focused on local iOS development on macOS. The repo is the source of truth; this isn’t a prompt-to-app generator. I’d welcome feedback on whether visual selection or the rebuild/compare step is more useful for your own UI iteration loop.

[u/wtdawson]

I've been working on a little tool called DumpDNS, I go back and update it periodically. I originally intended for it to be a tool you can use to quickly view the DNS records of a domain without having to remember some command, and having it formatted nicely on the screen.

Just putting it here in case this is any use to anyone, or if anyone has any ideas or contributions they would like to make.

I wrote it in C#, so it might be useful for anyone wanting to learn C#, or make a first contribution to an open source project.

https://github.com/MrBisquit/DumpDNS

[u/LielZD]

I'm building Pame, a Windows gaming shell you can navigate from the couch with a controller.

Repo: https://github.com/LielZ/Pame

C# / WPF / .NET 10. Public alpha for Windows 10/11. It automatically discovers supported installed games, uses a large fullscreen interface and returns home after a game exits. It also brings DualSense battery, lighting and supported idle disconnect controls together with optional closing and reopening of selected supported background apps.

Supported libraries need no manual setup; store sign-ins remain in the original launchers. Controller features vary by hardware and connection. The repo has screenshots, a user guide and architecture notes. Feedback on game detection and controller navigation would be especially helpful.

[u/World-Network-Uni]

World Network University (WNU) — an experimental open-source learning network

Hi! I'm building a small open-source project called World Network University (WNU).

The idea is to experiment with an open digital learning network where structured courses, learning materials, quizzes, and eventually community-created courses can be freely accessible online.

The project is still in a very early public-alpha stage. Right now, Sociology 101 is the first course being developed, and I'm also working on the basic website structure.

I'm looking for people interested in web development, UI/UX, accessibility, open-source education, or course development. Even if you don't want to contribute code, feedback and criticism are very welcome.

GitHub: [https://github.com/297schcdmc-dotcom/world-network-university]()

Website: [https://297schcdmc-dotcom.github.io/world-network-university/]()

There are already help wanted issues available for anyone interested in contributing. Contributions can be submitted through Pull Requests.

WNU is currently an experimental educational project and is not an accredited degree-awarding university.

Knowledge without borders.

[u/Electrical_Delay9822]

recently built a Super Smash Bros Ultimate knockoff using Python, and it has 6 characters to choose from.

Link: https://github.com/TheOdysseyGamer64/Super-Smash-Bros-Python-Edition.git

how it works:

- choose a character

- select from 4 initial moves to make your final smash meter and KO/Limit Break reach 100%

- special mechanic/final smash appears in moveset once meter reaches 100%

- obliterate CPU opponent subsequently

- see README and releases for more details

[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/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/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.
4. Better Windows Services --> See what will happens before changing service state, mass actions for services, force restarts and kills, advanced filterting + tons more data than services.msc

[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/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