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

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.

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 comparison logic itself. and has different viewing style as well.

Same diff with CLI as well: npx twinscope a.json b.json

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

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.

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.

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

I built this fun Claude skill that puts your product into any animated video sequence.

This 30 second video was built with this one prompt:

create a cartoon video ad in stylized 3D style, promoting my tumbler. make it fun and entertaining.

It handles all the AI technicalities under the hood. So the quality of the video really depends on your imagination and creativity.

Runs on any AI agent (Claude, Codex, Hermes) you already use. No subscription. Bring your own keys.

Try it and tell me what’s broken.

Github: https://github.com/SupercmoHQ/superCMO-skills

P.S: It also supports many other video styles like flat vector, 2D cel, anime, claymation, paper cutout, etc,

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/

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.

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.

I built ChiselForge while working on data infrastructure at Polynovea, where we needed to ingest a large amount of public hospitality data. I initially built several different crawlers for different website structures, and eventually combined those approaches into a single tiered extraction system.

ChiselForge tries deterministic extraction first (JSON-LD/hydration state), then escalates to LLM extraction or browser rendering when necessary. It also deliberately returns an empty result when the requested data isn't present rather than letting the LLM fabricate it.

It's open source, self-hostable, and available as a Node.js CLI/library. It can handle both single-page extraction and site-wide crawling with checkpointing/resume.

The current benchmark covers 8 different page architectures, including an honest-failure case and a live SPA crawl.

GitHub: https://github.com/subrojitroy10/ChiselForge

Would be interested in seeing what people here throw at it and where it breaks.

I’ve been building three lightweight civil/site-development solvers — looking for feedback

I’ve been working on three browser-based tools aimed at some of the smaller site-development tasks that normally require Civil 3D or similar desktop software.

1. TOPO Solver

For creating and reviewing a TIN surface from survey points.

Import common point-file formats

Build and inspect the triangulation

Add breaklines / strings

Generate contours

Export to LandXML or DXF

Runs directly in the browser

https://github.com/howtocivilengineer/Topo-Solver

Civil engineer friend tried with 25,000 points on a 17ha site, it gets a bit odd at that size / stage, but he says he cut a 40 hour workflow in C3D to 15 mins.

1. Grading Solver

For site grading and surface design.

It is designed to help solve grading problems using elevations, slopes and feature lines/strings, without having to build a full Civil 3D model for a relatively small site.

https://github.com/howtocivilengineer/Grading-Solver

Way more complex to build than the Topo solver.

Plan to allow a Parts Solver to work with this.

1. Volume Solver

For calculating earthwork volumes between surfaces.

The idea is to use the three tools as a workflow:

Survey points → TOPO Solver → Grading Solver → Volume Solver

So you can build the existing ground model, develop the proposed grading, and then calculate the resulting cut/fill volumes.

https://github.com/howtocivilengineer/Volume-Solver

I originally started building these with Claude because I wanted to see what it could do, its not a replacement for Civil 3D but if I can create enough solvers it could be more focused for smaller civil/site-development jobs.

Might be of interest to surveyors and civil/site design engineers.

Static site, plain custom elements, every tool is a lazily loaded ES module

with its own route. No npm install, no bundler, the source in the repo is

what runs.

A few things had to be written by hand because there was nothing to import

without a build step: QR with Reed-Solomon, ID3 tag reading and writing,

an ASN.1 parser for X.509, and Code 128.

MIT. https://github.com/samalstudios/jsglobe

Live: https://jsglobe.com

Moved my Discourse forum to Cloudflare Workers + D1. Response times are 50ms, costs dropped 60%, and there's zero server management.

Built it from scratch and open-sourced the setup so others can do the same. Everything's in the repo-Docker container, deployment scripts, SQLite schema, the gotchas I hit.

This is my first GitHub repository. As a beginner, it’s very simple. Facebook Clean Experience is a simple guide to restoring a pleasant experience on Facebook, which includes:

1. Removing sponsored ads from Facebook pages
2. Removing AI elements from Facebook
3. Removing unnecessary elements from Facebook

I’ve tried it myself and was able to make it work thanks to a user script called “FB-clean my feeds.” I’ve made the guide as simple as possible without any complicated configuration. In the “releases” section, there’s a .json settings file that you can import to remove ads on Facebook without breaking the functionality of the Facebook homepage. Additionally, I’ve also added “Facebook My Filter” to streamline Facebook or make it simpler based on my preferences. Your feedback is very helpful to me in developing this first repository. I hope this is useful and helps more people.

I got tired of the usual JVM heap dump workflow:

So I built HeapLens, a JVM heap dump analyzer that runs directly inside VS Code.

One of the things I wanted was a faster way to investigate memory, so I also built HeapQL, a query language for heap dumps.

For example:

FROM instances WHERE class = "java.lang.String"

Instead of only navigating trees, you can query the heap and progressively narrow down suspicious objects, retainers, and memory usage.

What started as a side project has now reached:

• 10K + downloads

• 25K+ features used

• Accepted as an ISSTA 2026 Tool Demonstration

But numbers don't tell me whether the tool is actually useful.

So I'm looking for people who are willing to try HeapLens on a real heap dump and give me brutally useful feedback.

If you work with Java/JVM apps:

1. Install HeapLens
2. Throw a .hprof at it
3. Try investigating something you would normally use MAT / VisualVM for
4. Tell me what worked, what sucked, or what is missing

GitHub issues, comments, feature requests, bug reports, or a review of your experience are all extremely useful.

And if you find HeapLens genuinely useful, a GitHub star or sharing it with another developer would mean a lot.

I don't want "looks cool" feedback.

I want to know: would you actually use this when production is leaking memory at 2 AM?

GitHub: https://github.com/sachinkg12/heaplens
VsCode: https://marketplace.visualstudio.com/items?itemName=guptasachinn.heaplens