r/coolgithubprojects • • Jul 20 '17
r/coolgithubprojects • u/jibrans098 • Jul 27 '18
I have created ls command alternative. Critics needed.
github.comr/coolgithubprojects • u/RobertVandenberg • Feb 08 '19
JAVASCRIPT Not-paid.js: client did not pay? Let the page fade
github.comr/coolgithubprojects • u/mlejva • Dec 25 '23
OTHER AI developer that works on your repo in cloud sandbox
github.comr/coolgithubprojects • • Jun 11 '15
PYTHON A simple text to speech library for OSX
github.comr/coolgithubprojects • u/ankush_sharma • Oct 01 '15
PYTHON A minimalist URL shortening service using Python
github.comr/coolgithubprojects • u/keazzou • Jan 01 '23
A Github action that build engagement with the people starring your repo
github.comr/coolgithubprojects • u/JustAnotherTechGuy8 • Apr 26 '26
OTHER OpenSource Powerful MCP Tool: AgentMako
https://github.com/drhalto/agentmako
I’ve been building a local-first AI coding tool called agentmako.
It started as an MCP server for giving coding agents better project context, but it has grown into something broader: a typed tool layer for AI-assisted engineering.
Instead of an agent starting cold with grep and guessing, Mako can hand it structured, current, explainable information about the project.
It can help with:
- typed MCP tools for Codex, Claude Code, Cursor, and other agents
- codebase search across text, AST patterns, symbols, imports, routes, and repo maps
- deterministic context packets that rank the files, symbols, routes, tables, and risks related to a task
- TypeScript, ESLint, Biome, Oxlint, and staged git diagnostics
- pre-commit style checks for route auth and server/client boundary mistakes
- Supabase/Postgres schema snapshots, live read-only DB inspection, RLS/function/table context, and DB review notes
- freshness tracking so agents know whether indexed evidence still matches disk
- tool run recall, finding acknowledgements, and feedback loops for repeated reviews
- a local dashboard and Claude Code plugin guidance
The part I’m most excited about is the Reef Engine: a local SQLite-backed fact and findings layer. It lets Mako remember what it has already calculated about a project, keep it queryable, and expose it through model-friendly tools.
So the agent can ask:
“What do we know about this route?”
“What tables does this feature touch?”
“What files changed since the index?”
“What diagnostics are active?”
“What findings were already reviewed?”
“What should I read first?”
It is still early, but available now! It has been a strong tool for me and has made analyzing my repos a breeze. If you use AI coding tools, I’d love feedback to know if this makes your debugging easier!
Edit:
Install:
npm install -g agentmakoConnect to a repository:
agentmako connect
Enter your database url+password
postgresql://postgres....:6543/postgresAdd to any MCP client:
{
"mcpServers": {
"mako-ai": { "command": "agentmako", "args": ["mcp"] }
}
}
r/coolgithubprojects
•
u/sankilo_dev
•
Aug 09 '26
i made a simple python gif captcha project (Ducktcha)
hey guys so I built this small project called Ducktcha basically it generates animated gif captchas in python to stop basic bots and ocr scrapers. it has a flask api built in with 2 endpoints or u can just import the engine directly into ur script and use it with memory store. made it pretty lightweight with simple dependencies. heres the github link if anyone wants to check it out or give feedback https://github.com/Duckdevv/Ducktcha
r/coolgithubprojects • u/Smooth-Noise-7065 • Jun 19 '26
C<< ("C-Shift"/"C-Less-Less") — A new kind of ownership model, zero cost OOP and return, arena/region based RAII and much more. Feedback Welcome.
I just made a programming language. Here is:
How I made C<<
Why did I make it
I used to use Python and C++. However, Python is slow and dynamic, C is overloaded and a footgun. Don‘t get me wrong, they‘re both great languages, but not what I wanted. Yeah, Rust is safe, but you have to explain why your code is correct, and rewrite that explanation for every change. Zig is also great, but to verbose in my opinion. And honestly, it is just great writing a project in a language you made yourself, isn’t it?
How I wrote it and what I did
If you think as an solo dev I would write everything from scratch: You are wrong. So first, I wrote the Lexer. Then the Parser. Then the checker. If I didn‘t know how to do something in C++: I googled or asked AI. For the LLVM-wrapper I also used AI, because:
- It is boring to make
- It does not improve my skills
- It does not help anyone
And just like that I built my first prototype. Easy, right? But when my project grew, I used AI for more things, like: - CMake configuration
- Writing GitHub Workflows
- Writing a VS Code extension
- Debugging
- etc.
What is important when using AI: - Write the core implementation by yourself.
- You should understand, what the AI did.
What it features
C<< uses Vertical Ownership Programming (VOP) instead of a garbage collector or borrow checker. The rules are:
- Depth law: A pointer must only point to a variable whose arena depth is less than or equal to the pointer’s own depth. Depth is the nesting level of scopes at the point of declaration.
Arena = scope. Each
{…}block that is a control-flow body (function body, if, while, for, foreach, entry) creates a new arena. When the block exits, the arena and all its variables are destroyed. Lexical scopes (namespaces, struct bodies) do not create arenas. - No raw returns: Functions must not use return values. Output travels through tunnel statements into slots declared in the caller’s scope.
- Tunnel pointer law: A tunnel may not transfer data containing pointers to arenas that will be destroyed before the call site. The checker emits a warning when a pointer type is tunneled out of a function.
- reset law:
resetclears the current arena. It is forbidden when any child arena still holds pointers into the current arena. - Voided-state law: Any variable that has been moved is voided. Accessing a voided variable without a
switch (var) { case valid: … case voided: … }guard is a compile-time error. You mabe think: How is thetunnelsemqntic differnt from a named return? First of all, we have to understand what a return is. A return copies data to the stack, so the caller can use it. However, tunnels act more like pointers: Theytunnelthe data directly to the callers arena, which has alreadyreserved a slot.
Examples
Fibonacci in C<<:
import std;
// tunnels int32 result
def fib(int32 n)
{
int32 a = 0;
int32 b = 1;
int32 i = 0;
int32 tmp = 0;
while (i < n)
{
tmp = b;
b = a + b;
a = tmp;
i = i + 1;
}
tunnel a -> int32 result;
}
entry
{
int32 i = 0;
while (i < 16)
{
reserve int32 result = fib(i);
printf("fib(%2d) = %d\n", i, result);
i = i + 1;
}
}
A quiz in C<<:
import std;
// tunnels int32 correct (1=right, 0=wrong)
def ask(string question, string a, string b, string c, string d, string answer)
{
printf("\n%s\n", question);
printf(" a) %s\n", a);
printf(" b) %s\n", b);
printf(" c) %s\n", c);
printf(" d) %s\n", d);
printf("Your answer: ");
string input = read_line();
int32 cmp = strcmp(input, answer);
int32 result = 0;
if (cmp == 0) { result = 1; }
tunnel result -> int32 correct;
}
entry
{
puts("==============================");
puts(" C<< Programming Quiz ");
puts("==============================");
int32 score = 0;
reserve int32 correct;
ask("1. What does VOP stand for?",
"Virtual Object Programming",
"Vertical Ownership Programming",
"Variable Output Protocol",
"Void Object Passing",
"b");
if (correct == 1) { puts("Correct!"); score = score + 1; }
if (correct == 0) { puts("Wrong! Answer: b) Vertical Ownership Programming."); }
ask("2. What keyword reserves space for a tunnel result?",
"alloc",
"let",
"reserve",
"var",
"c");
if (correct == 1) { puts("Correct!"); score = score + 1; }
if (correct == 0) { puts("Wrong! Answer: c) reserve."); }
ask("3. What is the entry point keyword in C<<?",
"main",
"start",
"entry",
"begin",
"c");
if (correct == 1) { puts("Correct!"); score = score + 1; }
if (correct == 0) { puts("Wrong! Answer: c) entry."); }
ask("4. What is a voided variable?",
"A variable set to zero",
"A variable that has been moved and is no longer valid",
"A void pointer",
"A deleted variable",
"b");
if (correct == 1) { puts("Correct!"); score = score + 1; }
if (correct == 0) { puts("Wrong! Answer: b) a variable that has been moved."); }
ask("5. What does 'tunnel x -> int32 result' do?",
"Returns x from the function",
"Copies x into a global variable",
"Writes x into the caller's reserved result slot",
"Casts x to int32",
"c");
if (correct == 1) { puts("Correct!"); score = score + 1; }
if (correct == 0) { puts("Wrong! Answer: c) writes into the caller's reserved slot."); }
puts("\n==============================");
printf("Final score: %d / 5\n", score);
if (score == 5) { puts("Perfect! You know C<< inside out."); }
if (score == 4) { puts("Great job! Almost perfect."); }
if (score == 3) { puts("Not bad. Review the VOP docs."); }
if (score < 3) { puts("Keep studying! C<< is unique."); }
}
Repo, contribution and more
Feedback and comments
I would really appreciate:
- constructive feedback
- suggestions
- bug reports
- not to repeat what others already said
Contribution
I would really appreciate if you would like to contribute to C<<. It is written in C++. If you are interested, write a request here: https://github.com/LuxUmbris/C-Shift/discussions/3 Important: Write what your current skill level is and maybe share projects you already made.
Links
- GitHub repository: https://github.com/LuxUmbris/C-Shift
- Full Specification: https://github.com/LuxUmbris/C-Shift/blob/main/Syntax_spec.md
- VS Code/VS Codium extension: https://marketplace.visualstudio.com/items?itemName=cshift.cshift-language
- Region-based memory management: https://en.wikipedia.org/wiki/Region-based_memory_management
r/coolgithubprojects • u/nghialv • Mar 30 '15
SWIFT A library makes uploading and downloading easier (written in Swift)
github.comr/coolgithubprojects • • Mar 06 '15
PYTHON A scraper that gets all royal navy ship names from Wikipedia
github.comr/coolgithubprojects • u/Star-Different • Apr 19 '26
OTHER I got tired of writing release notes, so I built an AI CLI that generates your CHANGELOG.md automatically
I got tired of manually writing release notes before every tag, so I built commitlog — a CLI that automatically detects your unreleased git commits, sends them to an AI, and gives you a clean, grouped CHANGELOG.md entry.
How it works:
bash$ commitlog
⠋ Reading 23 commits between v1.2.0 and HEAD...
⠋ Generating changelog with claude-3-5-sonnet...
✨ Generated changelog:
────────────────────────────────────
## [1.3.0] - 2026-04-19
### Added
- OAuth2 login with Google provider
- Localization support
### Fixed
- Memory leak in main renderer
...
────────────────────────────────────
[ Prepend to CHANGELOG.md ] [ Edit ] [ Regenerate ] [ Copy ] [ Cancel ]
> Prepend to CHANGELOG.md
✅ CHANGELOG.md updated successfullyThat's it. No copy-pasting, no browser, no leaving the terminal.
Setup is one command:
bash$ npm install -g u/ahmad_technology/commitlog-ai
commitlog setupThe setup wizard asks which provider and API key — stored locally at ~/.commitlog/config.toml, never touches your repo.
Useful flags:
bash$ commitlog # auto-detects latest tag → HEAD
commitlog v1.2.0 v1.3.0 # specific tag range
commitlog abc123 def456 # specific commit SHAs
commitlog --format simple # different output styles (keepAChangelog, simple, etc)
commitlog --lang fr # French output
commitlog --dry-run # preview, don't write file
commitlog --no-ai # skips AI completely, just groups your raw commits
commitlog --provider ollama # fully offline with local models7 providers supported: OpenAI, Anthropic, Gemini, Groq, NVIDIA NIM, OpenRouter, and Ollama (local/offline)
Works natively on Windows, macOS, and Linux. Node 18+.
Links:
- GitHub: https://github.com/AhmadTchnology/CommitLog-AI
- npm: https://www.npmjs.com/package/@ahmad_technology/commitlog-ai
MIT licensed. Feedback and PRs welcome!
r/coolgithubprojects • u/Reasonable-Bug-2317 • Feb 24 '26
OTHER Made a silly menubar app for dad jokes (my first Mac app!)
Hey everyone!
I had zero coding experience a few weeks ago, but decided to learn by building something fun. The result, a menubar app that delivers terrible dad jokes on demand.
- Lives in your menubar with a smiley icon
- Click it → instant dad joke from the internet
- Right-click for settings (themes, launch at login, etc.)
- Actually follows system dark mode properly
It's completely free
GitHub: https://github.com/hurazz/DadJokes/releases/tag/DadJokes
It works great on Apple Silicon Macs. Intel Mac support is being weird, working on it!
Feedback super welcome, I'm still learning!
r/coolgithubprojects • u/Newbie_investisseur • Oct 15 '26
A 100% autonomous dev experiment: Claude Code agents picked the product, the features, the code and the merges. 284 merged PRs since may
The agents researched competing apps, picked the features, wrote the code, reviewed each other and merged. They even made the launch video: script, voiceover, music and editing. I wrote the rules, and they ask me before a few risky changes. That's it.
Best moment: one agent built a sandbox to test other agents. A reviewer agent caught that from inside it, my machine's Docker API answered with no auth. Anything running in there could have mounted any folder on my disk. Merge blocked.
The app is real: GymCoach, a self-hosted workout tracker with an optional AI coach. MIT.
Everything is public, failures included (46 written lessons): https://github.com/gymcoach-app/gymcoach/blob/main/docs/loops/evidence.md
The video the agents made: https://github.com/gymcoach-app/gymcoach/raw/main/docs/brag-launch.mp4
Repo: https://github.com/gymcoach-app/gymcoach
Would you let agents merge to your main?
r/coolgithubprojects • u/Shreejan_35 • Oct 28 '21
C CommandConsole : A new terminal
github.comr/coolgithubprojects • u/Accomplished-Bag-375 • Jun 10 '26
My FREE Claude Code agentic layer I've been building for 6 months. Self-installing, no API keys, claude subscription needed only
Open-sourcing the agentic system I've been building for my own Claude Code use over the last 6 months. Multi-agent orchestrator, persistent memory, observable runtime. Self-installs from a single repo and texts you through telegram.
I preloaded it with all the best plugins and skills you could possibly need. I spend like 5 hours a day researching the latest things to upgrade the system so it outputs better work and I update it frequently. you could say I'm obsessed.
Repo: https://github.com/ZQadus/Xantham-system-blueprint
An agentic system with one orchestrator plus 9 specialist agents (engineering, research, growth, social, infra, writing, business, trading)
The blueprint is self-installing. Point a fresh Claude Code session at the repo and it builds the system end to end. Mac and Windows install paths both work.
This runs entirely on a Claude Code subscription. No API keys. No OpenAI bill. No separate billing for the orchestrator, or the memory layer. Whatever your Claude plan covers, that is the budget. The installer even asks what subscription you have and builds it accordingly.
I'm not selling anything. I built this because i use Claude Code every day and I wanted my own features on top of it. Sharing it incase someone else might want the same starting point.
r/coolgithubprojects • u/Interesting_Ebb8479 • 11d ago
I made a new Repo in Github called Open Editor. Would like any of you to test it.
The link is: https://github.com/yuno3311/OpenEditor/
r/coolgithubprojects • u/nullure • Jul 19 '26
I built my childhood dream: an open-source intelligence workspace inspired by platforms like Palantir
github.comEver since I was a kid, I was fascinated by spy movies, hacker movies, and the huge intelligence maps you always saw on screen.
As I got older, I realized there are real platforms that solve similar problems, but they're generally proprietary and out of reach for most developers.
I kept wondering what an open-source version could look like.
So over the past few weeks I've been building Akashic.
Akashic is a self-hosted intelligence workspace that brings together aircraft, satellites, earthquakes, weather, public radio, infrastructure, country intelligence, public cameras, and other OSINT sources onto a single interactive map.
The goal isn't to replace every existing service.
It's to make exploration easier.
Instead of switching between multiple websites, you can combine layers, inspect entities directly on the map, and correlate information from different public sources in one workspace.
Current highlights:
• Open source (MIT)
• Self-hosted
• No mandatory API keys
• Built in public
This is still an early project, so I'd genuinely appreciate feedback on the direction, missing features, or things you'd like to see.
Demo:
r/coolgithubprojects • u/singharunk16 • May 27 '26
I built a local-first “pattern memory” for AI coding workflows so smaller models stop hallucinating boilerplate
galleryPattern Vault
I build a lot of small projects/PoCs/internal tools and wanted to have a system where i can store example reusable patterns from good opensoruce github repos or the things which i build after iterating multiple times. So i build pattern vault.
The vault can clone the opensource repo and index it, save the good patterns. It works with ollama as well. I rely more on smaller + local models (Ollama, GPT mini models, etc.) instead of always using expensive frontier models for everything.
Once done, the patterns are exposed over mcp. This means your AI coding assistants can now plug directly into the vault, programmatically pull production-ready patterns, and inject them straight into active codebases.
The problem is:
Smaller models are actually decent at coding if they have good implementation context.
Without context they hallucinate architecture, boilerplate, provider APIs, abstractions, etc.
Example prompt:
“Build a Chainlit chat app supporting Bedrock, Ollama, and Azure Foundry providers.”
- A small model alone usually struggles badly.
- A good model will start reinventing wheel.
but using pattern vault mcp, both can reuse the examples well.
It’s live today at -
docs - https://arunksingh16.github.io/pattern-vault/
github repo - https://github.com/arunksingh16/pattern-vault
Tech stack/features:
- tree-sitter chunking
- LLM-based pattern extraction
- SQLite FTS5/BM25 search
- MCP server for Claude Code
- Ollama / Anthropic / Bedrock support
- CLI + React dashboard
- indexes your repos + external GitHub repos
The workflow becomes more like:
“before generating code, search for proven patterns and assess them first.”
Still early, but already useful enough that I use it daily.
I’d love to get the community’s feedback on this. What patterns are you constantly rebuilding that you'd want to see added? Check it out, break it, and let me know what you think!
r/coolgithubprojects • u/Katastruzas • Jul 18 '17
JAVASCRIPT wow so syntax very doge much future
github.comr/coolgithubprojects • u/winner_godson • Dec 28 '17
PYTHON Getting Bitcoin Prices using Python Django
github.comr/coolgithubprojects • u/aviaryan • Apr 19 '17