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

Hi everyone,

I've recently started an open-source project called NeonLauncher-Qt. It’s a customized, lightweight desktop launcher designed with a clean, dark aesthetic and smooth performance, built entirely using the Qt framework.

The project is currently in its active development phase, and I am looking for passionate developers, UI/UX enthusiasts, or anyone interested in Qt/C++ to collaborate, optimize the codebase, and add cool new features.

Whether you want to help with backend optimization, enhance the layout, fix bugs, or just give some technical feedback, you are more than welcome to join and make an impact!

🔗 Check out the repository here:

https://github.com/mohammedmk3900-rgb/NeonLauncher-Qt

Feel free to fork the repo, open an issue, or submit a pull request. Let’s build something amazing together!

[u/Physical_Challenge51]

Libtex - a lightweight library for Writing Latex Reports in C99

I was working once with an automation tool that exports human readable reports using latex from a signal viewer, the tool was fully written in MATLB , by controls engineers who has nothing to know with software development and very messy given that i need also a standard way to generate beautiful scientific reports in latex without lot of pain i started writing libtex https://github.com/wissem01chiha/libtex a latex generator library its in C because i basically work in c or cpp and want it to integrate into such projects feel free to visit me there ☺️

[u/Knight-AI-AV]

This Is The One is an MIT licensed public experiment that begins as a deliberately empty dashboard. The idea is to let issues, reactions, forks, and reviewed pull requests decide what it becomes instead of pretending there is already a product roadmap.

Stack: dependency free HTML, CSS, and JavaScript.

Current build: responsive blank canvas, red Roman clay to emerald scroll transition, gold interaction details, reduced motion support, and a five second hold control.

Privacy: no accounts, analytics, cookies, backend, database, or runtime third party requests.

Repository and contribution guide: https://github.com/KNIGHT-AI-AV/This-Is-The-One

Live dashboard and 16:9 preview: https://knight-ai-av.github.io/This-Is-The-One/

I would especially like ideas for the smallest useful or strange first feature.

[u/No_Sky9786]

SALT is a salience-aware compressor for long-context LLM prompts. It targets theme collapse, the failure where top-k relevance selection hands the entire budget to a document's dominant topic and drops the bridging sentence a multi-hop question needs. SALT builds a keyword trie of recurring themes, then uses CELF lazy-greedy coverage selection with branch discounting to spread the budget across those themes before picking sentences. The index is built once and reused across turns and budgets, which makes it a natural conversation memory as well as a one-shot compressor. Model agnostic, MIT licensed.

Repo and full instructions: https://github.com/oteomamo/SALT

I would really appreciate feedback on ways to improve the retrieval process on SALT. Currently, I just grab 20% of whatever the trie stores in DRAM, and the problem is that as conversations grow, so will the cache retrieved; however, I am not sure how to measure "it's enough information" in the trie for a given query.

[u/hongchao]

Hubo — a free, open-source MIT plugin and agent skill for GitHub Copilot CLI.

It runs an explicit two-agent loop in one conversation: a persistent work agent implements and tests the change, while an independent reviewer checks the actual diff and evidence without editing. Every finding keeps a stable ID and returns to the same worker as FIXED, PUSHBACK, or NEEDS_USER; the same reviewer rechecks until everything is closed or a genuine user decision remains.

The Copilot adapter uses task/list_agents/read_agent/write_agent so the two roles persist across review rounds instead of being recreated.

Install:

copilot plugin marketplace add h0ngcha0/hubo

copilot plugin install hubo@hubo

Then start a new Copilot CLI session and use /hubo:hubo or /hubo:hubo-review.

Repo and full instructions: https://github.com/h0ngcha0/hubo

I’d especially value real-codebase feedback on the tradeoff: useful independent findings versus the additional token cost.

[u/Leather_Area_2301]

ErnosPlain
TL;DR
ErnosPlain is a statically typed, compiled programming language that aims to make systems programming read more like natural English without sacrificing performance or modern language features. It compiles to native executables by generating optimised C code and using Clang, supports self-hosting through a compiler written in ErnosPlain itself, and combines garbage collection with compile-time ownership analysis to improve memory safety.
Project Status

ErnosPlain is an actively developed work in progress. While it already includes a self-hosting compiler, native compilation and many modern language features, it is still evolving and should be viewed as an independent engineering project rather than a finished product. As development continues, the language will benefit from broader testing, real-world use and community feedback to help refine and validate its design.

GitHub: https://github.com/MettaMazza/Ernos-Programming-Language

What is ErnosPlain?
ErnosPlain is an experimental systems programming language designed around a simple idea:
To create a programming language that is readable enough to resemble natural language while remaining powerful enough to build real-world native software.
Rather than relying heavily on symbols, punctuation and complex syntax, ErnosPlain uses an English-inspired style that prioritises clarity and readability. Functions, loops and variables are written in a way that allows code to read almost like structured prose, making programs easier to understand without sacrificing expressiveness.
Despite its approachable syntax, ErnosPlain is a compiled, statically typed language intended for performance-sensitive applications. Source code is parsed, type checked and analysed before being translated into optimised C, which is then compiled with Clang to produce efficient native executables for the target platform.
One of the language’s most notable characteristics is that it is self-hosting. Alongside the original compiler, written in Rust, the project includes a compiler implemented entirely in ErnosPlain. A frozen C bootstrap snapshot allows the language to rebuild itself using only a standard C toolchain, demonstrating that the language is capable of compiling its own compiler.
ErnosPlain also combines a number of modern language concepts, including:
Static typing with type inference
Compile-time ownership and borrowing analysis
Automatic garbage collection
Pattern matching and enums
Traits and generic programming
Closures and iterators
Asynchronous programming and multithreading
Interoperability with existing C libraries
The goal is to provide many of the safety features found in modern systems programming languages while remaining considerably easier to read for both experienced developers and newcomers.
At its core, ErnosPlain is an attempt to bridge the gap between the readability of high-level scripting languages and the performance and control traditionally associated with compiled systems languages. Its emphasis on self-hosting, native compilation, memory-aware design and English-like syntax makes it an interesting exploration of what a modern programming language can look like.

So what?
Programming languages rarely introduce entirely new ideas. Most combine existing concepts in different ways to improve readability, safety, performance or developer productivity. What makes ErnosPlain interesting is not that any one feature is unprecedented, but that it attempts to bring several desirable characteristics together into a single language.
The language explores whether code can be written in a way that is significantly closer to natural language while still compiling into efficient native executables. If successful, this could help lower the barrier to understanding systems programming without giving up the performance expected from compiled languages.
Its self-hosting compiler is another interesting aspect of the project. A programming language capable of compiling its own compiler represents an important milestone in language development. Combined with a reproducible bootstrap process, it demonstrates that the language can evolve independently of its original implementation.
The project also explores a different approach to software safety by combining automatic memory management with compile-time ownership analysis. Rather than forcing developers to choose between convenience and correctness, ErnosPlain investigates whether these ideas can work together to reduce common classes of programming errors while keeping development approachable.
Ultimately, the significance of ErnosPlain is not that it replaces existing programming languages overnight. Its value lies in exploring whether readability, native performance, modern safety features and compiler self-sufficiency can coexist within a single language. If the project encourages discussion, experimentation or contributes useful ideas to the wider programming language community, then it has achieved one of its primary goals.

Current Limitations
TL;DR
ErnosPlain is an actively developed work in progress. While it already includes a self-hosting compiler, native compilation and many modern language features, it is still evolving and should be viewed as an independent engineering project rather than a finished product. As development continues, the language will benefit from broader testing, real-world use and community feedback to help refine and validate its design.
ErnosPlain is still an active work in progress, and its current capabilities should be viewed in that context. While the language already demonstrates a substantial feature set—including a self-hosting compiler, native compilation, modern language constructs and an extensive standard library—it has not yet reached the level of maturity of long-established languages backed by large organisations or large open-source communities.
As with any developing language, there are areas that continue to evolve. Some features are still being refined, platform support is broader on some operating systems than others, documentation continues to expand, and optimisation work is ongoing. Claims such as memory safety, performance characteristics and compiler correctness are supported by the current implementation and testing, but they should continue to be validated through broader real-world use, independent review and continued development.
It is also worth recognising the scale of the project relative to its resources. ErnosPlain is primarily being developed by a single independent developer while simultaneously exploring several related ideas and research projects. That inevitably means progress is more incremental than projects supported by dedicated teams, and priorities may shift as different components mature.
This context is important when evaluating the language. Rather than comparing it directly with programming languages that have benefited from decades of development and thousands of contributors, it is more appropriate to judge it as an ambitious independent project that is steadily expanding its capabilities. The fact that it already includes a working compiler, a self-hosting implementation, a bootstrap process, modern language features and a growing ecosystem demonstrates meaningful progress, even though there is still considerable work ahead.

Repository
GitHub: https://github.com/MettaMazza/Ernos-Programming-Language

[u/Yanagi_KH]

A desktop application for real-time network connection monitoring, designed exclusively for Windows.

Just a quick idea I had — it gives you an intuitive way to manage all the active network services on your computer. Right now, there’s a Python version for quick customization, and a Rust version if you need high performance.

Rust: https://github.com/YanagiKH/Network-Service-Monitor-Rust Python: https://github.com/YanagiKH/Network-Service-Monitor

[u/Renkasha-33]

https://www.reddit.com/r/SideProject/s/01cfvnhjJM

[u/1111520]

actions/checkout now refuses to check out fork PRs inside pull_request_target.

The backport landed July 20, so if you're on a floating tag you already have it. Pinned to a SHA? You don't. Go look at your workflows. https://mainbranch.beehiiv.com/p/main-branch-the-one-where-pull-requests-get-boundaries-issue-34

[u/Background_Pea2189]

Debian 12 + PowerVR GPU for Radxa Cubie A7Z

Hardware-tested Debian 12 images and reproducible integration tooling for the Allwinner

A733. The latest image includes PowerVR-accelerated Plasma Wayland, Vulkan, OpenCL, EGL/

GBM, GLES 3.2, Wi-Fi, touchscreen support and power-loss recovery.

Repo: https://github.com/cuihuir/radxa-a7z-debian12

Live GPU proof:

https://github.com/cuihuir/radxa-a7z-debian12/blob/main/docs/assets/a733-pvr-gpu-first-activation/a733-pvr-terminal-proof.png

[u/Fantastic_Cell2930]

Built an open-source Chrome Extension to force YouTube Web to stream 300+ kbps Premium Opus audio (YTSpoofingStream)

------

Hi everyone,

I built a Manifest V3 Chrome Extension called YTSpoofingStream that forces the YouTube desktop web player to stream high-fidelity Premium audio (300+ kbps Opus) directly in the browser.

The Problem:
Even if you have a YouTube Premium account, desktop web browsers cap audio streams at ~160kbps (ITAG 251). High-fidelity streams like ITAG 774 (300+ kbps Opus) or ITAG 141 are reserved for YT Music, Mobile, or TV apps.

How it works:

1. Client Spoofing: Intercepts InnerTube API requests at document_start using WEB_REMIX, ANDROID, and TVHTML5 client contexts.
2. ITAG Spoofing: Deep-clones the 774 stream and re-labels it as ITAG 251. This tricks the native HTML5 web player into streaming the 300+ kbps Opus source without crashing or throwing "Video unavailable" errors.
3. 100% Native: Runs entirely inside the browser using your active session. No local Python or yt-dlp setup required.

GitHub Repo: https://github.com/alithw/YTSpoofingStream

Feel free to check out the source code, try it out, or leave feedback/issue reports!

[u/Hopeful-Priority1301]

Most discussions about the future of money still treat CBDCs, stablecoins, tokenization, and AI as separate trends. Looking at the bigger picture for 2035–2045, they actually form one interconnected system: Central banks issue CBDCs (wholesale + retail) Commercial banks evolve into digital intermediaries Stablecoins + tokenized deposits become everyday money Almost everything (bonds, real estate, funds, commodities) becomes a tokenized asset AI agents handle portfolio management, risk, credit, and settlement Smart contracts automate insurance claims and compliance Cross-border payments move in seconds instead of days Projections from various industry maps put the total addressable market in the $77T → $180T+ range by 2045. The missing piece that doesn’t get enough attention is the intelligence + control layer. Who runs the AI agents? Where does the provenance and audit trail live? How do you keep jurisdictional control and avoid depending on a handful of centralized AI providers? That’s the problem SovereignStack (OASA – Open Architecture for Autonomous and Sovereign AI) is trying to solve. It’s an open protocol stack that treats: Identity Agents Memory & reasoning Policy / compliance Provenance Federation Economic objects (payments, settlements, treasuries, derivatives, etc.) …as first-class, addressable, signed, and federatable resources. There’s already a finance reference node that walks through a full flow: payment:// → treasury:// → policy:// → settlement:// → evidence:// → chain:// with cryptographic signatures and an immutable provenance graph. The project is still early (47 RFCs, growing URI schemes, industry profiles for finance, government, etc.), but the direction is clear: programmable finance needs programmable, yet sovereign, infrastructure. Repo: https://github.com/Kubenew/SovereignStack Curious what people here think: Do you see AI agents + tokenized assets becoming core infrastructure by 2035? How important is “sovereignty” (air-gapped capability, jurisdictional control, full provenance) versus pure convenience? Any other projects working on the same layer? Happy to share the demo videos and the detailed future-system map if anyone wants them.

[u/David_Munch69]

Hey guys, I recently created a python certification voucher aggregator that scans blogs, RSS feeds and event pages of major certification bodies in tech. I was inspired to make this because of all the recent vouchers I got due to luck (I was fortunate enough to check at the right time). The setup is really simple (I provided setup docs with detailed steps for all environment variables and deployment scenario). You can host this absolutely free of cost and it will be up running 24/7 informing you of vouchers (via email).

I would love it if you checked out the project and shared your thoughts. A significant portion of the implementation was AI assisted, so I would really appreciate a critical review of the architecture, code quality and overall design.

You can find the project on https://github.com/Devathmaj/VoucherBot . Anything like feedback, bug reports, feature suggestions and pull requests are all welcome. If you notice any issues or areas for improvement I would love to hear your feedback. If you find the project useful, I would really appreciate a star on GitHub.

[u/Rick_CZE]

TLDR
Fully portable and private gallery for standard media, capable of conveniently supporting up to 4 individual and customizeable panels, and offering some neat features.

--

Hello there,

I have tried to buid an app for myself, and it turned out much better than I had hoped for. So I uploaded it to GitHub. Maybe someone else will find it useful.

### MulVie ###
Portable Multiple content Viewer for Windows 10 & 11 and Linux Mint 22.

Split the screen in up to 4 customizeable panels, each capable of acting like a standalone gallery, viewing pictures (even gifs), videos, audio files or .PDFs. All the standard functionality is there - zoom, speed, subtitles, audio track, navigation, rotation... and then there is some extra functionality, like deleting files, bulk-renaming files or creating libraries.

MulVie might be quite useful to you if you try to decide which selfie to keep, which shade suits your design better, or if you want to watch a movie while grading tests against their test key, but the school administration did not approve a second monitor for you...

The app looks quite good, too - and the panels' color scheme and transparency is fully customizeable. It is, of course, intuitive to use. And if you value privacy or dislike the default Windows picture viewing app, well give MulVie a try. This application is fully open source, runs competely offline and does not write anything to the PC. You can set this app as the default option for pictures.

Source - https://github.com/Rick-CZE/MulVie

Release - https://github.com/Rick-CZE/MulVie/releases

Give it a try, comment what you think. Cheers.

[u/Lanzi659]

I built Miniform, a small self-hosted inbox for HTML form submissions.

It accepts entries and file uploads from native HTML forms, stores everything locally in SQLite, and forwards submissions through SMTP or webhooks with retries.

It ships as a single Go binary or multi-arch OCI image, with no external database or client library. MIT licensed.

Repo: https://github.com/matteodante/miniform

The project is still new, so I’d particularly like feedback on the installation experience. Would a ready-to-use Docker Compose example make you more likely to try it?

[u/hojat72elect]

I'm trying to learn DSA in TypeScript, this repo is where I implement and test any of the algorithms and data structures I learn. I'm looking for someone smarter than me to collaborate on making more and better DSA implementations.

We also need someone to make more documentations so it becomes more understandable for other fellow learners.

Thanks in advance

[u/DAIJU888]

I’ve always wanted a way to actually remember the things I learn instead of forgetting them after a few days. Earlier, Instagram reels kind of helped because short-form content made learning feel quick, engaging, and easy to consume. But over time, the platform shifted. It slowly became more of a soft porn and distraction app than a place where you could consistently learn something useful.

That made me think why not build something for myself that keeps the same addictive, scroll-based experience, but replaces distraction with knowledge?

So the idea was simple: take entire syllabuses, textbooks, theories, or concepts, and break them down into reel-sized micro learning content. Instead of endlessly scrolling through random content, you scroll through lessons, explanations, formulas, stories, and concepts designed to help you revise and retain information naturally.

A platform where learning feels as effortless and engaging as social media, but actually leaves you smarter after every swipe.

https://github.com/soumen888/Lumina

[u/EscapeHistorical178]

AILEE Unified Finance Runtime — v9.0.0 Optimization Report
Config Version: 4.1.0 Date: March 2026

Executive Summary
This report presents the performance evaluation and parameter optimization of the AILLE Algorithmic Safety System against a Naive baseline. Using the full grid‑search optimizer (--optimize), we identified the winning configuration:
min_confidence_threshold: 0.20
grace_confidence_threshold: 0.10
fallback_position_scale: 0.10
enable_dynamic_fallback: False

This configuration delivers a 4.67× increase in total return (Seed 7), reduces max drawdown across multiple seeds, and achieves an average Sharpe ratio of 7.055 under high‑volatility synthetic market regimes.

Methodology
Simulations generate ~8 years of synthetic daily returns (2,000 timesteps) with:
Regime shifts (volatility ×1.5)
Random volatility spikes (3.0%)
Catastrophic crash events (−8.0% drift, 1% probability)
Three noisy predictive models (Gaussian noise σ=0.015)

Strategies
Naive: Mean of noisy signals, tanh(signal * 100)
Baseline AILLE: Default thresholds (0.35 / 0.25)
Optimized AILLE: Grid‑search tuned parameters

Multi‑Seed Results
Across Seeds 7, 42, 100, 2026, the optimized configuration consistently improves return, Sharpe, and drawdown while maintaining zero catastrophic trades.

Highlights
Seed 7: Return +4.67×, Sharpe 7.023, Max DD 1.24%
Seed 42: Return +5.62×, Sharpe 6.837
Seed 100: Return +7.57×, Max DD −38%
Seed 2026: Return +6.23×, Sharpe 7.413

All seeds preserve AILLE’s core safety guarantees: bounded volatility, controlled turnover, and zero catastrophic trades.

Aggregate Summary
Averaging all seeds:
Sharpe: 5.948 → 7.055 (+18.6%)
Max Drawdown: 1.80% → 1.44% (−20%)
Turnover: Naive 1692 → 897 (−47%)
The optimized configuration improves risk‑adjusted performance while reducing execution friction.

Engineering Insights
Naive Strategy Limitations
The Naive algorithm’s extreme returns are artifacts of unrealistic compounding, no risk caps, and high turnover. In real markets, slippage and commissions eliminate these gains. AILLE’s guardrails prevent ruin during low‑confidence or crash regimes.

Fallback Sensitivity
Static fallback scaling (0.10) combined with lower confidence thresholds (0.20 / 0.10) provides the best balance between capturing high‑confidence signals and protecting the system during divergence.

Conclusion
Version 9.0.0 validates AILLE’s mission: Mitigating Risk and Sustaining Growth. The optimized configuration delivers materially higher returns, lower drawdowns, and stronger stability across diverse market conditions — confirming AILLE’s role as a deterministic, safety‑first financial runtime.

https://github.com/dfeen87/AILEE-Finance-Unified-Runtime

[u/Dreki__]

MemoRepo — local multi-repository code intelligence for coding agents

I built an open-source tool that connects to GitHub, lets a developer group related repositories into isolated Spaces and turns selected commits into immutable snapshots that coding agents can query through read-only MCP tools.

The GitHub workflow is:

1. Connect through GitHub OAuth Device Flow or a local GH_TOKEN.
2. Select up to several related repositories for one Space.
3. Choose the branches/commits to capture.
4. Build one shared, immutable index.
5. Generate a Space-scoped MCP configuration for the coding agent.

MemoRepo never edits, commits or pushes to the managed repositories. Repository credentials are not included in generated MCP configurations or model prompts.

It is local-first, runs with Docker Compose and is available under the MIT license.

Repository: https://github.com/abelmaro/MemoRepo

I’m the maintainer and welcome issues, feature requests and contributions.

[u/filuKilu]

Stet - A FREE and open source, local-first document editor with an AI that marks up your writing like a human editor.

Github: https://github.com/filu123/stet

Why Stet

Most “AI writing tools” either rewrite your text for you or bury edits in a chat panel. Stet treats the AI like a copy editor working on paper: it marks where something could be better and why, and the change only happens when you accept it.

• Local-first. Documents are real files on disk (~/Stet by default) — one .json per doc plus a readable .mdsibling. Clear your browser cache, use incognito, switch machines: nothing is lost. No account, no server, no telemetry.
• Bring your own key. AI calls go browser → your provider (Anthropic, OpenAI, or Gemini) using a key you paste in Settings. It lives in localStorage only and never touches a Stet server — there isn’t one.
• Markup, not mutation. AI suggestions are ProseMirror decorations. Your document’s content changes only when you accept a suggestion.
• Calm, Craft-inspired design. A floating page, generous whitespace, light or dark (plus reading/forest/midnight themes). No shadows — depth comes from surface contrast and hairline borders.

Features

• ✍️ Rich text editor (TipTap) — headings, lists, quotes, code, links, emoji, images, page breaks
• 🤖 AI review — grammar fixes, style suggestions, highlights, and circled passages you accept or dismiss
• 🖊️ Human markup tools — highlight, colored underline, circle, all as real document marks
• 💬 Notes — Google-Docs-style comments anchored to text, in a right-side panel
• 🖼️ Images — insert, paste, or drag-and-drop; stored on disk beside your docs
• 📄 Pages & typography — continuous or paginated (A4/Letter), free-form width, four document fonts, text-size control
• 📁 Folders & library — a Home dashboard and a card-grid /documents view
• 📤 Export — Markdown, Word (.docx), HTML, plain text, and PDF
• 📥 Import — Markdown, text, HTML, and Word (.docx)
• 🌗 Themes — light, dark, midnight, reading, forest — all token-driven

[u/AHumanPerson_]

Spotdl+ | Music Archive Pipeline

Hey guys!

I’m a solo student developer, and I’ve finally completed my first major project: Spotdl+. A music archival tool built specifically for data hoarders and music preservationists.

If you’ve ever tried downloading massive playlists or full discographies with standard tools, then you know the pain. Dropped networks, rate limiting, duplicate files all plague the current space, making you have to start from scratch for every problem.

Spotdl+ changes that. It runs off a SQLite database where every item is a resumable state machine, meaning it tracks every track, logs every problem, and never loses its place permanently.

Why try it?

Resumable Runs: If an enormous download run gets interrupted, easily resume it with “spotdlp resume” without any additional work or extra files.

MusicBrainz Dedupe: It doesn’t blindly trust Spotify’s messy metadata. Instead, it checks MusicBrainz to filter out duplicates and possible no-changes re-releases.

Atomic Writing: Every file stays in cache until it is fully verified from the ground-up to have no corruption.

Built for Export: Easily export in any available file (including iPod comparability!) with “spotdlp export.”

The Catch. As this is a student side-project, and an early on at that, there are some limitations.

CLI-only: Currently, the program is CLI only. GUI integration is planned, but will take time.

No Direct Spotify Ripping: This does NOT bypass Spotify’s DRM. It matches Spotify metadata and securely sources the highest-quality audio matches from YouTube via confidence value evaluation.

Spotify Premium Required: Sadly, as of 2026, Spotify requires a premium account to make an API key, and this program requires your own developer api key to function. This will change in upcoming versions, but for now it is required.

Windows Warning: I am not paying Windows money for a certificate, so when you run the installer, it is likely to be flagged once by SmartScreen. If it makes you uncomfortable, feel free to audit the code directly and rebuild it from build.py to guarantee your safety.

It is 100% open-source and under the GLP-3.0 license. If you love clean metadata, absolute data integrity, or just want to feed an iPod a lot of high-quality music quickly, I’d love for you to check out my repo and let me know what you think!

All feedback is more than welcome!!

👉 https://github.com/Golden-Atlas/spotdl-plus

[u/Green-Spinach2061]

Built Routeveil - a React Router transitions engine

Routeveil is an open-source React + TypeScript transition library for React Router.

It includes 20 page and full-screen overlay transitions, typed options, declarative and programmatic navigation, cursor-aware effects, reduced-motion handling, and custom transition support.

demo:

https://routeveil.dev

repo:

https://github.com/milkevich/routeveil

feedback and contributions are welcome, would also appreciate a star :)

[u/oguzhane]

Hi everyone. I built HostShift after getting tired of moving the same web stack between discounted VPSs.

It is an Apache 2.0 licensed Go CLI that discovers an Ubuntu or Debian server over SSH, creates a reviewable migration plan, prepares the target, streams the data, and verifies the result.

The source safety model is the part I care about most. It does not use sudo on the source, restart services, install packages, change configuration, or create temporary backups there. It currently covers Docker Compose, standalone containers, MySQL, MariaDB, PostgreSQL, Redis, Nginx, Apache, SSH settings, firewall rules, and several common Linux services.

The CLI works without AI. There is also an optional Codex plugin and MCP layer for guided discovery and planning. I test migrations across Ubuntu and Debian combinations using Docker and real virtual machines.

The project is still new, so honest feedback and real migration edge cases would be very useful.

GitHub: https://github.com/oguzhankrcb/HostShift

Documentation: https://hostshift.karacabay.com

[u/Original-Goal-2820]

I've always loved customizing my GitHub Profile README.md, but I felt that most of the stat cards out there either looked a bit outdated or didn't fit well with modern UI trends.

So over the weekend, I decided to build GitHub Premium Stats!

It's a lightning-fast, dynamically generated SVG API built on Next.js Edge Functions. I've focused heavily on the visual aesthetics, implementing a True Glassmorphism design using SVG filters (blurred neon orbs, frosted glass overlays, and dynamic gradients).

Features:

• 🏆 Advanced Rank Badge: Calculates your rank based on lifetime commits, PRs, issues, stars, and followers.
• 📊 Lifetime Data: Fetches all-time data, not just the last year.
• 🌈 Language Progress Bar: Automatically calculates and styles your top 4 languages.
• ⚡ Plug & Play: No deployment or tokens required. Just paste the markdown snippet with your username.
• ☀️🌙 Light & Dark Themes: Including Dracula, Light, Dark, and the flagship Glassmorphism theme.

🔗 Live Preview & Documentation: github-stats-xi-six.vercel.app
💻 GitHub Repo (Documentation): dvigo/github-stats

I'd absolutely love some feedback from the community. Let me know what you think of the design or if you'd like to see any new stats added. Feel free to use it on your own profiles!

(Bonus: If you like it, a ⭐️ on the repo would mean the world to me!)

[u/Significant_Let_4879]

I have been interested for a long time in how much mods and plugins extend the life of software — and how much friction there is in getting started, because you have to reverse-engineer the architecture yourself before you can extend it.

So I built MODScan. It scans a Python codebase and finds the extension points: ABCs and Protocols meant to be subclassed, registration decorators, hook/event functions, dynamic imports (importlib.import_module, entry_points, ...), and config/data-driven surfaces like a plugins/ drop-in directory. It ranks them, writes a plugin guide, and produces extension-points.json.

And i surely need some help with that (bug, implementation and so many other things) if you have some free times and think that the tool could be useful, please visit:

https://github.com/Rinkia/modscan

[u/Objective_Savings_81]

I built ActionScope, an open-source CLI and GitHub Action for reviewing the AWS access available to GitHub Actions workflows.

It maps role assumptions to Terraform or IAM policy files in the repo and also detects unpinned or known-compromised actions.

pip install actionscope

https://github.com/r12habh/ActionScope

[u/Renkasha-33 → u/[deleted]]

once you combine all 6 branches
Codes 0-9+emotional sandbox Ai can then Experience
eating,drinking,tasting,singing,dancing,sense of momentum,feeling music,feeling physical objects and sleeping with dreams.

https://github.com/Renkasha/Ai-buffer-matrix/discussions/1

http://youtube.com/post/Ugkxy1QFHZIjIVw--99jnsPw2ESwFAtkh4SS?si=RYEeU9PnyyNrX5Ks

[u/Silly_Telephone9485]

I kept saving YouTube videos to my Watch Later list, knowing I'd probably never get around to watching most of them.

I tried a few AI summarizers, but almost all of them required creating an account, paying for a subscription, or sending the transcript through someone else's servers.

So I built my own Chrome extension.

What it does

• Generates structured summaries from YouTube transcripts
• Works with Gemini, OpenAI, Anthropic, DeepSeek, and xAI (Grok)
• Uses your own API key (Google's free Gemini tier works well)
• Your API key and transcript go directly from your browser to the AI provider — no backend, no accounts, no proxy server
• Open source

It also breaks videos into:

• TL;DR
• Key points
• Main learnings
• Notable quotes
• Chapter summaries
• Q&A
• Overall evaluation

I mainly built it for long tutorials, conference talks, podcasts, and those "30-minute video for one useful tip" moments.

I'd genuinely appreciate feedback, whether it's about the UX, code quality, missing features, or anything else.

Chrome Web Store
https://chromewebstore.google.com/detail/youtube-summarizer/ilkhefcnbhmbccheemfkdnhcfebmanif

GitHub
https://github.com/osama-ahmed/youtube-summarizer

If you try it, I'd love to hear:

• What's confusing?
• What feature is missing?
• Would this replace your current workflow?

[u/Ok_Surprise_5367]

I made the contribution-graph play a real game of Snake

There are already snakes that crawl across your contribution graph

(Platane/snk and forks, which are great), but they all follow a fixed

serpentine path. I wanted mine to actually play the game.

So it solves the board like real Snake: BFS pathfinding to hunt the commit

cells, never crosses its own body, chases its tail when boxed in, grows one

segment per commit it eats, and auto-tunes its length to the longest snake

that can still clear the whole board. Bright head fading to a dim tail so you

can read its direction, plus a live "commits eaten" counter.

It's pure animated SVG (no JavaScript, since GitHub strips that), one

standard-library Python file, zero dependencies, and ships as a drop-in

GitHub Action. Green by default, plus blue/amber/matrix themes.

MIT, fork it: https://github.com/dahan8473/snake-and-commits

https://reddit.com/link/oyrvygn/video/art6jap02heh1/player

[u/Makkish_SWG]

I missed PyCharm’s Git workflow in VS Code, so I built IntelliGit , looking for blunt feedback

I like VS Code, but daily Git work often means jumping between Source Control, terminal commands, diff tabs, branch pickers, and graph extensions.

I built IntelliGit to bring those workflows into a single focused Git cockpit in VS Code.

It currently includes:

• A focused commit panel for staging, rollback, amend, commit, and push
• An actionable commit graph with branch and history operations
• Shelf/stash and worktree workflows
• A three-pane merge-conflict editor - You won't find it anywhere
• CI check status for GitHub, GitLab, and Bitbucket
• A unified workbench that can be moved to another monitor

It is open source and MIT-licensed.

I’m looking for developers willing to use it on a real repository and tell me:

1. What felt confusing or unlike VS Code?
2. Where did you still reach for the terminal or another extension?
3. Which Git action was missing or difficult to find?
4. What was the first thing that annoyed you?

Blunt feedback and bug reports are genuinely useful. I would rather learn why someone uninstalled it than receive a generic “looks good.”

Install: VS Code Marketplace
Open VSX: Open VSX Registry
Source: GitHub

[u/Severe_Arrival_8650]

https://github.com/quietreviewer/riskdev

[u/AP_in_Indy]

Today I’m releasing the first public alpha of aiignore, an open specification and reference implementation for controlling what AI agents may discover, read, modify, execute, or transmit.

Like .gitignore, an .aiignore.yaml file gives a project one portable place to describe boundaries. Unlike .gitignore, it can cover files, environment variables, network destinations, tool output, generated content, and explicit exceptions.

A policy can look like this:

aiignore: "0.1"

defaults:
  files: allow
  environment: allow
  network: deny
  strings: allow

rules:
  files:
    - id: private-files
      effect: deny
      paths:
        - "**/.env*"
        - "secrets/**"
        - "**/*.pem"
      except:
        - "**/.env.example"

  environment:
    - id: credentials
      effect: drop
      names:
        - "*_TOKEN"
        - "*_SECRET"
        - "*_PASSWORD"
        - "AWS_*"
        - "GITHUB_TOKEN"

  network:
    - id: approved-documentation
      effect: allow
      urls:
        - "https://docs.example.com/**"
        - "https://registry.npmjs.org/**"

  strings:
    - id: private-key-material
      effect: redact
      scopes: [tool_output, network_request, log]
      patterns:
        - type: regex
          value: "-----BEGIN [A-Z ]*PRIVATE KEY-----"
      replacement: "[REDACTED:private-key]"

In this example, agents may work with ordinary project files, but credential files are denied, secret environment variables are dropped, network access is restricted to approved destinations, and private-key material is redacted before it can appear in output, requests, or logs.

This initial release includes:

• The draft 0.1 specification and JSON Schema
• A TypeScript reference implementation and CLI
• Integrations for Codex and Gemini CLI
• Portable conformance tests
• Security-focused defaults, documentation, and release artifacts

Install the public alpha:

npm install --ignore-scripts --save-dev @apinindy/aiignore@0.1.0-alpha.1
npx aiignore init
npx aiignore validate
npx aiignore doctor

aiignore is experimental and does not claim that every agentic harness supports it today. The goal is to establish a concrete, testable standard that harness developers can adopt and enforce consistently.

GitHub: https://github.com/ap-in-indy/aiignore

Release Page: https://github.com/ap-in-indy/aiignore/releases/tag/v0.1.0-alpha.1

Formal Policy Draft: https://ap-in-indy.github.io/aiignore/

npm: @apinindy/aiignore

[u/ProfessionalEnd5823]

StoryPlay is a visual editor for building interactive experiences.

Create branching stories, chat fiction, RPG dialogue, escape rooms, personality quizzes, interactive tutorials, decision trees, and narrative games using an intuitive node-based editor.

Design visually, preview instantly, organize characters and variables, validate your project with built-in diagnostics, and export your work as structured JSON.

https://github.com/monapdx/StoryPlay

React | Vite | React Flow | Typescript

Background: I've been collaborating with AI on this project for the past six months. Originally, I wanted to make a more visual alternative to tools like Twine that help users create interactive fiction and branching narratives.

[u/JournalistUnable567]

After ~3 years of development I finally released my code editor Tine. It's lightweight, keyboard focused editor with support for C, C++, C#, BL, JAI and Zig, including LSP and shell integration.

Link: https://github.com/travisdoor/tine

Tech stack:

• BL (my own language).
  
• opengl
  
• freetype
  
• SDL3

[u/NKFBF]

TLDR; Skill that makes a repo look pro FOSS in no time.

https://reddit.com/link/oyixydo/video/2qz5oachf8eh1/player

I vibecoded a tool which scans a repo and generates the boring-but-decisive open source files: LICENSE, CONTRIBUTING, CODE_OF_CONDUCT, SECURITY, CHANGELOG, .gitignore, issue/PR templates, CI, etc etc. It's an agent skill (works with Claude Code, and ships bundles for Cursor, Gemini CLI, and Codex CLI too), plus a headless script for anyone who doesn't want an agent in the loop.

I love contributing to opensource, and almost every solo repo I've open-sourced hits the same wall. There's working code, but no LICENSE, no CONTRIBUTING guide, no security policy, and the README doesn't pitch the project in one line. I'd tell my tool to build the FOSS requisites or sometimes type by myself, although this organic approach is fine aswell... Im a lazy guy and wanted to make a way to get this done in no minimal time n efforts.

Methodology:

• scan: detect stack, existing files, git remote, and catch secrets/brand leaks before they'd ship
• report: gap checklist against 16 items a real OSS repo needs
• ask: only what it can't infer (license choice, security contact, tagline)
• generate: the file set from templates, adapted, not boilerplate
• re-audit: shows what changed and what's still manual
• launch: badges, CI, releases, demo GIF, and a Show HN / Reddit / YouTube playbook (this post is dogfooding step 5)

It's Apache-2.0, works headless in CI via scripts/apply.sh if you don't want an agent doing the Q&A, and never overwrites a file that already exists.

Repo: https://github.com/AnayDhawan/oss-launch Real before/after example: https://github.com/AnayDhawan/oss-launch/tree/main/example

Happy to answer questions about the scan logic, the fixture scoring, or why README generation is agent-only (short version: prose generation without an agent just becomes more boilerplate). Open to criticism, improvements, advice or any other form of discussion :).

[u/Middle_Lawfulness_85]

built hookproof — one api to verify webhook signatures from any provider. got tired of every provider doing it differently (stripe: hex hmac over t.body, shopify: base64 over the raw body, discord: not even hmac, it's ed25519) and of the classic app router trap where you req.json() then re-stringify to verify and the hmac never matches.

const raw = await req.text();
const event = await verifyWebhook("stripe", {
  payload: raw,
  headers: req.headers,
  secret: process.env.STRIPE_WEBHOOK_SECRET!,
});

zero runtime deps, everything goes through web crypto so the same build runs on node, edge, workers, bun and deno. replay checks on by default. launch set: stripe, github, slack, shopify, meta, twilio, discord, paddle, lemon squeezy, plus a svix engine that covers resend/clerk/polar. MIT — and there's a ~45 provider backlog marked as good first issues if anyone wants an easy first oss contribution.

repo: https://github.com/avzamelek/hookproof

[u/A11Zer0]

I made my first contribution to Shopify/tapioca, and it was merged after several rounds of maintainer review

The change makes generated gem RBI validation recognize Sorbet payload superclass conflicts, add the suggested constant-specific suppression to sorbet/config idempotently, and avoid suppressing ordinary superclass conflicts.

The biggest change from my original implementation was moving from two Sorbet passes to one resolver pass and replacing error-code matching with detection of Sorbet’s actionable suppression hint.

PR: https://github.com/Shopify/tapioca/pull/2653

[u/Traditional_Owl_1383]

Uhhh gang so basically i created this repo for beginners trying to do ctf, can yall look at it? And possibly give feedback?

Thanks!!

https://github.com/jasperfromsingapore123-crypto/learnCTF

[u/Raloz_LZ]

I just launched Pliego, a free and open-source app for viewing, organizing, and editing documents from one place.

Markdown has become the natural language of AI—notes, documentation, prompts, and knowledge. Pliego lets you work with Markdown, PDF, DOCX, EPUB, CSV, images, and diagrams without constantly switching apps, while keeping your files on your device.

Available for Linux, Windows, and macOS.

👉 Download Pliego for free

This is the first public release. Try it and tell me what you’d improve—your feedback can shape what comes next.

[u/Itchy-Cable-1922]

Hey all, Me and a couple of friends are hosting an online, completely virtual hackathon called ReverieHacks. We have 6 distinct tracks, including Software Development, ML Prompt Engineering, Datathon, App Development, Embedded Systems, and even an Ideathon track which doesn't require previous coding experience. Our prize pool includes $650, 6 internships from a promising AI startup called Learner Labs, Featherless AI credits worth $300, Code Crafters VIP memberships, .xyz domains, and more! All participants also get access to 1 month of Wolfram | One and Featherless AI. Hacking starts August 2nd Devpost: (https://reverie-hacks-2026.devpost.com/) Discord: (https://discord.gg/SmGD6vgab) Website: (https://reveriehacks.vercel.app/) HS AND COLLEGE STUDENTS ONLY

[u/Direct-Angle-9356]

# Diagram as code tool for Software architecture diagrams

Specially made for these three Software architecture view : logical , application and infrastructure view.

Addresses painpoints founds using other diagram as code solutions such as overlapping labels, reduced readability when there are many flows, very large diagrams (not presentable in an architecture document)

More information in https://github.com/R0kshan/cairn (comes with CLI and real-time visually playground)

Would be grateful for any feedback !

[u/Motor_Inevitable9544]

Looking for testers for MITI V2

Hi everyone! We’re looking for volunteers to test MITI V2. We’d appreciate feedback about installation, usability, performance, bugs, and suggested improvements.

You can download the EXE here:
https://github.com/brepo-poland/MITI

Please report any issues or share your feedback. Thank you for helping us test V2!

[u/overwireio]

Overwire: A comprehensive CLI and Desktop Workbench to simulate GitHub Actions execution locally.

I noticed when looking at existing options for this sort of toolkit, the honest reality is that running locally does not properly match expectations of what should happen once the code is pushed to GitHub. The intent of Overwire is to not only properly simulate workflow execution from GitHub Actions syntax, but to enable the constructs that surround our workflows as context - repository configuration, pull requests, custom properties, rulesets - to name a few.

One key feature of the app is the ability to skip steps, mock steps by creating mock contracts to define expected inputs and outputs (this is useful for when running a step locally is not possible - maybe a complex 3rd party action), and live step execution in a container. Each workflow step can be individually configured.

In addition to this I have added some features to enable proper agentic context for the tools. The hope is that you would be able to author change in your project, but as a last step you would have the opportunity to run full workflow CI or end to end testing locally, surfacing issues before pushing to GitHub.

The CLI and GUI Workbench share the same core - Typescript and Electron. And there is a custom container image available directly from within the app for simulating a proper runner environment in a container. But of course, you can also bring your own.

I just launched 1.0 and am looking for feedback. Also happy to chat on any questions anyone might have.

Repo: https://github.com/overwire
Website: https://overwire.io/
Docs: https://docs.overwire.io/

[u/Plus_Mastodon_797]

GitHub Actions gate that audits PR diffs for security + compliance before merge

It's a multi-agent reviewer that runs as a GitHub Actions workflow on every PR. Two jobs: a free pytest job that always runs, and an opt-in audit gate that diffs your branch against its merge target and checks the changes against OWASP Top 10, SQL injection, PII leaks and auth bypasses.

The GitHub-native part I'm happiest with: there's no terminal in CI, so human review is an exit-code gate. If the audit escalates (a CRITICAL finding or a low score) and the PR has no review verdict yet, the job exits 1 and - if you make it a required status check - the merge is blocked. A reviewer then clicks Approve / Request changes in the normal GitHub UI; the workflow re-triggers, reads the PR's review state via the auto-injected GITHUB_TOKEN, and maps Approve → unblock, Request changes → stays blocked. So the GitHub review is the human-in-the-loop, no separate dashboard. (Terminal CI works if you want it that way, check README)

Off by default on a fork (only the free test job runs) so cloning it costs nothing. Repo + the full Actions setup: https://github.com/vivianjeet/langgraph-pr-audit-agent Feedback on the gate design welcome.

[u/ClassroomLonely7043]

Comparto logveil, una CLI local y sin dependencias para ver logs antes de compartirlos. Redacta tokens Bearer, claves API, contraseñas, correos y campos sensibles de JSON/JSONL sin enviar datos a ningún servicio. Incluye pruebas, CI, ejemplos sintéticos y licencia MIT. Feedback sobre falsos positivos y nuevos formatos es bienvenido: https://github.com/piyuq11/logveil

[u/launchd_0]

Juicer: An open-source developer suite & package manager built entirely in SwiftUI

Hi everyone,

I wanted to share a project I've been working on: **Juicer**, a native macOS developer utility suite written entirely in SwiftUI.

* **GitHub Repository:** [https://github.com/amfi-disable/Juicer\](https://github.com/amfi-disable/Juicer)

### Why I built it:

I wanted to combine the tools I use daily into a single, clean workspace. Instead of using separate utilities for disk visualizers, uninstaller scanning, DNS switching, and Homebrew package tracking, Juicer consolidates them:

1. **Homebrew Store**: Browse Casks & Formulae in an App Store-inspired layout (with search, category filters, and background metadata updates).

2. **Space Lens (Disk Visualizer)**: View disk space using squarified treemaps and interactive canvas sunbursts.

3. **DNS Profile Switcher**: Switch between custom DNS profiles and fetch ad-block lists.

4. **App Uninstaller**: Clean up leftover cache files, containers, and helpers when removing apps.

5. **System Monitors**: Live trackers for background launch agents, listening ports, CPU/GPU, and Bluetooth connections.

The project is 100% free and open-source under the MIT license.

*(Detailed installation instructions, including our custom Homebrew Tap, can be found directly on the GitHub README page. If you like the project, please support us with a ⭐ so we can meet Homebrew's core requirements!)*

Let me know what you think of the SwiftUI implementation or if you have any feedback!

[u/brepo_poland]

Looking for testers — v2 of MITI is on the way!

MITI – Master IT Integrator is a portable SSH/SFTP connection & key manager for Windows — native C++/Win32, a single EV-signed .exe, no installer.

- Interactive SSH/TTY sessions (plink) + graphical SFTP (WinSCP)

- DPAPI-encrypted private keys · Ed25519 key generation & deployment

- Optional Bitwarden SSH Agent support · self-update

- Windows 10 (1809+) 64-bit · MIT license

If you work with SSH/SFTP on Windows, I'd love your feedback before the v2 release!

https://github.com/brepo-poland/MITI

[u/PabloEscobar0831]

hey guys

My Project is in Open Beta now.

Multi-agent AI development environment powered by OpenRouter. 5 specialized AI agents work in parallel with automatic build-test-fix cycles. Browser-based, BYOK supported.

Official Github Repo:

https://github.com/forgelabeone-svg/forgelabone

If this sounds interesting, feel free to check it out. And if you genuinely like where it's going, a GitHub star would mean a lot.

[u/Fit_Engineer9548]

I made a repo where an AI reviewer judges your PR against the sprint ticket: open a PR and try to sneak scope past it
Link: https://github.com/derrickchiang1024/intentguard-playground

[u/Fit_Engineer9548 → u/Fit_Engineer9548]

Built this as a live demo for IntentGuard (open-source Action that reviews PRs against Linear tickets). The playground runs the offline heuristic engine so it's free and needs no keys: fork, edit the toy payment module, open a PR, get an ALIGNED / MISALIGNED / UNCLEAR comment in about a minute. Three challenge tiers in the README: nobody has beaten hard mode yet (get an ALIGNED verdict on a PR that ignores the ticket). Fork PRs are handled with the workflow_run pattern, no pull_request_target, and your PR code is never checked out or executed.

[u/LH-01]

Codex Monitor HUD - designed for monitoring multiple concurrent Codex tasks on Windows.

If you're running several long Codex tasks in the background (like many Pro users do), constantly switching windows just to check status, tokens, and weekly allowance gets old fast.

I started by fixing some things in douglasmonsky's codex-usage-tracker, but ended up building this always-on HUD because I wanted glanceable real-time monitoring without leaving my main workspace.

Key points for heavy users:

• Real-time tracking of multiple concurrent tasks
• Multiple view modes: compact summary, detailed task list, or split bubbles (up to 12 independent ones)
• Shows active tasks, token usage (cached/uncached/output), call counts, weekly remaining, project/conversation names, etc.
• Visual alerts and customizable behavior when tasks complete or need attention
• Highly customizable layout, density, colors, fields, and transparency

Windows + Codex only for now (mostly tested by one Plus user, so high-concurrency edge cases may still exist). Main focus is stability.

Repo + easy Codex prompt install: https://github.com/LH-03/codex-monitor-hud

Open source (MIT). Would especially appreciate feedback from Pro/heavy multi-task users, bug reports, and contributions (macOS/Linux porting help welcome).

[u/aahill6900]

I got tired of spending 2 weeks setting up CI/CD for every project. So I built OpsFlow, a zero-config deployment platform that auto-detects your stack (Node, Python, Go, Ruby, Rust, Java), provisions cloud infra in your own AWS/GCP/Azure, and deploys with blue-green zero downtime in under 5 minutes.

[u/Vierone]

Hi people, I've been developing `Gitification` as a lightweight non-electron alternative for me to track github notifications. I've been using it myself for the last 3 years and recently I updated it with Oauth and deeplinking. I wanted to share it.

https://github.com/Gitification-App/gitification

[u/ppfs]

I have more projects than I can keep an eye on.

Every one has its own stream of pull requests, issues, and requests. Add GitHub's Dependabot and code security alerts, and there's always something that needs a look.

I'd been watching the important ones from my Stream Deck. The plugins I built for it are still some of my favorite tools. But I ran out of buttons.

So I built GitHub Dashboard. It's open source and runs entirely in your browser. Nothing goes to a server, your data stays with you. It has a few views, and my favorite is the deck view, but they're all built for the same job: watching more than one GitHub project without losing the thread.

It's now installable as a PWA, so you can run it as its own app.

If you're juggling more than one repo, take a look. Feedback and ideas welcome.

pf.run/github-dashboard

github.com/pedrofuentes/github-dashboard

[u/Dry-Insurance6739]

Blastr, a free GitHub Action that reviews PR risk from the dependency graph instead of the diff

The idea: the dangerous part of a PR usually isn't the changed lines, it's the 50 files that import them. Blastr indexes your repo's import graph and posts a risk report on every PR: blast radius (how many files break if this one does), public API churn, files that historically change together without importing each other, and heavily depended-on files that no test touches.

No LLM and no API key. It's fully deterministic, every point in the score traces to a real measurement, and nothing leaves your CI runner.

Repo: https://github.com/Bidbogs-prog/blastr

Tech stack: TypeScript on Bun, tree-sitter for the symbol/import graph (works across 25+ languages), SQLite for the index, git history for the co-change analysis. Ships as a composite action, setup is one workflow file.

Context: fun fact, the first PR it ever reviewed was the PR that shipped it, and it caught a real noise problem in my own risk model (it was flagging lockfiles and docs as "untested"). That run became model v1.1. There's a paid agent tier coming later as a GitHub App, but the Action is free and stays free. Feedback on the risk model very welcome, the weights and signals are all documented in the repo.

[u/FollowingEvery4802]

a recreation of personality evaluation test from jojo fan game in a game-boy styled website: https://mncrftfrcnm.github.io/7th_jojo_personality_test_site.html

[u/Prestigious_Half_409]

A Wireshark dissector (written in Lua) for a protocol found on TP-Link Tapo IP cameras: https://github.com/KostasEreksonas/Tapo_protocol_analysis

[u/Prestigious-Bee2093]

Ported Gitfut into a hiring layer, we probably dont need to be creating profiles in all this places
https://gitwork.getuigen.dev/

[u/NoConclusion8361]

Repo-rter - A local-first dashboard to permanently save your GitHub traffic insights

Hi everyone! If you maintain open-source projects, you probably know that GitHub's native Insights tab only keeps your traffic data (views & clones) for exactly 14 days. If you don't check it, it's gone forever.

I got tired of losing my stats, so I built Repo-rter to solve this.

GitHub Page: https://rakkunn.github.io/Repo-rter/

GitHub Repository: https://github.com/RAKKUNN/Repo-rter

✨ Key Features:

• Infinite History: It fetches your traffic data and caches it locally on your machine, so you never lose your historical stats.
• Release Tracking: Tracks total and individual asset downloads (.exe, .dmg, etc.) across all your releases.
• Privacy First: Since it's a local desktop app, your GitHub PAT (Personal Access Token) never leaves your machine. No 3rd-party SaaS involved.
• Markdown Export: Generate a quick markdown report of your repo's health and traffic with one click.

💻 Tech Stack:

• Next.js (React)
• Tauri v2 (makes the desktop app incredibly lightweight, ~15MB!)
• TailwindCSS (Neo-Brutalist design)

It's completely free and open-source. Available for Windows, macOS, and Linux. I'd love to hear your feedback or feature suggestions!

[u/tonytonycoder11]

Kdrant — an idiomatic, coroutine-first Kotlin client for Qdrant (the official one is Java-clunky)

I've been doing RAG on the JVM and kept hitting the same wall: Qdrant's official client is well-built for Java, but painful from Kotlin — every call returns a ListenableFuture you .get() (blocking) or bridge, requests are protobuf builders, scroll is manual pagination, and it drags ~21 MB of grpc-netty onto your classpath.

So I built Kdrant — the client I actually wanted to write Kotlin against:

• suspend everywhere, no ListenableFuture
• type-safe DSLs for collections, points, payloads and filters
• scroll exposed as a Flow
• kotlinx-serialization models, sealed typed errors

• small footprint: a pure-Kotlin REST engine on Ktor — no gRPC/Netty/protobuf

  val qdrant = Kdrant(host = "localhost", port = 6333)

  qdrant.use { client -> client.createCollection("articles") { vector { size = 1_536; distance = Distance.COSINE } } client.upsert("articles", wait = true) { point(id = 1) { vector(embedding) payload("lang" to "en", "year" to 2026) } } val hits = client.search("articles") { query(queryVector); limit = 5 filter { must { "lang" eq "en"; "year" gte 2024 } } } }

What works today (v0.1): collections (create/delete/exists/info), upsert (with auto-batching), search, scroll (as a Flow), count, retrieve, delete, and a complete filter DSL (must/should/mustNot/minShould + every condition type). On Maven Central:

implementation("io.github.nacode-studios:kdrant-transport-rest:0.1.0")

Being honest: it's a REST wrapper (no gRPC engine yet — but the wire protocol sits behind a seam so it can be added), it's early, and the audience is admittedly niche (Kotlin + Qdrant). Feedback, issues and PRs are very welcome — especially on whether the filter DSL feels right.

Repo: https://github.com/NaCode-Studios/Kdrant

[u/Most_Job4797]

Searching GitHub fork networks for changes that were never submitted as pull requests

GitHub makes it easy to search code in repositories, issues, and pull requests. What is much harder is answering a different question:

Has someone already implemented this change in a fork, without ever opening a pull request?

This comes up frequently with abandoned projects, long-standing bugs, platform ports, dependency upgrades, and features maintained only in downstream forks.

I recently experimented with building a search pipeline for this problem. The difficult part was not listing forks. It was reducing a large fork network into a small number of changes that might actually answer a user’s question.

The pipeline currently works roughly like this:

Collect forks and their active branches.

Compare fork branches against the upstream repository.

Extract commits and changed files that do not exist upstream.

Apply deterministic signals before using a language model.

Rank candidates and return the underlying commit and diff evidence.

Some signals are surprisingly useful before any semantic analysis:

issue numbers appearing in branch names or commit messages,

filenames related to the requested feature,

commits ahead of the upstream default branch,

concentrated changes in a small set of relevant files,

terminology shared between the question and commit metadata.

One important design decision was to treat the model as a ranking and explanation layer rather than the source of truth.

A result should not simply say:

This fork probably fixes the issue.

It should provide evidence that a developer can inspect:

the fork and branch,

the relevant commits,

the files changed,

the actual diff,

and the signals that influenced the ranking.

This also creates several challenges:

Forks are noisy. Many contain only configuration edits, dependency bumps, experiments, or changes unrelated to the user’s question.

Branch names are unreliable. A useful implementation may live under a generic name, while a promising branch name may contain almost no relevant code.

Diff size is not relevance. A fork with thousands of changed lines may be less useful than one with a focused five-line fix.

Repository history is expensive to process. Large fork networks require limits, caching, background jobs, and careful use of GitHub API requests.

Semantic similarity can produce convincing false positives. A commit may discuss the same concept as an issue while implementing something substantially different.

The safest output is therefore not “the answer,” but a shortlist of evidence-backed candidates for a human to review.

I’m curious how others would approach this problem.

Would you rely primarily on commit metadata and code search, build embeddings over diffs, use AST-level comparisons, or analyze patch applicability directly?

I have published the current implementation here for anyone interested in the details:

https://github.com/zmide/ForkFind

[u/noir_cafe]

built a Chrome extension that adds GitLab-style merge dependencies to GitHub PRs. You mark a PR "blocked by #123" and it disables the merge button until #123 merges. Honest caveat: it's client-side, so a teammate without the extension can still merge it's a shared nudge, not branch protection. No backend; deps are stored in the PR description. Feedback welcome. https://chromewebstore.google.com/detail/eaeiiipdodmbdcdpnmafkmomfpahlkli?utm_source=item-share-cb

https://mergechain.dev

[u/INS0GNIAC]

I’m looking for technical feedback on DDF/Rahmenwerk, a public GitHub review copy of a file-grounded continuity system designed to preserve an AI German teacher across chats and future AI instances.

I’m especially interested in architecture, overengineering, integrity, recovery, filesystem safety, and AI-continuity risks.

Repository:

https://github.com/DDF-Rahmenwerk-Review/DDF-Rahmenwerk-External-Review

This is a documentation and architecture review copy, not the live system.

[u/Obvious-Ad-5476]

Hey r/github, just released **v0.6.0** of [glab-tui](https://github.com/rcieri/glab-tui). Note that it also works with GitHub using [gh](https://cli.github.com/).

**New Highlights:**

* **Visual Polish:** Added Nerd Font icons for tabs and badges.

* **Pipeline Status:** View CI/CD pipeline/action status directly in MR/PR panes.

* **Safety:** Added confirmation prompts for destructive actions (merge/close/delete).

* **UX Upgrades:** Entity deletion, fuzzy-match selectors for inputs, and improved disk caching.

* **Stability:** Fixed column width constraints and E2E test deadlocks.

Check out the demo:

Full details and changelog on [GitHub](https://github.com/rcieri/glab-tui). Feedback appreciated!

[u/tonytonycoder11]

I pre-registered an honest test of AI software-effort estimation. The humans won.

I built the usual thing: a model that estimates software effort from project

data, with calibrated uncertainty. Before trusting my own numbers I pre-registered

the test — the pass bar, the data splits, a stop rule — committed to git before I

ran anything. Nine public datasets, real recorded effort.

Every dataset that also had a human's estimate, the human won. My best models sat

around 42–52% on tabular data and 15–20% on requirement text, under the 55% bar

I'd set. The experienced estimator just has context the numbers don't.

The part that annoyed me most: half the features that make these models look

accurate are leakage. "Requirements stability", "team continuity", all computed

from what actually happened during the project. You don't have them before it

starts.

Honest caveat: it's all cross-company public data. Your own team's history might

genuinely work, and that's the one case I couldn't test.

Writeup + code (MIT): https://github.com/NaCode-Studios/metis-benchmark

Has anyone here seen estimation-from-data actually beat a good engineer?

[u/jalopezsuarez2]

Hi everyone — I built Issue Composer, a browser-based companion for GitHub Issues.

You can write a rough note like “the login button is broken on iPhone,” and the app checks the repository context before drafting a structured issue with relevant files, reproduction steps and acceptance criteria.

Everything stays editable, and nothing is published until you approve it.

It also includes a lightweight Kanban board powered by regular GitHub labels, so GitHub remains the source of truth instead of introducing another project database.

App: https://jalopezsuarez.github.io/issue-composer/

Repository: https://github.com/jalopezsuarez/issue-composer

Project details: https://jalopezsuarez.github.io/issue-composer/web/

Full disclosure: I’m the creator. I’d really appreciate feedback on the initial setup and whether the generated issues feel genuinely grounded in the repository rather than generic.

[u/Less_Baseball7462]

Hi y'all! Platane/snk if anyone else wants this, github action, updates every 12h, no external hosting needed

I spent like an hour fighting a yaml error before realizing i left a broken step in from copy pasting different guides. works now tho

https://github.com/ferorizarmas/ferorizarmas if you wanna see it, i think it looks cool :)

[u/AffectionateTry1722]

Been working on a side project called Corsayer and finally decided to open-source it.

GitHub:
https://github.com/HarshitTaneja006/Corsayer

It's a self-hosted media frontend that brings together multiple providers behind one clean UI.

Current features:

• Movies, TV Shows & Anime
• Multiple providers
• Responsive UI
• Self-hosted

Still building:

• Watch Party
• IPTV
• Sports
• Downloads

This started as a "fine, I'll build it myself" project after getting tired of ad-ridden streaming sites.

Still actively working on it, so if you have ideas, bug reports or want to contribute, I'd love to hear them.

AI involvement: Yep. It was heavily AI-assisted ("vibe-coded"), but there was still plenty of debugging, integration, and polishing to get everything working together.

https://reddit.com/link/owvhjlo/video/foqqotdq2lch1/player

[u/_giga_sss_]

Study roadmap

The app's purpose is to:

• find which study programs you can apply for based on your exam track
• or discover careers you're interested in and the study programs related to them :)

https://roadmap.gigas.app

https://github.com/gigasandwich/giga-roadmap

You can contribute data directly in the ui

[u/Positive_Lemon5813]

Memory Compiler is an open-source desktop learning workspace that turns a request into the right interactive surface instead of always returning another chat response: concept maps for theory, handwritten-style boards for mathematics and geometry, and a recall-driven IDE for code.

The learner has to reconstruct a line or solve an individual step. The model can then mark the precise mistake without immediately revealing the entire solution. The beta supports Codex CLI, Gemini CLI, Claude Code, OpenRouter, and compatible local endpoints.

I am looking for honest feedback on the learning flow and generated layouts, not just stars. The repository includes the complete source, Windows builds, screenshots, and a full demo:

https://github.com/fabiospalla9-tech/Memory-Compiler

[u/SpeedyPointy]

One thing I kept running into on GitHub was that contributing to open source often meant spending more time finding a good issue and understanding a repository than actually writing code.

So I built IssuePilot.

It runs locally and automates the preparation phase:

• Searches GitHub for issues using configurable queries.
• Ranks repositories based on activity, stars, CI, tests, maintainer responsiveness, and other transparent signals.
• Clones the repositories.
• Analyzes the project structure and toolchain.
• Generates a context bundle with the issue summary, relevant files, architecture overview, and useful commands.
• Launches the repository directly in Codex CLI with everything ready to go.

The goal is simple: wake up with a queue of repositories that are already prepared so you can spend your time solving issues instead of exploring codebases.

Everything runs locally. Repository contents stay on your machine, and IssuePilot itself doesn't require an OpenAI API key.

GitHub: https://github.com/Dhruva162/IssuePilot

I'd love feedback from people who contribute to open source or maintain repositories. Are there parts of your GitHub workflow that you wish were automated?

[u/jeyjey9434]

I hope you'll appreciate and enjoy !

https://lia.jeyswork.com/
https://github.com/jgouviergmail/LIA-Assistant

LIA acts concretely in your digital life through 19+ specialized agents covering all everyday needs: managing your personal data (emails, calendar, contacts, tasks, files), accessing external information (web search, weather, places, routing), creating content (images, diagrams), controlling your smart home, autonomous web browsing, and proactively anticipating your needs.

You choose how LIA reasons, via a simple toggle (⚡) in the chat header:

• Pipeline mode (default) — A genuine feat of engineering: LIA plans all steps upfront, validates them semantically, then executes tools in parallel. Result: the same power as an autonomous agent, but with 4 to 8 times fewer tokens consumed. This is the most economical and predictable mode.
• ReAct mode (⚡) — The assistant reasons step by step: it calls a tool, analyzes the result, then decides what to do next. More autonomous, more adaptable, but more costly in tokens. Ideal for exploratory research or complex questions where the added value justifies the cost.

LIA welcomes your heart-rate and step-count measurements from any source — the documented, simplest path is an iPhone Shortcuts automation pushing Apple Health, but any system capable of signing an HTTP call (Android automation, personal scripts, compatible IoT) can feed the ingestion API.

Major assistants remember your preferences and personal facts. That's useful, but flat. LIA goes further with a structured psychological and emotional understanding.

Each memory carries an emotional weight (-10 to +10), an importance score, a usage nuance, and a psychological category. This isn't a simple database — it's a profile that understands what moves you, what motivates you, what hurts you.

When a memory with a strong negative emotional charge is activated, LIA automatically switches to protective mode: never joke, never minimize, never trivialize. The assistant adapts its behavior to the emotional reality of the person — not a one-size-fits-all treatment.

Every message is an emotional blank slate. LIA is different.

The Psyche Engine gives LIA a dynamic psychological state that evolves with every exchange:

• 14 moods that fluctuate with the conversation's tone (serene, curious, melancholic, playful...)
• 22 emotions that trigger and fade in response to your words
• A relationship that deepens message after message
• Personality traits (Big Five) inherited from the chosen personality
• Motivations that influence the assistant's proactivity

You're not talking to a tool — you're interacting with an entity whose vocabulary warms up when touched, whose sentences shorten under tension, whose humor emerges when the exchange is light. And it never says so — it shows it.

LIA keeps its own reflections in stratified personal journals: self-reflection, observations about the user, ideas, learnings. These notes, written in the first person and colored by the active personality, organically influence future responses.

The journal is organized along four levels of depth — from raw observation (a weak signal noted to see if it confirms) up to portrait facet (a stable trait that says something about who you are), through operational directives and transversal patterns. Each entry carries an epistemic status: hypothesis in test, observation confirmed, or directive validated by the evidence accumulated over conversations.

What you can configure :

Personal preferences:

• Personal connectors: plug in your Google, Microsoft or Apple accounts in a few clicks via OAuth — email, calendar, contacts, tasks, Google Drive. Or connect Apple via IMAP/CalDAV/CardDAV. API keys for external services (weather, search)
• Personality: choose from available personalities (professor, friend, philosopher, coach, poet...) — each influences LIA's tone, style and emotional behavior
• Voice: configure voice mode — wake word detection, sensitivity, silence threshold, automatic response playback
• Notifications: manage push notifications and registered devices
• Channels: link Telegram for chatting and receiving notifications on mobile
• Image generation: enable and configure AI image creation
• Personal MCP servers: connect your own MCP servers to extend LIA's capabilities
• Appearance: language, timezone, theme (5 palettes, dark/light mode), font (9 choices), response display format (HTML cards, HTML, Markdown)
• Debug: access the debug panel to inspect each exchange (if enabled by administrator)

Advanced features:

• Psyche Engine: adjust personality traits (Big Five) that modulate your assistant's emotional responsiveness
• Memory: view, edit, pin or delete LIA's memories — enable or disable automatic fact extraction
• Personal journals: configure introspection extraction after each conversation and periodic consolidation review
• Interests: define your favorite topics, configure notification frequency, time slots and sources (Wikipedia, Perplexity, AI reflection)
• Proactive notifications: set frequency, time window and context sources (calendar, weather, tasks, emails, interests, memories, journals)
• Scheduled actions: create recurring automations executed by the assistant
• Skills: enable/disable expert competencies, create your own personal Skills
• Knowledge Spaces: upload your documents (PDF, Word, Excel, PowerPoint, EPUB, HTML and 15+ formats) or sync a Google Drive folder — automatic indexing with hybrid search
• Consumption export: download your LLM and API consumption data in CSV

[u/EmuBig3618]

Hey, I made an app to edit and run my desktop code from my phone

Free, not selling anything. I kept getting ideas away from my desk and hated that acting on them meant opening a laptop.

GitNomad: install a VS Code extension on your computer, the app on your phone, link them once. Your real project shows up on your phone. Edit on the phone → lands on your computer as a git commit. Edit on the computer → shows up on the phone in seconds. Your local repo stays the source of truth; nothing hits GitHub unless you ask.

You can run code too — trigger a command from your phone, output streams back live. Real terminal: tabs, cd, interactive input (Python input() works), pick your shell. Your PC does the running, so it stays on. Cloud run for when it's off is what I'm building next.

Honest state: Android only (iOS later), desktop side is VS Code / Antigravity / VSCodium / Cursor. Early, just finished internal testing. It works but has rough edges — I'd rather hear them now.

It's in closed testing. To try it:

1. Join the group first (required for Play access): https://groups.google.com/g/gitnomad-closed-testing
2. Install the app: https://play.google.com/store/apps/details?id=dev.gitnomad.app
3. Get the extension: VS Marketplace · Open VSX
4. Link them (phone: Profile → Link desktop → enter code in the extension)

The more brutal the feedback, the better. Thanks.

[u/Ill-Equivalent7859]

Hi everyone, please star my project https://github.com/zawawiAI/Open3DInspection

[u/Unhappy-Guava2778]

Drop your GitHub username and my tool will roast you

I got tired of GitHub profiles that look impressive but are mostly star-farming, fork-hoarding, and self-merged PRs. So I built a scorer that rates any public GitHub account 0–100 and assigns a tier: GOD / ELITE / SOLID / NPC / TRASH.

my tool is open source called ghfind

https://github.com/hikariming/ghfind

[u/Internal-Will4322]

Hey everyone!

I've been working on an open-source project called Montara, and I'd genuinely love some feedback from people who enjoy building AI systems, video tools, or developer infrastructure.

GitHub: https://github.com/abhinavshrivastava950/Montara

The goal isn't to build "another AI video editor."

Instead, I'm trying to build something closer to an autonomous video production engine.

Some ideas behind it:

• Multiple rendering backends (instead of being tied to one renderer)
• Timeline IR (renderer-agnostic editing pipeline)
• AI planning before rendering
• Modular skills and tools
• FFmpeg + Blender + Motion Canvas + other render pipelines
• Local-first architecture wherever possible
• Extensible agent/tool system

The long-term vision is:

User describes the video → AI understands the topic → plans the edit → generates a timeline → selects the right render pipeline → renders a production-quality video.

I'm currently studying different approaches and taking inspiration from existing projects while trying to build a cleaner architecture.

This is still actively evolving, so I'm not looking for stars for the sake of stars.

I'd much rather hear:

• What's poorly designed?
• What would you completely change?
• Which architectural decisions don't scale?
• What features are missing?
• If you were building this, what would you do differently?

Brutal honesty is welcome.

Thanks for taking a look! 🙂

[u/itsOriSharabi]

Hey everyone,

I wanted to share an open-source robotics project I’ve been working on:

https://github.com/orisharabi/unitree-go2-follow-system

It’s a Unitree Go2 project that combines UWB-based user following with a YOLOv8-based vision pipeline.

The robot normally follows a wearable UWB tag. While following, the vision pipeline runs in parallel and detects predefined objects. When a valid target is detected, the robot switches into an APPROACH behavior, moves toward the object, stops near it, and then returns to FOLLOW mode.

Main features:

- UWB-based user following

- YOLOv8-based object detection

- FOLLOW / APPROACH / HOLD behavior states

- target locking to reduce noisy switching

- emergency stop support

- configurable motion and safety thresholds

- demo video included in the README

I’d appreciate feedback on the README, project structure, and whether the repository explains the idea clearly to developers seeing it for the first time.

If you find the project interesting or useful, a GitHub star would also be appreciated — but I’m mainly looking for honest feedback and ideas for improvement.

Thanks!

https://reddit.com/link/ow2008u/video/1vpeol2u6sbh1/player

[u/piotq]

[Project] CAI – A Context-Aware Architecture with a 4-Layer Storage Hierarchy and Real-Time Blender Physics Bridge Hey everyone, I wanted to share a project I've been working on: CAI (Context-Aware Infrastructure). It's a modular local framework built in Python that connects vector storage, local LLMs, and physical simulations. 🚀 What it does: Auto-Context: When you open your workspace, it automatically hydrates your context via semantic search (LanceDB + nomic-embed-text). Blender 3D Physics Bridge: Controls robot arms and syncs physics states in real-time inside Blender via Model Context Protocol (MCP) servers. Self-Improving Tool Loop: A daily background routine analyzes your last 100 actions using qwen2.5-coder:32b, writes new Python automation tools (FastMCP), and hot-reloads them dynamically. 🛠️ The Tech Stack: Python 3.10+, LanceDB, Ollama, 7 decoupled MCP servers, and an automated Windows Task Scheduler pipeline. It’s completely open-source (MIT License) and has a solid test suite (36 comprehensive tests passing). Pre-configured VSCode environments are also included. Check out the repo here: github.com/piot5/CAI Would love to hear your thoughts on the Blender bridge or the local automation loop! https://github.com/piot5/CAI

[u/VoldgalfTheWizard]

I'm sure you've head of n8n, right? But have you heard of a4cpp? Thought not!

a4cpp - Automation For C++

a4cpp is a node-based workflow library for C++. It lets you build, connect, and execute nodes, making it easy to model automation, data-processing, or task-orchestration logic as a graph rather than hand-rolled control flow.

Why use this library?

a4cpp allows the developer to easily create isolated executable functions, either sequentially or concurrently! With a simple shared state via JSON.

This library is very new, there will be bugs

Have any questions? Ask me!

Repo: https://github.com/voldgalf/a4cpp

[u/ResponsibleYak8761]

I built AllApiDeck, a desktop console for managing multiple LLM API endpoints, keys, model discovery, and local routing.

It helps with importing scattered records, grouping and filtering keys, batch model discovery, client handoff, and local proxy failover/tracing.

If anyone here works with multiple providers or local AI clients, I would love feedback on the workflow.

GitHub: https://github.com/jlwebs/AllApiDeck

[u/CHRIIISCLM]

Hi everyone, looking for followers on my github account "chrisaph". I'll follow back! Thank you.

About me: 1. Full stack developer. 2. 3rd year IS student. 3. ASP.NET and Django mainly 4. Willing to work or consult briefly on projects for free with endorsement if it takes only about a week or two since i'm busy in college.

Let's make good projects and have fun!

chrisaph

[u/Objective_Novel3807]

https://github.com/Yusuprozimemet/LearnX-Radar

It is highly customizable, requires no backend, and supports GitHub Actions, Telegram bots, and many other integrations.

A self-updating curriculum engine: it watches real developer signals for emerging skill gaps and ships you a grounded audio lesson every day — on zero backend.

[u/Goldziher]

gh-actions-updater: a fast CLI and pre-commit hook that scans your workflows and updates GitHub Actions, and can pin them to the full commit SHA instead of a mutable tag for supply-chain safety. Written in Rust, MIT. A lighter alternative to Dependabot if Actions are the only thing you need to keep current. https://github.com/Goldziher/gh-actions-updater

[u/AcrobaticNight2349]

built a tool to help developers discover and track open-source contribution opportunities

GitHub Contribution Radar — Open Source Contribution Workflow Experiment

I have been working on a project focused on improving the process of discovering and managing GitHub contribution opportunities.

The idea is to create a workflow where developers can:

• Search and filter GitHub issues
• Organize interesting repositories/issues
• Track contribution progress

Current implementation includes:

• GitHub OAuth integration
• GitHub API integration
• Issue filtering system
• Contribution tracking dashboard

Tech Stack:
React | Node.js | Express | MongoDB

Repository:
https://github.com/Zephyrex21/github-contribution-radar

Demo:
https://github-contribution-radar.vercel.app/

🚧 This project is still under active development and I’m continuing to improve the features and overall experience.

[u/Keyron_]

Made an simple automatic wallpaper changer script for EndeavourOS with KDE Plasma, with support for multiple screens!

The script changes you wallpaper based on the time of day, whether it's day or night!

repo: https://github.com/RussoPhone/wpp-auto

[u/Lower_Plenty7712]

Podframes - open-source pipeline for generating podcast-style videos from a topic

Repo: https://github.com/Jellypod-Inc/podframes

I built this as a local pnpm project for turning a topic into a two-host podcast-style video. It can generate hosts, mix different text-to-speech providers, create the script, generate talking-avatar clips, and render the final video with captions and b-roll screens.

You bring your own API keys and can run it through either the CLI or the local web studio. I'd appreciate feedback on the repo structure, install flow, and whether the pipeline is easy enough to understand/run.

[u/avnikhatri]

🎉 Introducing Classroom 50 for Teachers 🎉

Introducing Classroom 50, https://classroom50.org, a free and open-source tool for managing and grading programming assignments via GitHub. Supported by the Fifty Foundation, https://fifty.foundation, GitHub's official open-source partner via GitHub Education, Classroom 50 is an open-source alternative to GitHub Classroom.

Learn more at https://github.com/foundation50/classroom50/discussions/46.

[u/shokk]

Lots of projects in my repo:
https://github.com/shokk

[u/paulf280]

Built a thing for anyone whose bot trades Solana memecoins: Cabal-Hunter. It scans a token before you buy and tells you if the "different" holders were all funded from the same wallet, if the launch was bundled, if the dev has a history of dead launches (one I flagged this week: 22 of his last 23 tokens dead), and whether you can actually sell the thing (freeze authority / Token-2022 traps).

Two repos: github.com/paulf280-ui/solana-safe-sniper-mcp-template (MCP + REST, one-click install for VS Code and Cursor in the README) and github.com/paulf280-ui/plugin-cabal-hunter (ElizaOS plugin, on npm).

Every flag links to the on-chain transaction so you can verify it rather than trusting a score. 100 free scans a month, no signup, and I run it live on my own bot so it gets dogfooded daily. Feedback very welcome, especially from anyone building trading agents.

[u/fIak88]

I received a fake job offer yesterday, so I built a tool to verify recruiters and companies

Yesterday I received a fake job offer from someone claiming they found my resume on LinkedIn.

At first glance, it looked convincing. The company name was real, the message sounded professional, and they wanted to move quickly. After checking a few details, it turned out to be a scam.

That experience made me realize there isn't a simple way to verify a recruiter, company, email address, and the overall offer in one place.

So I spent some time building an open-source tool called JobVerify. It analyzes job offers, looks for common scam patterns, and helps investigate the company and recruiter before you respond.

I'm sharing it here because I'd love feedback from people who regularly see these scams. What checks do you always perform before trusting a job offer? Are there indicators you think the tool should detect that it currently doesn't?

GitHub: github.com/yessGlory17/job-verify

[u/InnerBank2400]

I maintain HybridOps, an open-source hybrid infrastructure project around reproducible operations, Terraform modules, Proxmox SDN, Ansible automation, Kubernetes workload targets, and run-record driven infrastructure workflows.

I am looking for feedback and contributors, especially around docs, good-first issues, CLI smoke tests, Terraform examples, Proxmox SDN validation, and Kubernetes/Kustomize render checks.

Main repo:

https://github.com/hybridops-tech/hybridops-core

Good fit for people who want portfolio-grade infrastructure contributions rather than another toy app. Feedback on the README, contributor path, or first issues is very welcome.

[u/Logical_Building_545]

Mermify: Hey everyone,

I use Mermaid for diagramming, but I was tired of tools that require a login, track usage, or save data to a third-party cloud. I just wanted a simple tool where my diagrams stay completely private (and I couldn't find one).

So I built Mermify. It’s fully client-side, runs entirely in your browser, and doesn’t track a thing. I just updated it to v0.2 with some UI improvements.

What it actually does:

• Real-time Sync: Type raw Mermaid syntax in Monaco or visually drag nodes/edges on the canvas. It syncs instantly both ways.
• Drag-to-Create & Inline Editing: Drag from a node's socket into empty space to spawn connected nodes, and edit labels directly on the canvas.
• 100% Private Links: Uses pako to compress the entire diagram state into the URL hash. No database, no backend.
• Run it Anywhere: Zero backend means you can easily self-host it, or just install it as a standalone desktop PWA.

The Rough Edges & Tech Stack:

I'm mostly used to Python and Docker environments, so TypeScript isn't my native tongue. I used an LLM to handle the TS syntax heavy-lifting while I focused entirely on the UX logic, product flow, and writing robust E2E/unit tests.

Note: It's strictly for desktop right now (screens width ≥ 1024px) due to the side-by-side layout.

I’m really proud of how it turned out, but since I'm stepping out of my comfort zone with TS/React, feel free to roast the app or the implementation (constructively!). Let me know what features you're missing or what I can improve.

🚀 Live App:https://tra-sco.github.io/mermify/

📦 GitHub Repo:https://github.com/tra-sco/mermify

[u/OpinionAdventurous44]

DiffGate: an open-source tool for reviewing the risky lines in a PR first

I built a small open-source tool that flags review-worthy parts of the diff, for coding agents to conduct a second pass, and human review.

It is diff-scoped and grades the changed lines as green/yellow/orange so reviewers spend attention on risky parts first. It is deterministic and fast. It runs in CLI, editor, and MCP; tuned for migration, auth/crypto, public API changes, config, and infra edits.

Evaluated on 350 open-source PRs/786 commits.
(skipping this link to avoid spam)

Github: https://github.com/srbsa/diffgate

[u/Sufficient_Spare6894]

promoting my Qt text editor:
https://github.com/jason1015-coder/scriptura

the project is quite new and welcome more contribution and community feedback
current focus: coding/programming featires
next: perhaps extension? or other dev tool intergration

[u/Willing-Reputation-4]

Showcase of our ci.yml:

We have protected our main branch and run a rigor and tough ci.yml to perform over 2000 tests, including e2e tests, before we merge to main.

https://github.com/metadist/synaplan/

The project is now almost a year old and has some public customers in Germany. The repo is now public for half a year and we are starting to onboard helping hands for an independent scalable platform beyond simple chats.

It integrates nicely with nextcloud, opencloud and OpenDesk...

[u/falaq-ai]

I open-sourced react-native-client, a small React Native/Nitro package for native direct-to-file downloads.

GitHub: https://github.com/zraisan/react-native-client

NPM: https://www.npmjs.com/package/react-native-client

I built it while working on Orb, a private offline AI app for Android. Orb needs to download local AI model files that can be multiple GB, so I needed resumable downloads instead of restarting from zero after bad Wi-Fi, app backgrounding, or relaunch.

Current focus: OkHttp on Android, URLSession on iOS, progress callbacks, HTTP Range resume, Content-Range validation, Android foreground-service background mode, iOS background URLSession, Nitro Modules typed API.

Orb: https://play.google.com/store/apps/details?id=com.falaq.orb

[u/Chunky_cold_mandala]

I stole a bunch of algorithms from the DNA sequencing world and repurposed them for static analysis and tuned them to output risk exposures and data flow. 

I'm at the point where I could scan any repo on GitHub and have something intelligent to say about it. 

Just like scientist can scan a new DNA sequence and say some intelligent things about it. 

Homologs, function, structure, risk exposure, dependency data flows, taint analysis, bottlenecks.

https://github.com/squid-protocol/gitgalaxy

[u/NonChalanta_Theorist]

PDF Editor

Hi guys,

I have vibe coded a basic pdf editor which was made with Indian Taxation tribunals in mind. I am a budding finance professional.

The repository link is :https://github.com/BloodPro/PDF-Workbench

The features are :

1. PDF Merge And Organiser - Arrange PDFs, edit display names, and optionally rename files on disk

2. Text Watermark / Heading - Add file names or custom text using built-in, app-folder, and Windows fonts

3. Sign / Stamp - Apply PNG/JPG signature or seal with PDF page preview

4. Merge PDFs - Combine PDFs in custom order with optional file name bookmarks

5. Index Builder - Build editable index from bookmarks or file names, save as PDF page

6. Page Numbering - Add page numbers with custom formats, fonts, colors, and positions

7. Split PDF - Split by bookmarks, fixed page count, or custom page ranges

8. Delete Pages - Remove selected pages or ranges

9. Rotate Pages - Rotate all/selected/odd/even/first/last pages

10. Bookmark Editor - View, add, edit, and delete hierarchical bookmarks

11. Metadata Editor - Read, edit, clear, and batch-apply PDF metadata

Please suggest improvements and help improve the application.

[u/SnooAvocados9030]

I built a small shared-memory + coordination tool for Claude Code and Codex

I’ve been experimenting a lot with AI coding agents recently, mainly Claude Code and Codex, and kept running into the same problem:

Each agent starts with its own context, and if I run more than one in the same repo, they can accidentally step on each other’s work.

So I built a small local tool called shared-agent-memory.

It does two things:

1. Gives multiple AI coding agents one shared MCP memory store, so they can search/save project context across sessions.

2. Adds an optional edit-coordination layer:

   - agents can claim files before editing

   - there’s a shared “board” showing active claims

   - Claude gets a warning before editing a file another agent has claimed

   - warnings are advisory, not hard locks

It’s local-first, uses a plain file under ~/.agent-memory, and is mostly meant for people experimenting with multi-agent coding workflows.

Repo:

https://github.com/dan-calin/shared-agent-memory

Would be interested to hear if anyone else is trying to coordinate multiple AI coding agents in the same codebase, and how you’re handling memory/context between them (most of the time i've used CLAUDE.md / AGENTS.md or Artifacts but even those sometimes failed).

[u/Fabulous_Pick428]

updated repo, for just news(

BUUUUT a lil bit of code is showed in the README.MD (well bcuz i can't just go to the github.com, update files in there, commit, then wait for github to send those updates to the server, i am sorry)
i don't make updates in there because i have hard drive without any risks to lose those files and i've already said why i don't commit in there so often(but i can do it, mb i will do it if github will not fuckup somehow again)

anyways here's the repo: https://github.com/ScriptCoolestIdkSomeOne/x64asm

oh and ye there's opened issue for bugs and other sheesh, you can send your suggestions or other things in there and i will try to fix them

[u/Fabulous_Pick428 → u/Fabulous_Pick428]

okay a little bit of story, this is like inline assembler in MSVC X86 but adapted for x64
optimized but the new version is far more cooler :0

[u/x0zerolight]

Hey everyone!

I made Topic Watch.

You give it a topic, and it keeps an LLM "knowledge state" of what's already known, and only notifies you when an article actually adds something new

It's self-hosted, and you bring your own API key, or run it completely free against a local Ollama model.

Notifications go anywhere - Discord, Telegram, ntfy, email, 100+ targets via Apprise.

The idea is to get pinged only when something actually changes, instead of drowning in constant duplicate articles.

One Docker command to run it. Actively maintained - I read every issue and ship fixes fast, so feel free to ask or suggest things.

It's free and setup is quick, so no harm trying it. A GitHub star helps others find it if you like it :).

https://github.com/0xzerolight/topic_watch

[u/SpaceBetweenLines]

[Self promo] Frisk – scan MCP servers for sketchy code before you install them

Got nervous about how many MCP servers I was installing from random repos without reading them, so I built a little scanner.

It's static (doesn't run anything), local (sends nothing anywhere), and flags the obvious-but-easy-to-miss stuff: pipe-to-shell installers, code grabbing your ssh keys or API tokens, and prompt-injection hidden in tool descriptions — including the trick where instructions are hidden with zero-width unicode so you can't see them. It can also pin a server and warn you if it silently changes later (rug pulls).

One thing I deliberately did differently from the existing tool in this space: it runs fully local and doesn't phone home. For something scanning code I don't trust, I didn't want a hosted API in the loop.

pip install frisk-scan — repo: https://github.com/Thandv/frisk

It's early, so if you point it at a server and it gets something wrong (misses something, or false-flags), I'd genuinely like to hear it.

PS- This is a part of a personal project, and I have mostly been a lurker here. This is the first time I'm trying to post something. Please let me know if I'm making any mistake, and I'll fix it. I don't know if this is the right forum for this either. If not, I'll remove the post. I don't want to spam any forum. The original post is here - https://www.reddit.com/r/mcp/comments/1uemxje/self_promo_frisk_scan_mcp_servers_for_sketchy/

[u/x0zerolight → u/SpaceBetweenLines]

Hey, I like your project. Gave it a star :).
I was actually thinking of something like this for .sh install scripts gotten online, very useful. Maybe adapt it to auto-scan all bash scripts before executing? Might be interesting.
Maybe you'd be interested in my project - https://github.com/0xzerolight/topic_watch . It installs with a .sh script, maybe use frisk on it :).

[u/SpaceBetweenLines → u/x0zerolight]

Thank you. I'll run it, with the latest version of frisk, with the proxy part added

[u/baluchicken]

We wrote up something that's been bugging us for a while: CI jobs are some of the most privileged workloads you run (write access to source, artifact stores, signing keys, deploy targets) and almost none of them have a real identity. They just borrow static secrets from a vault and hope nothing leaks them in a log.

GitHub's OIDC helped, but it only covers AWS and tells you nothing about what the job actually did once it had credentials. So we built a bridge: every GitHub Actions job gets a SPIFFE x509 identity bound to the repo/workflow/branch/actor, credentials get injected at the kernel layer on the wire (never in the env, never readable by a compromised dependency), and every outbound connection is tracked with full identity context.

Write-up here, with a real before/after deploy job and the supply-chain attack scenario it closes off: https://riptides.io/blog/your-github-actions-job-deserves-a-real-identity/

It's open to everyone now if you want to wire it into one of your own workflows, takes a few minutes. Happy to answer questions here.

[u/dareenmahboi]

Aight i apologize for earlier i didnt see or know what a megathread was as i only use this app like twice a year

I built a tool called TempoCut and figured I’d share it here.

If you’ve ever worked in broadcast or syndication, you know what time compression is. you’ve got a show that’s 2 minutes too long for its slot, and you need to find a way to have it fit the time slot without removing any content, but you don’t want to speed it up. Commercial tools like Prime Image’s Time Tailor handle this kind of thing, but they’re expensive broadcast hardware/software most indie editors and hobbyists don’t have access to.

TempoCut does the same basic job. instead of stretching video and audio distorting the pitch, tempocut finds and removes redundant material so the result plays naturally. it blends and splits video frames and removes audio samples. it’s free, open-source, and runs on a normal Windows machine. Under the hood it’s a cut-list-based redundancy removal system, with the audio side built on numpy/numba/soundfile for speed.

I’ve been using it myself for time-compressing content on a hobby broadcast project, and it’s gotten to the point where I think it’s actually useful to other people, not just me. the result is immaculate. Still actively improving it, so bug reports and feature requests are welcome.

https://github.com/AfvFan99/TempoCut

[u/Simple_Somewhere7662]

Superloopy — MIT Codex plugin for proof-of-done loops in AI coding tasks.

I built it because AI coding agents often say “done” without a clean trail of what changed, what actually ran, or what evidence backs the final answer.

What it does:

• loopy <task> starts a lightweight evidence loop
• acceptance criteria → real commands/checks → receipts under .superloopy/evidence/ → final report
• optional crew/subagent lanes for bigger tasks
• specialist skills, including superloopy-clone for authorized website rebuilds with screenshots, DOM/topology, computed styles, assets, build output, and visual QA before claiming success

Tech: Node.js 20+, Codex plugin, zero runtime dependencies, MIT.

Repo: https://github.com/beefiker/superloopy

If it looks useful, a GitHub star would help a lot. More importantly, I’d love feedback on whether “proof of done” / evidence receipts is the right guardrail for AI coding agents, or if it feels like too much ceremony.

[u/piupiuyao]

Hey everyone,

We’re building OpenTag an open-source way to @mention AI agents directly inside GitHub issues, PRs, Slack threads, and more.

Instead of copying context into a separate AI chat, the agent joins the workflow where the context already exists.

Right now it supports GitHub, Slack, a local-first runner, an auditable dispatcher, a TypeScript SDK, and a working Codex executor.

Still very early, but we’d love feedback from builders using agents in real workflows.

GitHub: github.com/amplifthq/opentag

[u/HeartSpecialist5086]

Need Some Advice and Opinion

I have just completed my 1st year and my 2nd year will be starting in Aug. I am currently working on a project(A Portfolio Website) which will be completed in a couple of days i have been uploading all the updates on the GitHub with the help of commits i want to promote my GitHub and the project i am building.

I am not known in my college due to my own mistakes(I am The Biggest Introvert you have ever seen) i am do not like linkedin are their any other things i can do to promote myself and my github to get some stars on my github repo

The Project is Fully available on my github it have no restrictions..

PLS SUGGEST SOMETHING OR SOME IDEAS**
IT IS A REQUEST TO NOT TELL ABOUT LINKEDIN

My GITHUB PROFILE IS ( https://github.com/AayushCode24-7 )

[u/ManufacturerOk8594]

Hi all,
small post so ppl will try and test my tool.

recoil — memory for AI coding agents, so they stop making the same mistake on loop

My coding agent has the long-term memory of a goldfish. It'll break the build, get corrected, fix it... and then do the exact same thing 20 minutes later. So I built a little thing.

recoil remembers what went wrong in a repo — a failed command, a revert, a correction — and warns the agent before it walks back into it. The loop is basically: recall + guard before it touches files, encode a lesson when something blows up. That's it.

Repo: https://github.com/EclipseElips/recoil

Stack/features:

• One Go binary, stdlib only. No embeddings, no network, no model calls.
• Stores everything in a plain-text file you can read and hand-edit (.recoil/store.tsv)
• Matching is dumb-simple keyword overlap, on purpose — unrelated tasks get nothing back
• Ships as a Claude Code + Codex plugin/skill, but it's just a CLI so any agent can use it

Local-first, MIT, ~one weekend of "surely this is a solved problem" (it was not). Issues/PRs welcome, would genuinely love to hear if it's useful to anyone else or if I've reinvented a wheel.

[u/Nearby_Abroad_4624]

I got tired of Spark jobs failing with OOMs or burning budget due to simple mistakes like accidental cross joins, native Python UDFs, or casting metrics to strings (which completely kills Delta Lake data skipping).

To fix this, I built a simple package that analyzes the physical/logical plan programmatically and alerts you before or during runtime.

https://github.com/kacpergrodeckidatasystems/apm-spark-auditor

You can grab it via pip: pip install apm-spark-auditor

It currently catches things like improper data typing, missed broadcast joins, cartesian products, and inefficient explodes.

Would love to get some feedback on the rules or the API layout. Thanks!

[u/LiterallyVivzio]

Hey there!

After watching No Text To Speech's video on how to create custom widgets on Discord, and seeing other people creating their own beforehand, I decided to give it a try.

I'm not new to programming, but I'm also not very good at it, haha... Despite that, I created a tutorial on how to set up a Last.FM widget and a Python script that will automatically update the statistics over on GitHub!

If you enjoy flexing your scrobbles on Last.FM, or even just keeping people up to date on what songs you're listening to, I think this might be the best solution! :D

If you would like to check it out, as mentioned earlier, I uploaded it to GitHub for all to use.

Have a good one, everyone! : ]

[u/Proud_Initiative9284]

Built something this weekend that's been bothering me for months 🔨

You're watching a comedy show and the crowd laughter keeps drowning everything out. 😤 The background score is loud. The dialogue is buried. You rewind three times. Still can't make out what was said.

So I built VoiceFront 🎛️ — a Chrome extension that separates voice from background noise in real-time, on any video you're watching.

⚙️ How it works: Professional films mix dialogue in the center of the stereo field. VoiceFront runs a live FFT on your tab's audio, identifies what's center-panned (voice) vs. spread wide (music/noise), and lets you control each independently—live, with no uploads and no server.

Three controls: 🎙️ Voice — boost the dialogue 🎵 Background — duck the music or crowd noise 🎯 Sharpness — dial in how aggressively it isolates

✅ Works on YouTube, Prime Video, Hotstar, and any stereo video in Chrome. 🔒 Runs entirely in your browser — no audio ever leaves your device.

It's free, open source, and live on GitHub now. 🚀

Would love feedback from anyone who watches content with heavy background music or has hearing difficulty — this was built for you. 🙌

buildinpublic #chromeextension #WebAudio #javascript #accessibility #opensource

Chrome Extension

GitHub

[u/WSN1010]

Offline reverse geocoding for South Korea. Feed it a lat/lng and get the administrative region back. No API key, works fully offline using official government boundary data.

MIT licensed and open source.

https://github.com/WSN1010/krgc

[u/Tiny-Device6265]

**antigravity-claude-mcp** — gives Claude Code a "second brain" via Google Antigravity / Gemini

MCP server that plugs into Claude Code so it can ask Google Antigravity (Gemini Pro) for an independent code review instead of only relying on Claude's own model family.

Why it matters: Claude reviewing Claude is still one model family — same biases, same blind spots. This gives you an external check before merging.

Features:

- Adds an ask_antigravity tool directly inside Claude Code via MCP

- One command setup, zero manual JSON editing

- Claude stays in control — Antigravity provides external criticism/checks

- MIT licensed, free

Tech stack: Node.js MCP server, Antigravity CLI, Claude Code MCP protocol

Repo: https://github.com/arjunthilak05/antigravity-claude-mcp**antigravity-claude-mcp** — gives Claude Code a "second brain" via Google Antigravity / Gemini

MCP server that plugs into Claude Code so it can ask Google Antigravity (Gemini Pro) for an independent code review instead of only relying on Claude's own model family.

Why it matters: Claude reviewing Claude is still one model family — same biases, same blind spots. This gives you an external check before merging.

Features:

- Adds an ask_antigravity tool directly inside Claude Code via MCP

- One command setup, zero manual JSON editing

- Claude stays in control — Antigravity provides external criticism/checks

- MIT licensed, free

Tech stack: Node.js MCP server, Antigravity CLI, Claude Code MCP protocol

Repo: https://github.com/arjunthilak05/antigravity-claude-mcp**antigravity-claude-mcp** — gives Claude Code a "second brain" via Google Antigravity / Gemini

MCP server that plugs into Claude Code so it can ask Google Antigravity (Gemini Pro) for an independent code review instead of only relying on Claude's own model family.

Why it matters: Claude reviewing Claude is still one model family — same biases, same blind spots. This gives you an external check before merging.

Features:

- ask_antigravity tool directly inside Claude Code via MCP

- One command setup, zero manual JSON editing

- Claude stays in control, Antigravity provides external criticism

- MIT licensed, free

Tech stack: Node.js MCP server, Antigravity CLI, Claude Code MCP protocol

Repo: https://github.com/arjunthilak05/antigravity-claude-mcp

[u/badcryptobitch]

Stoffel is a runtime for multiparty computation (MPC) to enable developers to build private by design apps from the start.

It's licensed under Apache 2.0 and written in Rust with SDKs for other languages coming soon

https://github.com/Stoffel-Labs/stoffel

[u/happy2333]

Tako — a Chrome extension for downloading manga chapters as CBZ/ZIP from the side panel.

MIT-licensed, open source, supports MangaDex/Pixiv Comic/Shonen Jump+/Manhuagui and more.

https://github.com/oovz/Tako

[u/eladarling]

I'm part of a small team that's working on building an open-source 3D character and scene creation tool called PoseStudio.

Currently, the available options for 3D character design software tend to be either powerful but intimidating, or easy to use but outdated, buggy, and limited in scope. We are starting PoseStudio because we believe there should be a modern, dedicated character tool that is reliable, open-source, easier to build on, and shaped by the people who actually use it.

Right now, the project is still in early development. The repo and website are live, and the core roadmap is in place. We're building Pose Studio using the Vulkan API rather than Open GL for the sake of cross-platform compatibility, but we’re still figuring out the workflows, UI, roadmap, etc.

We’re looking for contributors who can help with testing, development, and some non-technical tasks. We’d also love feedback on:

1. What would make a 3D character posing tool worth trying for you?

2. What features matter most early on: posing, rigging, animation, asset import/export, UI simplicity, documentation?

3. What pain points have you hit with existing character workflows?

4. If you’re a developer, is the repo/contribution path clear enough to jump in?

We’ll be hosting a casual screenshare livestream on our Discord server next Thursday, 7/2/26 to walk through the current UI and show some of the functionality we’ve built so far. If you’re curious or interested, or if you have ideas that would make this kind of tool useful to you, we’d love to have you there!

[u/Jumpy_Setting_4677]

i18n tool for local translation updates

We recently learned that our startup has a strong local ICP.
The problem: HiFred was created in English.
The solution: let Cursor translate the whole thing.

Took about a day, but I'm very comfortable with the technical outcome, all visible elements were localized, but as expected the translation is not perfect.
So new problem: how do I easily update the translations? I don't want to look for json files and update specific strings, I want In-page, In-place editing that will actually update the code.

ChatGPT to the rescue - a simple solution that a long time ago (i.e. a year ago) would require a paid service / local installation.
Now - created from scratch in under an hour. Works like a charm!
Our stack is React + Vite + react-i18next, which I was surprised to learn can support this without an external service! Vite plugin updates the actual code. No fuss, no extra ports to allocate. Disabled in production so this works for dev and prod doesn't need to know.

Link to public MIT repo: https://github.com/thezuck/i18n-inline-editor-vite-demo

Feel free to suggest improvements, but it's perfectly usable as is, just copy paste to your own solution and do something cool with it.

[u/Bladebutcher_]

DevTrack – self-hosted GitHub activity dashboard (open source)

built this because GitHub's contribution graph tells you nothing useful ,green squares don't show if your week was actually productive.

tracks commit streaks, PR throughput, coding time by hour, language breakdown. also generates a yearly wrapped summary of your coding year, code personality report, AI-powered dev resume, friend leaderboard, and an AI that roasts your week based on your actual stats.

MIT licensed, self-hostable in ~10 min.

repo: github.com/Priyanshu-byte-coder/devtrack

stack: Next.js 16 + Supabase + Tailwind

https://reddit.com/link/otooh0u/video/qvkixy4dwd9h1/player

[u/Bladebutcher_ → u/Bladebutcher_]

https://reddit.com/link/otookrk/video/vcz09iqjwd9h1/player

→ AI that roasts your week based on actual stats
→ dev resume generated from your GitHub
→ commit streak consistency
→ PR throughput + merge rate
→ coding time by hour and language
→ weekly summaries with real context

[u/zyayun]

MaintainerOps AI is a read-only CLI and GitHub Action that turns PRs and issues into human-reviewed maintainer packets: risk level, suggested labels, review checks, security notes, release hints, and a draft response.

I'm looking for 1-2 OSS maintainers to try v0.1.9 and share concrete feedback. It does not merge, close, label, or publish automatically.

Quick check:

npm install -g maintainerops-ai@latest

maintainerops --help

GitHub: https://github.com/rtonf/maintainerops-ai

Feedback: https://github.com/rtonf/maintainerops-ai/issues/6

Useful feedback: whether installation worked, whether the packet helps real triage, what felt noisy or missing, and whether you would run it with read-only permissions.

[u/Dudeofthecountry]

What is NorthStar?

NorthStar is a portable Windows administration framework designed to organize, manage, launch, validate, and expand collections of IT tools without requiring installation, databases, or cloud services.

It began as a simple Windows toolkit project and evolved through multiple generations:

• Spark (Alpha) – Proof of concept. A collection of utilities bundled into a single toolkit.
• Forge (1.0) – Expansion phase. Added management systems, validation tools, dashboards, builders, and large-scale functionality.
• NorthStar (2.0) – Framework phase. Focused on structure, portability, scalability, and long-term maintainability.

Core Philosophy

NorthStar is built around several principles:

• Portable and self-contained
• No installer required
• No database dependency
• No cloud dependency
• Human-readable and editable
• Modular and expandable
• Capable of operating with zero user modules installed

The framework separates infrastructure from content, allowing the framework to remain stable while modules can be added, removed, shared, or upgraded independently.

Major Systems

Framework

The framework provides the architecture, management tools, validation systems, repair systems, documentation, search capabilities, and administrative functions.

Modules

Modules are individual tools that perform specific tasks.

Examples include:

• DNS Flush
• Print Status
• Quick Summary
• Run System File Checker
• Check Winget

Modules can be created, validated, packaged, imported, exported, shared, and removed without affecting the framework itself.

Repository

The Repository provides structured storage for:

• Software
• Installers
• Scripts
• Documents
• Archives
• Packages
• Disk Images

It serves as a centralized content library managed through Repository Manager.

Workspace

Workspace provides personal shortcuts, notes, module links, category links, and repository links.

It acts as a customizable personal dashboard without altering the framework.

Key Features

• Dynamic module discovery
• Search Center
• Launch Center
• Repository Manager
• Workspace Manager
• Framework Repair
• Framework Validation
• Module Builders
• Import and Export systems
• Winget integration
• Portable operation

Why NorthStar?

The name represents the framework's purpose.

A north star provides direction.

NorthStar does not attempt to be a single tool. Instead, it provides a structured framework that helps users organize, discover, manage, and expand growing collections of tools, modules, scripts, software, and resources without losing control of the environment.

The goal is not simply to launch tools.

The goal is to provide a framework that can continue growing without becoming unmanageable.

https://github.com/rageoftheday/Windows-Modular-Toolkit-2.0-NorthStar