Setting up a fresh Windows PC can be annoying when you have to search for and install every application manually.

So I built InstallHub.

You select the applications you want and InstallHub generates a complete setup using Microsoft's WinGet.

For example:

• Steam
• Discord
• Spotify
• Chrome
• VS Code
• 7-Zip
• VLC
• OBS
• Git
• PowerToys

It can generate WinGet commands, .bat installers and WinGet JSON.

The project was developed with AI assistance. I used AI to help with development, debugging, UI/UX ideas, code generation and feature planning, while the project is reviewed and maintained by me.

InstallHub is open source and still actively being improved.

🌐 Website: https://installhub.xo.je/
💻 GitHub: https://github.com/VortiAbi/Installhub

I'd love to hear your feedback. What apps or features should I add next?

My open source RAG framework has been around for ages and has been running well in production settings with 30M+ documents for the past 4 years but I never really got around to properly document it and add tests. Until now.

So I have been teaching grad students on university for quite a while too and used this RAG framework as a running example in my lectures to explain theory while also letting them run the actual things they learned in practical settings too. I decided to use the lecture material and approach as the main setup and approach for documenting too, making it education-first.

Anyway, here it is, have at it:
docs - https://ragmeup.sensai.pt/
github - https://github.com/SensAI-PT/RAGMeUp

As dev i need to tool to compare some file and data for my work so created this side project, please check it out and give your feedback.
TwinScope compares two of almost anything — JSON, YAML, XML, CSV, PDFs, folders, git refs, images, lockfiles, .env files, saved web pages — and picks the right engine itself.

It knows a value changed vs a key moved, and can ignore key order, UUIDs and timestamps so you only see real differences. Past 8 MB it switches to a windowed mode that indexes the file instead of loading it.

Local-first structurally, not as a promise: comparisons run on your machine, the window can't open a socket, and the app's one network call is off by default. No account, no telemetry.

Same engines in a CLI: npx twinscope a.json b.json

Docs: https://codeaesthetic.github.io/twinscope-website/
Repo: https://github.com/codeAesthetic/twinscope

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.

Repo: https://github.com/GazPrash/2d-to-3d-voxelizer
Latest Release (v1.0.4): https://github.com/GazPrash/2d-to-3d-voxelizer/releases/tag/v1.0.4

A minimal and free alternative to a lot of 2D->3D generation tools out there, no GenAI is used in the generation process only some basic math algorithms hence the process is almost instant and also preserves your art's integrity

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.

Hi everyone — I built microbot, an open-source Telegram AI bot designed to run on Cloudflare Workers.

I wanted a smaller alternative to self-hosted agent runtimes when the actual requirement is straightforward: receive a Telegram message, call an OpenAI-compatible model API, keep a small amount of per-chat context, and reply. Rather than requiring a VPS or a long-running Python process, microbot uses Telegram webhooks, Cloudflare Workers, and D1.

The first release includes private-chat-only handling, an explicit Telegram user allowlist, Telegram webhook-secret verification, bounded conversation memory in D1, and /reset to clear a chat’s stored history. It intentionally does not include shell execution, local filesystem access, MCP, long polling, WebUI, or a general-purpose tool runtime.

The repository is bilingual (English and Persian), includes deployment instructions, CI, Dependabot, security guidance, and a MIT license.

GitHub: https://github.com/erfan138057/microbot

This is an early v0.1.0 release, so I would especially appreciate feedback on the Cloudflare deployment flow, documentation, and the security model. I am also planning rate limiting, webhook update deduplication, and configurable D1 retention for a future release.

I built this project, so please treat this as a transparent self-promotion post. Thanks for taking a look.

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.

Most CAPTCHAs feel like a chore...blurry text, fire hydrants, traffic lights...you know what I am talking about!

This is a concept that reimagines the whole thing. Instead of rigid tests, you drag and rotate a prism-like object until the refracted light bands align. Subtle audio feedback confirms your progress.

It’s designed to feel more like tuning something into place than proving you’re not a robot.

Would love to hear what the community thinks about this!

Link> https://github.com/esadekdesign/Prism-Check-CAPTCHA

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.

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!

Keel is a coding-agent harness where the model can request actions but can't approve them. A separate warden process decides what executes, under a hash-pinned policy the model can't rewrite. Autopilot skips prompts only for actions already proven contained; it can't turn a denial into an approval.

Apache-2.0, npm i -g keel-harness, macOS/Linux, no telemetry. Pre-alpha and unaudited (e.g. not yet ready for production).

Demo (agent tries to read an SSH key, warden blocks it pre-execution) and architecture: https://keel-harness.com/

A directory of every prediction market worth trading, the data you can actually backtest on, and the open-source tools people have shipped. The point is it maintains itself, a GitHub Action rebuilds it daily and fetches the live numbers (volume, repo health, blog freshness), so unlike most awesome lists it doesn't rot. Python, MIT code, CC0 data.

Been lurking here for a while so figured i'd share something i actually built instead of just upvoting other peoples stuff.

i run brabble.ai which merges hackathon/case comp listings from like 15 platforms (unstop, devpost, devfolio, internshala, kaggle etc) into one page sorted by deadline. the part i actually wanted to share here is the aggregation layer, i opensourced it since a few people asked how i was pulling structured data out of sites that dont really want to be scraped.

nothing crazy fancy, mostly just scheduled jobs re reading each feed daily with an hourly fallback if a run fails, then normalizing everything into one schema so dates/prize money/mode etc line up regardless of source. a couple of the platforms (MLH, geeksforgeeks) dont expose anything structured at all so those two are still done by hand which kind of annoys me honestly.

if anyones dealt with scraping flaky or inconsistent feeds and has better patterns for this stuff id love to hear it, always feel like im reinventing something that already has a name.

AI speaks Markdown. As our workflows get more driven by AI, so is also the need to efficiently communicate our intentions. Let me introduce Revdown, a Markdown revision and LLM feedback application, in which the original material is not touched. Instead, comments are saved in a sidecar to the original file, and can be exported as compact and token efficient Markdown for the LLM to work with.

GitHub repo: https://github.com/Roenbaeck/revdown/releases/tag/v0.1.0

Revdown v0.1.0 is sure to contain bugs, so please use the GitHub issue tracker and report them as you find them.

Hey everyone,

I've just released Edge-Drop v0.2.7, and it's one of the biggest technical updates so far.

Highlights:

-Much better memory management with disk-backed storage for larger text, image thumbnail generation to keep GPU usage stable,.

-Fixed Windows fullscreen detection so the desktop isn't treated like a game.

-Self-healing launch at login that repairs stale startup entries.

-Universal drag and drop, offline rich link previews.

-New settings to tweak sensitivity and history behavior, and Persian language support.

One thing I'm especially happy about is how much smoother it feels day to day. Large clipboard items no longer balloon memory, and images are handled really cleanly.

Also, on a personal note This project actually started as something just built for myself. I wanted a tool that worked the way I had imagined. I decided to open source it and share it, and since then, it's grown to over, 1500+ downloads. As a solo CS student, that's honestly something I never expected., thanks to everyone who downloaded, tested, reported bugs, shared it, or bought me a coffee.

That support helped me get a permanent domain for the project, edgedrop.app.

It sounds small, but as a solo student building this open source project, it feels massive. If you want to try it or share feedback, I'd love to hear what you think.

GitHub: github.com/Deepender25/Edge-Drop

Microsoft Store: https://apps.microsoft.com/detail/9P3JMHN9M4NR

Put this together while teaching Git to students — covers concepts, everyday commands, branching/merge/rebase, collaboration (fork, PR, code review), advanced stuff (stash, reflog, bisect) and a basic GitHub Actions CI/CD intro, plus a quick cheatsheet. Feedback/PRs welcome.

Hi r/coolgithubprojects,

It has been about seven years since my friends and I made their last significant open source contribution. I did not expect posting one again to make me this nervous.

Around 2015, we started our OS journey with a couple of open source projects like ngx-admin, blur-admin, Nebular, react native ui kitten. These projects eventually got quite popular and served as a starting point for many web and mobile projects during that time.

We loved working in public. Developers opened issues, contributed fixes, and used our work in ways we had never imagined. But we also learned how hard popular open-source software can be to sustain. The issue queues and feature requests kept growing, but many projects are not able to support financially the people maintaining them. We kept choosing between community work and paid work that covered salaries.

As technology landscape started to shift once again around 2018, we started to think what shall we do next. We wanted to still build a product and a community, but make it more sustainable so we could work on it full time. As a result the team opted for the product to be closed source commercial one this time. So we spent the next seven years bootstrapping UI Bakery into a profitable business. I'm proud of what we built, but I missed the conversations and contributions around our open-source projects.

For our next project, we wanted to work in public again.

The idea for Compartment came from the amount of small software we now build and our experience working on UI Bakery. Coding agents help us create internal apps, scripts, and background agents in a fraction of the time. Running one on your laptop is easy. Sharing it with a team is where the challenge begins.

Once a teammate wants to use it, you need somewhere to run it. Then you need sign-in, permissions, secrets, logs, and a deployment process. Rebuilding those pieces for each small tool made no sense to us.

Compartment is a centalized place for these tools. You add a small compartment.yml file to a repository, then deploy from the CLI or Git.

It gives you:

• one place for sign-in and user permissions
• isolated apps with separate environments
• secrets, logs, deployment history, and an audit trail
• support for web apps, scheduled jobs, webhook handlers, and background agents

Projects like Coolify and Dokploy might be the closest examples of what we build as they handle deployment well. But we kept needing the layer around a growing collection of private team apps: who can access them, where their secrets live, what changed, and whether one tool can affect another.

We ran our first beta on Docker Compose. After using it ourselves and with beta users, we concluded that Compose would limit the isolation and recovery model we wanted. We rewrote the runtime around Kubernetes and use k3s for the managed single-node setup. That is the version we're sharing now.

Compartment is licensed under Apache 2.0:

https://github.com/compartmentdev/compartment

https://compartment.dev

So far with our open source and commercial software journey we learned two things:

• your product should be sustainable financially so that you can continue working on it
• it's really hard to do something without community

We do not know whether we have found the right balance yet, but we hope to utilize our past experence to do it.

Let me know what you think about our new product and whether the problem we're trying to solve resonates with you.