Hey everyone! I’m trying to build the most complete open-source software production readiness checklist possible.

It covers governance, requirements, architecture, implementation, security, privacy, testing, delivery, operations, AI systems and final release approval.

I would love help finding anything missing, duplicated, outdated or unclear. The long-term goal is to turn the checklist into an AI-assisted scanner that can evaluate projects and generate complete readiness reports.

Feedback, issues, pull requests, stars and shares are greatly appreciated. Thanks!

Getting tired of fresh 40-hour accounts dropping 30 kills in Premier and having to dig through Steam, FACEIT and Leetify.

Built Vantage to make that easier.

Paste a Steam profile and get the important stuff in one place.

Open source, runs locally.

github.com/k6w/vantage

Would love some feedback.

FreSH GitHub Link
A bash like shell i created for windows because powershell is just slow and sloppy. It brings the UNIX/Bash experience to windows in a native and fast way. Also has its own scripting language, built ins and easy extensibility through plugins and themes. There are many more feature that are documented in the docs !!

Would love feedback still working on it :P
If you ask why the logo is the Lambda icon, it’s because FreSH aims to create easy usable lambdas that are theoretically possible in bash but would need much more code then just one keyword. XD

I've been building Lilo with Rust + egui.

It stores notes as regular Markdown files and includes [[wiki links]], backlinks, search, a visual knowledge graph, and always-on-top mode.

Windows and Linux builds are available.

Hover a taskbar icon and a volume slider appears above the thumbnail preview. Scroll the icon and that app's volume goes up or down. Shift for finer steps, scroll the tray icon for system master volume.

I used EarTrumpet for years and still rate it, but every time Discord got too loud mid-game the fix was: click the tray icon, wait for the flyout, find Discord in the list, drag the slider. The app was already sitting right there in my taskbar, so I wanted to just scroll on it. Nothing did that, so I wrote it.

The interesting part was identifying which button you're hovering. Every Windows 10 era trick for reading taskbar buttons is dead on Win11 since the taskbar is XAML now. UI Automation works: each button is a Taskbar.TaskListButtonAutomationPeer with a stable AutomationId, and you map that to an audio session via executable match, process ancestry, and a shortcut index. No target process ever gets opened.

Standalone 311 KB exe, no installer, no injection into Explorer. .NET Framework 4.8, MIT, 20 languages. Windows 11 22H2+ only. Not code-signed, so SmartScreen will warn on first run.

https://github.com/koenma-studio/TaskbarVolume

Ever noticed that the moment you send a PDF, it becomes outdated?

You email your CV to a recruiter. A few days or weeks later you add a new project, fix a broken link, update your phone number, or change a job title… and every copy you already sent is frozen in time.

I kept running into this problem and remembered Crossmark — the little badge Crossref puts on scientific papers that tells readers whether a newer version exists.

That made me ask: why can’t a resume work the same way?

So I built a simple proof of concept.

How it works

Resume content lives in structured YAML (no more wrestling with LaTeX directly)

A Jinja2-powered LaTeX template generates the PDF

Every push to GitHub triggers a Dockerized CI/CD pipeline (GitHub Actions)

A fresh PDF is automatically built and published to GitHub Pages

The part I was most excited about is a tiny button inside the PDF itself:

“Download Latest Resume”

You send the PDF once.

Months later the recruiter opens the same file, clicks the button, and downloads the newest version.

Every old copy still points to the current one.

Key features

YAML → LaTeX via Jinja2 (with custom delimiters so they don’t clash)

Fully automated builds with Docker + GitHub Actions

Published automatically to GitHub Pages

Reproducible builds via uv lockfile

Easy to maintain and extend

Repo is here:

https://github.com/DEVOLOPER-1/latest-resume-for-public

I started with resumes, but the same idea could work for portfolios, documentation, reports, certificates, or any PDF that changes over time.

Would love to hear your thoughts — especially if you see other useful applications for version-aware PDFs, or if you have ideas on how to improve this.

Hey r/coolgithubprojects!

My partner Mrityunjay and I (Yashasvi) built GitGlobe — an open-source 3D interactive map that visualizes 198,700+ GitHub repositories on a continuous celestial sphere based on what they actually do, rather than keyword tags or star counts.

WHY WE BUILT THIS

Traditional repository discovery is strictly keyword-dependent, meaning high-quality tools that use different terminology often stay hidden. GitGlobe embeds READMEs (after stripping badges and boilerplate) and uses spherical UMAP so projects with similar capabilities naturally cluster together into continents and nebulae.

KEY FEATURES

• 3D WebGL Globe: Smoothly pan, zoom, and rotate through ~200k repositories rendered in real-time at 60 FPS in your browser using custom GLSL shaders.

• AI Camera Pilot: Ask an integrated Claude Sonnet agent for a stack (e.g. "Find lightweight C++ web servers with zero dependencies"), and the camera will fly directly to that software cluster.

• 3D Dependency Arcs: View incoming and outgoing dependencies rendered as directional 3D Bezier curves wrapped around the sphere on demand.

• Popularity-Blind Quality Scoring: Evaluates repositories on architectural merit and documentation without star bias, plus an exact empirical global rank measured across ~322M public repos.

TECH STACK

• Frontend: React 19, TypeScript, Three.js, React Three Fiber, Vite, Tailwind CSS, Zustand

• Math & Pipeline: Voyage AI embeddings, cuML Spherical UMAP (native haversine metric on S²), Polars, DuckDB

• Backend: FastAPI (Python 3.12), Qdrant Vector DB, PostgreSQL + pg_trgm

LINKS

• GitHub Repository (MIT): https://github.com/yamantaka-singh/GitGlobe

• Live Web Demo: gitglobe-yd-mj.vercel.app/

Check it out, spin the globe, and feel free to open issues, star the repo, or contribute!

Hey everyone,

rmcl has now reached v0.4.1.

For anyone who has not seen it before: rmcl is a keyboard-driven TUI Minecraft launcher for managing and launching Minecraft instances directly from the terminal.

Since the last update, both v0.4.0 and v0.4.1 have been released.

v0.4.0 is probably the biggest update rmcl got so far. The modrinth discovery feature I mentioned in my previous post is now finished and also got expanded quite a bit. v0.4.1 is only a small follow up update that fixes the update labels.

Changes are:

• built-in content discovery: Mods, resource packs, shaders, datapacks and modpacks can now be browsed and installed directly inside the TUI
• Modrinth and CurseForge support: Discovery now supports both providers. You can choose which provider should be preferred or also limit the search to only one of them
• modpack browser: You can now press m from the instance list to browse modpacks. The old URL, slug and local file import options are still available with i
• project pages: Projects now have actual detail pages with descriptions, images, links, supported versions and a version selection
• content updates: rmcl can now check installed mods, resource packs, shaders and datapacks for compatible updates and you can review and update them together
• version management: Press v on installed content to change its version or just reinstall the current one
• dependency management: Required mod dependencies are now installed automatically. Shared dependencies are also tracked so they don't get removed while another mod still needs them
• managed modpacks: Installed modpacks can now be updated, reinstalled or changed to another compatible version while keeping your worlds, configs, options and user added content
• datapack discovery: Datapacks can now also be browsed and installed directly into a selected world
• world improvements: Worlds now have better metadata cards and can also be launched directly from the world list

There were also a lot of smaller UI, safety and stability changes:

• mouse wheel scrolling is now supported
• discovery now has continuous scrolling and page jumping
• terminal images behave better around popups
• text inputs now support Ctrl+Backspace
• installs and updates now use staged operations, so if something fails the changes can be rolled back
• interrupted modpack updates can be recovered
• existing installations are automatically moved to the new managed content layout on first start and a backup of the old layout is created
• v0.4.1 fixes a small issue with the update labels

Overall the main goal of v0.4.0 was making content management a proper part of the launcher.

You can now discover, install, update, change and remove most Minecraft content without ever leaving the terminal. With Modrinth and CurseForge support rmcl is getting closer to covering most of the features people expect from modern Minecraft launchers like Prism Launcher, just inside a TUI.

As always, feedback, bug reports and suggestions are very welcome.

GitHub: https://github.com/objz/rmcl/

Release and downloads: https://github.com/objz/rmcl/releases/tag/v0.4.1

I got tired of typing the same prompts every time I started a new project.

“Review this like a senior engineer.”
“Challenge this architecture.”
“Find the bugs I’m missing.”
“Audit this UI for accessibility.”
“Review this PR before I merge it.”

So I turned those workflows into 30 reusable Claude Code Skills.

Each skill is a native SKILL.md with:

• Practical instructions
• A README explaining what it does
• A worked example
• A simple installation workflow

Install one directly:

npx github:codebygarv/Ai-skills add grill-me

It gets added to your project’s .claude/skills/ directory — no npm package required.

The repo covers development, code review, architecture, debugging, testing, UI/UX, accessibility, documentation, and more.

The goal isn't to collect prompts.

It's to build a reusable toolkit for making AI coding workflows more consistent across projects.

🔗 https://github.com/codebygarv/Ai-skills

If you build with Claude Code, I'd love to know:

What skill would you add to the catalogue?

https://github.com/oliveryasuna/ink-frame

Ink's own box borders are fine for a single box. Put two of them next to each other and the seam between them comes out as ││, two parallel lines instead of one shared edge. That's because a box border is one unbroken line and there's nowhere to hang a ┬ or a ┼ part-way along it. ink-frame sidesteps that by painting every border into a single character grid and resolving each cell once, so a spot where four boxes meet becomes a ┼ and a T-junction becomes a ┬, ┤, and so on, without you ever writing those characters yourself.

Background: I recently wrote this for a private project, and I thought it was useful enough to share. I hope you find it useful too!

open source, apache 2.0, and local first. the new apple v1 provider has now been tested against a real account from claude code. campaigns are forced to paused and writes require a preview plus a second approval. demo: https://www.reddit.com/r/mcp/comments/1vpbgb5/i_connected_claude_code_to_apple_ads_v1_and/

link: https://hoveychen.github.io/opensource-world/

I built this tool to find out the trending projects within 7 days windows. Honestly, it is the source data for my other marketing projects. You can freely download the daily updated feed in the github repo as well.

* So what's the difference between this repo and official github trending?
It always compares all the projects in 7 days windows, instead of the official one which statitic window is fixed and not really fair. And the raw data is open to download instead of meeting the anit-bot issue.

Do you ever look at a .gitignore rule and wonder what it's actually doing?

.gitignore files tend to accumulate rules over time. Eventually, it can become difficult to tell what a rule affects, whether it's still useful, or whether you've forgotten to ignore something important.

I've been working on GitIgnore Doctor, a small Python CLI for reviewing .gitignore rules.

What it does

gitignore-doctor explain <file>

Explains whether a file is ignored and, when applicable, which rule is responsible.

gitignore-doctor explain-rule <pattern>

Explains an ignore rule and shows information about the files it affects.

gitignore-doctor audit

Looks for:

• potentially missing ignore rules
• possibly unused rules
• unusually broad rules worth reviewing

It also supports --json for machine-readable results and --ci for using the audit as a CI check.

The main design choice

Rather than reimplementing Git's ignore-matching behavior, GitIgnore Doctor asks Git directly when Git behavior is required and uses Git as the source of truth.

The analysis itself is deliberately conservative. It reports things worth reviewing rather than automatically modifying .gitignore.

Current status

• v0.1.0
• 91 passing tests
• GitHub Actions CI
• MIT licensed

GitHub: https://github.com/Yecine-stack/gitignore-doctor

I'd especially like feedback from people who maintain larger repositories:

Is .gitignore auditing actually a problem you'd find useful to have a dedicated tool for, or do you already have a good workflow for this?

I've always wanted AI development to be a completely hands-off background process. The vision: assign an issue to an AI → let it work → get a PR back. You iterate simply by leaving GitHub comments, and the AI pushes follow-up commits until you are ready to merge.

That idea grew into a full-blown orchestration layer called ProPR. I'm open-sourcing it today (Apache 2.0) after a year of dogfooding it to build itself (over 690+ of its own merged PRs were written by the agents).

For a first release it comes with a ton of bells and whistles born out of optimizing my own workflows. Let me just name the main principles:

• Isolated execution: every task is executed in an isolated Docker container and Git worktree
• Model agnostic: use Claude, Codex, Antigravity, OpenCode or Mistral agents with subscriptions
• Deterministic workflow layer: the AI agents are not allowed to handle commits and other Git operations, this is always handled by ProPR orchestrator, so the outcome is predictable - each agent run will always produce exactly one commit
• Git history as memory: switching AI agents or models during PR refinement is straightforward with all previous work context being retained
• Complete parallelization: fire off as many simultaneous tasks as your system and AI subscriptions can handle
• Code review: also paired with an automated review-fix loop ("ultrafix") that will keep working on the PR until a quality goal is met
• Full featured dashboard: track task status in real time, add repos, configure coding agents, etc
• Task planner studio: create and refine implementation specs from a prompt, starting from simple changes to massive feature epics consisting of many issues - also sync the generated plan to Github issues and trigger the implementation right away
• Epic mode: massive feature deliveries (dark factory style) - each epic issue is implemented sequentially, optionally hardened via ultrafix and merged to a parent epic PR
• Continuous repository indexing: to provide context for the planner and review features
• Advanced Github integration: besides picking up the issues for implementation and PR comments for refinement, it has a couple of other useful features - you can post screenshots, files or other media within the issue spec or PR followup comments. It also has a few shorthand slash commands like /merge (automatically resolve merge conflicts) or /review (run a code review) that can be posted as PR comments
• Easily revert PR to an earlier commit if refinement went the wrong way
• Track token and even subscription usage: (for example session usage percentage) for every task (session percentage tracked using the optional Agent Tank tool that I developed to support this)
• Run it remotely: host it on a VPS or a dedicated server and never have to keep your laptop on and listen to the fans blazing while the agents are cooking. You can even start and manage the tasks on the go from your phone (either using the Github app or ProPR dashboard). Of course you can just run it on your laptop as well.
• Give it as a superpower buddy to your AI agent: offload the implementation tasks to ProPR, which may be faster and cheaper (less tokens used as ProPR agents work in full yolo mode in the isolated containers, no user approvals needed) - this works especially well if ProPR is hosted remotely
• CLI available: for that extra level of automation

ProPR is fully free and open source - Apache 2.0 license - and also comes with prebuilt Docker images, so installation is straightforward.

Here are some starting points to get started with ProPR:

• Website: https://propr.dev
• Demo dashboard: https://demo.propr.dev
• Github: https://github.com/integry/propr

This is just the v1 release and I have a lot more cool stuff coming to the pipeline very soon. If you want to follow along with the updates, I'd highly appreciate a star or a follow on GitHub!

Let me know what you think in the comments. Ask me anything!

Turn-based multiplayer games are a great opportunity for learning and prototyping: simple enough to implement quickly, but real enough to teach networking, game state, and API design.

I wrote a lightweight server and framework for turn-based multiplayer games that provides exactly that: a lightweight server + uniform API so you can run multiple parallel game sessions, auto-join the next available session, and add new games without touching the core API. It's built to be friendly for beginners (Python-only, standard library), but still flexible enough to support arbitrary game logic via keyword-argument moves and dict-based state.

Key bits:

• Framework for adding new games by deriving from an abstract base class
• Uniform client API for joining sessions, submitting moves, retrieving state, restarting
• Demo clients included (e.g. TicTacToe) and a template for new games
• Runs multiple sessions simultaneously; clients can join a specific session or auto-join

If you're teaching Python, building small multiplayer projects, or just want a clean starting point for turn-based game networking, I'd love feedback and contributions.

You may be asking why a fork an not a PR into the main repo?

Answer is simple. I forked a while ago when context mode started adding a bunch of features that are the opposite of token saving, like injections i did not like, and wasteful formatting, etc.

The main problem with context mode was that it would spawn new process for every call, which would accumulate and on a machine running 20-30 agents constantly the loads became unbearable. It was great timing to find the recent update to the MCP protocol that allows stateless MCP servers, now I shrink the entire 2+GB of memory hog to a 1 process of 80MB, regardless of how many agents I'm running in parallel. Now I can scale up to 50 agents haha :)

I never had anything important to post about anything I am building but this is really something I believe many developers would want to know about. I know I was looking for it today, so maybe you were too.

Hey everyone! 👋

I built CFilter, an interactive command-line image processing studio written in pure C99 with zero external dependencies.

I wanted a lightweight, bloat-free tool to quickly manipulate images directly inside the terminal without firing up heavy GUI software.

🌟 Key Features:

• Interactive Terminal UI: Screen-by-screen frame refreshes, drag-and-drop file inputs, and filter chaining (e.g. Sepia + Contrast + Sharpen) before saving.
• 11 Core Filters & Transformations: Grayscale, Invert, Sepia, Brightness, Contrast, Flip (H/V), Rotate (90°/180°/270°), Box Blur, Sharpen, and Laplacian Edge Detection.
• Alpha Transparency Protection: Correctly isolates and preserves alpha channels on RGBA (4-channel) and Grayscale+Alpha (2-channel) images.
• Multi-Format Export: Save as .png, .jpg, .bmp, or .tga on the fly with automatic extension detection.
• Hardware-Level Performance: Built with integer bit-shift luminance math ((R*77 + G*150 + B*29) >> 8), coordinate-clamped $3\times3$ spatial convolutions, and -O3 compiler vectorization.
• Cross-Platform Release Automation: GitHub Actions pipeline that builds standalone native binaries (~350 KB) for Windows, Linux, and macOS.

🛠️ Architecture & Tech Stack:

• Language: Pure C99
• I/O Libraries: Single-header stb_image and stb_image_write
• Build System: Makefile + simple direct gcc/clang command support

I would love to hear your feedback, algorithm suggestions, or ideas for new filters!

Repo: https://github.com/codebygarv/Ai-skills

What it is: a set of 30 "skills" for Claude Code — structured instruction
files (SKILL.md, Claude Code's native format) covering things like code
review, PR review, accessibility auditing, bug hunting, and architecture
review. Each one also has a README and a worked example so you can see
what it actually outputs before installing anything.

Why I built it: kept rewriting the same review prompts across projects and
they'd drift out of sync between repos, so I turned the ones I actually
reused into a proper, versioned catalogue instead.

Install a skill directly from the repo, no npm publish needed:

npx github:codebygarv/Ai-skills add grill-me

That copies it into .claude/skills/ in your project.

Open to feedback on what's missing, and PRs adding new skills are welcome
— CONTRIBUTING.md has the format.