r/coolgithubprojects

Ember is a desktop social network that runs with no servers at all. No accounts, no company in the middle, no feed algorithm.

Little explanation is in order!

- Your identity is a keypair on your own machine. No email, no sign-up.

- Your posts are a signed log on your device. People who follow you keep a copy and share it on, so your posts stay up even when you're offline.

- If nobody keeps a post around, it fades. Stories disappear after 24 hours.

- You discover people by meaning, not popularity: posts are slotted into "buckets", so writing about something puts you next to strangers writing about the same thing.

- Direct messages are end-to-end encrypted (text, images, voice notes) and wait in a queue while the other person is offline.

Status: alpha, tested between a handful of people between continents. Windows and Linux builds are on the Releases page. An Android client works but isn't released yet.

Try it: https://github.com/CRTnoise/ember-p2p

- The Windows build isn't code-signed yet, so SmartScreen will warn you: click More info → Run anyway. SHA-256 checksums are on the release page.

- On first launch, allow Ember on private AND public networks, or it can't find anyone.

A peer-to-peer network is only as alive as the people online, and right now that's mostly me and my test posts. Join then and we'll actually see each other in the swarm.

What I'd love feedback on: does "find people by meaning instead of followers" sound useful or weird? And what would make you open it a second time?

I built it with a lot of help from Claude. Happy to talk about how that went, too.

[Watch the demo!] https://streamable.com/gk2s5m

I got tired of emailing myself files and using cloud apps just to move a PDF from my phone to my computer. So I built FileApex, a local-first file manager and sharing hub for Android, macOS and Windows.

You pair your devices once. After that, files go straight between them over your own network.

What it does:

• Pair with a QR code. There are no IP addresses to type. You can also use a 6-digit code, and there's an optional PIN lock.
• Browse and move files between paired devices, or send to several devices at once.
• Share from anywhere. It adds a Finder and Share extension on macOS, Share and Send To on Windows, and Direct Share targets on Android.
• Bulletin Board. Send text or files to all your devices at once. Delete a message and it disappears everywhere.
• Phone notifications on your computer (opt-in). You pick which apps share notifications. You can reply to messages or dismiss them from your desktop. Nothing is stored, and verification codes stay on the phone by default.
• Clipboard and link sharing (opt-in). Copy on one device and open the link on another.
• Locate Phone. Make your phone ring from your computer.
• Device details. See battery, storage, RAM and network for every paired device.

For the power users:

• A desktop CLI and terminal dashboard for scripting and headless use
• Tailscale support to reach your devices across networks
• A Docker daemon you can run as an always-on node
• A browser extension that sends your current tab to the Bulletin Board
• A Simple theme if you only have one phone and one computer and want the minimum, with many others to customize your experience

Privacy: There are no ads, trackers or analytics. Anything that touches the internet is opt-in, and your files stay on your devices.

It's free for personal use. The project is new and updated often, so feedback and bug reports help a lot.

Download: GitHub releases (Android APK, macOS, Windows) | Google Play 

I'm happy to answer questions in the comments. What would you want it to do next?

I built Ripple around a question I kept running into on larger codebases:

You change one piece of code — what else could that change affect?

Ripple takes a Git diff, maps the changed lines back to symbols, and traces the relationships outward so you can see direct impact, transitive impact, tests, type dependencies, and references.

The part I cared about most was keeping the analysis conservative.

A reference is not automatically a call.

“Affected” does not mean “broken.”

And if Ripple can’t prove a relationship, I’d rather it miss an edge than invent one.

The analysis runs locally. No source upload, no telemetry, and no LLM-generated dependency edges.

TypeScript/JavaScript is the stable target right now. There’s also experimental Python support in the current beta.

The thing I’d most like feedback on is false positives. If Ripple tells you something is affected when it clearly isn’t, I want to know about it.

Repo:

https://github.com/Aliferous3/ripple-impact

I also wrote a longer breakdown of why I built it:

https://medium.com/@noamanm19/i-built-ripple-to-answer-one-question-what-else-did-this-code-change-touch-188ab96465e5

It’s Apache-2.0 and open source.

Hi everyone,

I’ve spent the last few months building a custom knowledge graph extraction engine (which I call blAST) designed to map the architectural physics of massive software repositories.

Usually, extracting code into a graph requires an Abstract Syntax Tree (AST). The problem is ASTs are incredibly heavy, strictly monolingual, and fail if a repository doesn't compile. I wanted to map planetary-scale, multi-lingual enterprise systems, so I built a deterministic parser instead. It treats code like text and scans for keyword markers across 50+ languages to build the graph.

Here is how the graph ontology and analytics work:

1. The Ontology

• Nodes: Files, Classes, and Functions.
• Node Properties: 50+ dimensional vectors representing regex keyword hits (e.g., raw memory manipulation, state flux,etc).
• Edges: File (imports/dependencies) and functional execution paths (outbound calls/reachability).

2. Graph Analytics & Network Topology

Once the graph is built, the engine runs network math over the repository to find architectural bottlenecks. I calculate:

• Modularity & Average Path Length to measure encapsulation.
• Articulation Points to find the "God Nodes" (if these fail, the graph shatters).
• Cyclic Loop Density to measure static friction in the architecture.

3. K-Means Clustering on 1.5M Nodes

As all langauges have keywords that roughly mean the same thing, I analyzed 1000 repos of different languages and I took the regex count vectors of 1.59 million file nodes across 50 languages and ran them through an unsupervised K-Means clustering algorithm. The graph converged into 10 distinct architectural "micro-species" (e.g., UI View Layers, Highly Concurrent State Managers, Unshielded Native Core). The clustering algorithm successfully grouped a complex Java service and a defensive Rust file into the same exact node category based purely on their physical edge/property behavior.

4. Graph Traversal Use Cases

I used this graph engine to tear down Google DeepMind's original AlphaFold repo. By traversing the graph, the engine instantly isolated the absolute heaviest bottleneck in the network: a single node (contacts_network.py) running an $O(N^6)$ complexity loop holding up the entire pipeline.

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

example data of google Deepmind's Alphafold - https://squid-protocol.github.io/gitgalaxy/museum-of-code/alphafold_teardown.html

Population data from 100's of repos - https://squid-protocol.github.io/gitgalaxy/03-04-claim-4-comparing-languages/

I've been building and maintaining multiple web projects, and I kept running into the same problem: every new project required repeating a lot of setup work before I could focus on building the actual product.

So I built create-clubedge-app, a CLI that generates a Next.js monorepo from a versioned starter.

It includes a foundation for:

• Next.js App Router and TypeScript
• pnpm and Turborepo
• PostgreSQL and Drizzle ORM
• Supabase Auth
• Testing, linting, and CI
• Optional Redis-compatible caching and object storage integrations

One feature I particularly wanted was traceability. The generated project records the CLI version and starter reference, including the starter commit, so you can identify where it originated.

I've tested the published CLI by generating a project and running its type checks, tests, and production build.

I originally built this for my own development workflow, but I think it could be useful to other developers too.

I'd love honest feedback:

• Would you use a starter like this for your own projects?
• Is the included stack a useful starting point, or would you remove anything?
• What would make you choose this over maintaining your own template?

Website: https://starter.clubedge.live

CLI source: https://github.com/Clubedge/create-clubedge-app

Starter source: https://github.com/Clubedge/clubedge-starter

I'm happy to answer questions about the architecture and implementation.

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

The idea is pretty simple: give it a list of icons:

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

and embed the generated SVG directly into a README:

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

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

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

Would love feedback on the API, implementation, or anything that could make it more useful.

Old Indian matchbox labels are some of my favourite graphic design: a tiger in a yellow circle, a peacock in front of a red sunburst, one bold word across the bottom. I wanted a model that makes new ones from a text prompt.

What I built

• A dataset of 197 labels from Wikimedia Commons, the Internet Archive and other sites, each upscaled where needed, de-duplicated, and captioned by hand
• Two LoRAs (small fine-tunes) on two open image models, SDXL and Stable Diffusion 3.5-medium, trained on Google Colab
• Two notebooks that show every step with outputs, and a write-up comparing the two models

What came out

• The SD3.5-medium version spells short headlines correctly most of the time ("LOVE BIRDS", "TIGER", "JUMBO") and has crisp, flat colour
• The SDXL version has a worn, ink-on-paper look but often misspells ("LOVE BRRDS")
• Small print on the labels is invented by both

Links

• Code and write-up: https://github.com/spearb0lt/Indian-Matchbox-Art-Style-Text-to-Image-Generator
• Model weights: https://huggingface.co/spearb0lt/Indian-Matchbox-Art-Style-Text-to-Image-Generator
• Dataset: https://huggingface.co/datasets/spearb0lt/Indian-Matchbox-Labels

Both notebooks run on Google Colab (trained on an L4). Feedback welcome.

I got tired of googling the same nmap flags, sqlmap syntax, and privesc one-liners every day. So I built a small CLI that keeps them all in one place — no internet, no browser, no dependencies.

It's called Selwanism. You type `sel nmap` and get every nmap command you'd normally copy from Cheatsheet sites. Or `sel sqlmap`. Or `sel -s recon` to see everything tagged for reconnaissance.

What it does:
- 50+ tools across recon, web, password, exploitation, privesc, AD, network, wireless, OSINT
- Search by name, title, or tag
- Interactive mode if you just type `sel`
- Single JSON file for the database, so adding your own tools takes 30 seconds
- Zero dependencies — just Python 3
- Works offline

It's still evolving. I'm planning to add:
- Target variable substitution (`set target 10.10.10.10` and the commands auto-fill)
- Fuzzy search
- External cheatsheets in data/tools/
- Optional clipboard copy

Not trying to replace man pages or writeups — just want to keep the essentials one keystroke away while I'm in a shell.

Any feedback welcome, especially from people who use this kind of stuff daily. If something's missing, open an issue and I'll add it.

Links in the comments.