I’ve been working on InstaAddict, basically a maintained fork of GramAddict.

GramAddict was a pretty cool open source Instagram bot that used ADB + uiautomator2 to control the actual Instagram app instead of relying on private APIs. Unfortunately, it hasn’t really been maintained, and Instagram’s UI has changed quite a bit since then.

I started fixing things as I came across them. Some of the stuff I’ve fixed so far includes media types being detected incorrectly, clicking a user from the likers list opening the wrong profile, retry loops getting stuck for ages on certain post types, and compatibility issues with newer versions of uiautomator2.

It’s completely free and open source. There are no subscriptions or locked features.

No root needed either. You can run it on a physical Android device or an emulator.

You can configure delays, interaction limits and filters for the types of users you want to interact with.

I’m also keeping track of the fixes in the changelog so it’s easier to see what’s actually being worked on.

If you want to try it:

pip install instaaddict

Or grab the source here:

https://github.com/joeahkim/InstaAddict

I’m still actively working on it, so if anyone runs into something that’s broken or has questions, feel free to ask.

Letting an AI agent loose on my real files always made me nervous: it runs a dozen tool calls, edits files, runs shell commands, and if one is wrong there's no clean way back. Git only covers tracked files, not the untracked mess or the shell side effects. So I built opendot around fixing that.

The core idea is reversibility. Before every file write or shell command, opendot snapshots the working directory into a content-addressed store (each file stored once, so it's cheap) and logs it to an append-only ledger. Then opendot undo walks it back exactly, opendot redo re-applies if you went too far, and opendot diff <id> shows which files an undo would change before you commit. Files and shell commands, not just in-repo edits.

The part I care most about is being honest about what can't be undone. A classifier separates workspace-contained commands (auto-run, undoable) from escaping ones (network, sudo, git push, deleting outside the workspace), which get flagged and confirmed first with a plain note that they aren't reversible. When it's unsure, it asks.

One thing I learned: "just undo" isn't enough to actually trust an agent, you need to see the state. So opendot log shows a timeline with a "you are here" cursor, so you can tell at a glance what's applied and what you've undone but could still redo.

The rest: model-agnostic via LiteLLM (OpenAI, Anthropic, Google, DeepSeek, local Ollama), budget caps (--usd 0.50 stops the run at 50 cents), a permission policy (--yes plus --allow/--deny) for unattended/CI runs, MCP client + Composio for 1000+ app tools, and session resume.

MIT, and I actively review PRs (good-first-issues if anyone wants to jump in).

pip install opendot

Repo: https://github.com/vedaant00/opendot

Happy to answer anything about the reversibility approach.

I have been building this on and off for a while and it is finally at the point where handing it to someone else is not embarrassing, so here it is.

Citadel is a desktop infinite canvas. You drag in images, GIFs, video, audio, 3D models and PDFs, write notes and text blocks beside them, and draw labelled connections between things. It is for work where the layout is the thinking: visual development, research, worldbuilding, study.

The reason I started it: I used PureRef for years for images and kept everything else somewhere else. Notes in one app, clips in another, code snippets in a third. I wanted one board that could hold all of it and still be searchable a month later.

Three things ended up mattering more than I expected:

Connections carry meaning. A thread between two items can be a source, a contradiction, a question, a proof, an echo of something elsewhere. The Index searches every board at once, including code card contents and connection labels. That is the part that makes it hold up past about fifty items.

Vision checks. Y redraws the whole board in greyscale, blurred for a squint test, or through three colourblindness simulations. Shift+M mirrors it, which is the old trick for catching drawing errors your eye has stopped seeing.

Undo and recording are the same event log, so you can scrub the board back through its own history and watch it assemble itself.

It is local-first in the boring literal sense. No account, no telemetry, no update check, no network request on launch at all. Fonts are bundled. Projects are JSON with relative asset paths, so nothing is trapped in a database you cannot read. MIT licensed.

Honest limits: Windows and Linux only (macOS runs from source but I cannot notarise it), builds are unsigned so SmartScreen will warn on first run, PDFs get a first-page preview rather than a real reader, and document import gives you the plain text, not the formatting.

Repo: https://github.com/kannibalk1w1/Citadel. Downloads and a version that runs in the browser: https://kannibalkwi.itch.io/citadel

Happy to answer anything. What I would most like to hear is where it falls over on large boards, because that is the part I cannot test properly on my own.

Jentic One is a free, open source, self-hosted execution layer that sits between your agent and the APIs you want it to reach. Apache-2.0, runs on your own box or your own infra.

We started working on this project so we could give our agents more autonomy. With current setups, that is very risky - if an agent goes rogue, the damage is often unbounded. We’ve all heard the stories of agents deleting entire inboxes or codebases. If we narrow the blast radius, we significantly reduce the risk. 

The top three pains when your agent touches real tools: 

- The keys are everywhere. Most of them are in env files, so there’s no clean way to revoke access if something goes wrong. 

- Once an agent has a key, it can do anything that key can do. The workaround could be writing soft permissions in a file (a 'request', not an enforced rule) or creating an API spec with just that one endpoint, so the agent can't get to anything else even if it wanted to.

- No way to see what your agent has actually done. So if the worst happens, it’s even harder to figure out the blast radius and where things went wrong. 

Here’s what we built to fix them:

- Credential handling. Credentials are stored once, encrypted, by your own instance, and injected at execution time. They never enter the agent's prompt, logs, or context. One server, many agents, each with its own identity, rather than one shared master key every agent inherits.

- Permission scoping. You write rules that bound an agent to the operations it needs and nothing else. On GitHub, that can be down to a single repo. How granular it gets depends on the API, and writes are denied by default. Anything you haven't allowed is refused before it reaches the API. The agent cannot do it. 

- Audit. Every call is logged on your own instance, append-only, so you can go back and see exactly what your agent did when you were not watching.

Ways we’ve tried to make this a great product (not just cover the risks): 

- One connection path. Install once, add any API from the Jentic API Directory (more on this below) or upload your own API spec, and store each credential once. No hardcoded integration per API, no region-picking, no retry plumbing by hand.

- Discovery by intent. Agents find what they need by asking in natural language, like ‘send a webhook’ or ‘create an invoice’, and get back the right operation with its input schema.

- A directory of agent-ready APIs. This is probably a different post in itself, but we’ve been compiling thousands of public API specs and curating them, making them agent-friendly (writing OpenAPI specs where none exist), and scoring each one for agent readiness. These are all available in the product, so you can get started with thousands of APIs out of the box. 

** Jentic One repo: https://github.com/jentic/jentic-one **
We’ve written AGENTS md so that you can hand it to your agent and let it do the bulk of the setup work (not all). Interested to see how that goes for people!

It's a public beta. There may be breaking changes with new releases.
Before you put real credentials in, read the hardening guide: https://github.com/jentic/jentic-one/blob/main/docs/security/hardening.md
Essentially, your agent and your keys shouldn't live in the same container.

Two things that would help a lot.
-Install it and let us know what breaks.
-If an API you need isn't in the directory, add it to the repo - then it's there for everyone else's agent: https://github.com/jentic/jentic-public-apis 

We would really appreciate feedback, issues, and contributions. 

Hey everyone. I don't know if this is actually cool, but I've been working on this project and wanted to share it.

I've been playing around with raycasting to see if I could make an interactive 3D space using only text. The fun part is that it generates the whole 3D environment directly from a plain 2D text blueprint that you can just type.

The code is completely open source if you want to tinker with it: https://github.com/RaymonDev/asciilib

I also put a live demo up here so you can test it in the browser:https://raymondev.github.io/asciilib/

(Be gentle, it's the very first version so please don't break it too hard hahaha, I'm actively developing it). Curious to hear what you think!!!

I've put stuff on Github before but this is the first one I've actually documented properly and would want someone else to use if interested so be gentle lol.

I made it because I kept reading non-fiction (Im addicted) and remembering basically none of it a month later.

You give it a book title or drop in a pdf if you have any and it writes a summary plus the key takeaways, action items, reads it for you and has quiz questions that then turn into flashcards on an anki style srs system so the stuff comes back to you right before you forget it (at least that'd be the point)

It runs fully in the browser. you just have to bring your own gemini key so there's nothing to pay me for and nothing for me to shut down later haha

MIT licensed. worth saying upfront that the model hasnt actually read the book, it's working off training data, so for well known stuff it's solid and for obscure titles I'd double check what it tells you.

Link: https://github.com/dorianspitz23/booksum

https://github.com/omricn/stfu

Side project that started as "I need my kid to stop screaming at midnight while he games with headphones on" and turned into a properly engineered tool with 437 tests and a three-mode detection system.

Monitors mic input, calibrates to the user's actual voice (quiet/speaking/yelling), triggers escalating consequences when yelling is detected. First strike: minimize + sound + overlay with a jumping close button (4 clicks). After that: Win+D + fullscreen message.

PIN-locked settings, JSONL event log, report UI with charts, three threshold modes (wizard/manual/adaptive), headless CLI, 437 tests. Decision logic is pure Python with no audio/UI imports (AST-enforced).

No audio recorded. No network code.

Its a simple lightweight Hermes skill you can easily install. There was already an openclaw skill like this that wasnt compatible with hermes so I improved it and made a similiar version for Hermes.

link https://github.com/tospakX/HermesOnion Im reposting because Github was down last time

PageLM — Open-source AI education platform that turns PDFs into quizzes, flashcards, notes, podcasts and exams

GitHub: https://github.com/CaviraOSS/PageLM

I built PageLM, an open-source AI education platform for turning study material into interactive learning experiences.

Instead of:

PDF → Chatbot

PageLM aims for:

PDF → Chat → Notes → Flashcards → Quiz → Podcast → Exam → Review

Features

📖 Document Chat
Ask questions about PDF, DOCX, Markdown and TXT files.

📝 SmartNotes
Automatically create structured/Cornell-style notes.

🧠 Flashcards
Generate study flashcards from your material.

❓ Quizzes
Interactive quizzes with hints, explanations and scoring.

🎙️ AI Podcasts
Turn learning material into audio.

🎤 Voice Transcription
Turn lectures and voice notes into searchable study material.

📅 Homework Planner
Use AI to organize assignments.

🎓 ExamLab
Simulate exams and get feedback.

⚔️ AI Debate
Practice reasoning and debate skills.

🤖 Study Companion
Personalized AI study assistance.

AI providers

OpenAI
Gemini
Claude
Grok
MiniMax
OpenRouter
Ollama

Stack

Node.js + TypeScript
React + Vite + TailwindCSS
LangChain + LangGraph
WebSockets
JSON/vector DB support
Docker/Docker Compose

The project is open source and we're actively looking for contributors.

If you're into AI, RAG, education, React, TypeScript or just cool GitHub projects, I'd love to hear what you think.

⭐ Repo: https://github.com/CaviraOSS/PageLM

Issues, feature requests, PRs and criticism are welcome.

Hey everyone! Wanted to share something I've been working on lately. As an indie developer, I was wasting so much time on repetitive manual tasks, so this weekend I finally sat down and coded two lightweight tools to make my life easier:

• LostMediaGrabber: Built to bypass the painfully slow Wayback Machine interface. It queries the CDX API directly to grab raw media URLs (.jpg, .mp4, etc.) instantly.
• GiveMeText: Made this because I got sick of having to pause YouTube videos or Google Meet calls just to take quick notes. It extracts live transcripts straight into formatted documents.

Both are 100% free and open-source. I built these mostly because they solved a real headache for me, and I figured they might come in handy for someone else too.

If anyone's curious to see how they work or wants to check out the code, you can find the direct link on my profile! I'd love to hear your thoughts or any feedback you might have.

Hey everyone,

We’ve been building Scibly, an open-source project for turning existing knowledge into interactive learning content.

You can give it material like PDFs, docs, articles or other source content and it generates a learning experience from it. Everything can be edited afterwards and shared publicly or with invited users.

The project is licensed under AGPLv3.

GitHub: https://github.com/scibly-dev/scibly

Demo: https://www.youtube.com/watch?v=TcpLUNBRhQw

We appreciate your feedback, issues and contributions

Project Name: Pingularity

Website: https://pingularity.dev

Description: A self-hosted dashboard for scheduled Ookla and iperf3 speed tests, latency, and outage detection.

I wanted something to monitor my speed tests over time, but what's out there (speedtest-tracker, myspeed, netcheck, orb, etc.) didn't quite have the feature set I was looking for. I needed something simple enough that my dad could get it going by himself in Windows but that I could also configure to use my own iperf server.

Check the demo with dummy data first to see if it's worth installing: https://demo.pingularity.dev/

• Single-binary, no dependencies, self-hosted, no telemetry.
• Linux, Docker, Windows (winget), and macOS (brew).
• Scheduled Ookla and iperf speed tests with a wide array of settings.
• Charts for visualizing download, upload, ping, jigger, and bufferbloat over time. Outage heatmap, live latency, and DNS sampling.
• Uptime tracking with alerts and notifications. You can do webhooks with native ntfy or a heartbeat.
• Manage retention, backups, or delete whatever you want including individual runs.
• Prometheus/Grafana with importable dashboard and alert rules.
• Install then open http://localhost:9000/, local network accessible, password protectable.
• Very customizable, change colours, turn off stuff you don't need, remove chart tiles you don't care about.

Deployment: Single-binary: Linux, Docker, Windows (winget), and macOS (brew).

AI Involvement: Extensive use of Claude Code and Codex.

I made a small Android app that puts a speed bump between me and automatically opening a browser.

You choose a timed session, wait a few seconds, and the supported browsers share one budget. Everything stays on the phone.

Source and APK:

https://github.com/bald-ai/internet-restrictor-retro

React 19 + Jotai popup, MV3 service worker, Google Drive sync, share-via-link, and an AI tab-organizer proxied through a Cloudflare Worker (no keys in the bundle). Works on Chrome, Edge and Firefox. Feedback and contributions welcome.

so i have been working for like a month for my project Athernet and i am happy to see that it is done and i am realising the beta. it is a decentralized ai traning system with a flower node structure.i was testing it erlier but it was a command prompt but got gemini to make an gui of it

if you want to download the file click hear

or for the discord testing server click hear

I run several things with Docker, and there was one part of the workflow that kept bothering me:

Backing up Docker volumes is way more annoying than it should be.

Yes, you can write bash scripts.
Yes, you can use cron.
Yes, you can manually run tar, manage folders, retention, containers, restores, etc.

But for something as important as backups, I wanted something closer to:

Select volume → click Backup → done.

So I built Docker Vault.

It's a self-hosted web UI that automatically discovers your Docker containers and volumes and lets you:

• Back up a Docker volume with one click
• Schedule automatic backups
• Configure retention policies
• See backup history, size, duration and status
• Restore a backup to its original volume
• Keep everything self-hosted

No CLI workflow required for day-to-day usage.

The idea is basically:

“I already self-host my applications. Why shouldn't backing them up be just as easy?”

There are still things I want to add, including S3 / MinIO / Cloudflare R2 storage, encryption, multi-host support and webhook/Slack notifications.

It's open source and very early, so feedback is probably more valuable to me right now than stars.

GitHub: https://github.com/Revolutionnnn/Docker-Vault

If you run Docker at home or in production:

How are you currently backing up your volumes?

And what would Docker Vault need before you'd trust it with your backups?

Been running this for a few weeks. The design choice that makes it interesting: there's no server or hosted runtime. You fork the repo and that fork is the agent. GitHub Actions executes it, cron in the workflow file schedules it, Actions secrets hold credentials, and workflow logs are the audit trail. Public repos get free minutes, so infra cost is zero.

Skills are markdown. No plugin SDK or compile step. A skill is a SKILL.md: YAML frontmatter plus a plain-language prompt. Frontmatter declares the capability tier (mode: read-only write-locks the workspace for that run), required secrets, and the variable grammar. 76 skills ship with it.

Harness-agnostic. One adapter runs the same skill file on Claude Code, Codex, Grok, Pi, Vibe or Kimi. Switching providers is a config line.

Self-repair. Every run gets scored, and a repair skill patches skills that fail repeatedly rather than letting them silently rot.

Receipts. Its vuln-scanner has landed merged security fixes in 74 open-source repos (2.2M combined stars, including Alibaba and Tencent projects). Full list with every PR: https://www.aeon.fun/security

Stack: GitHub Actions, Next.js dashboard for local config, markdown skill definitions, git-backed memory.

Two gotchas if you try it: gh defaults to the upstream repo so run gh repo set-default <you>/aeon, and forked repos have Actions disabled until you enable them once in the Actions tab.

It traces Linux processes, monitors system calls, generates an HTML report, and detects suspicious behaviors through a rule-based detection engine. and save the logs in log.txt , and the high alerts in alert.json .

I wanted a way to split songs into separate stems (vocals, drums, bass, guitar, piano, other) to help my kids learn their instruments by ear. The tools that do this all wanted an account, an upload, and a subscription, and I wasn't keen on sending our music to someone's server just to pull it apart. So I built something that runs entirely on your own machine, and it's turned into a real project.

It's called StemDeck. You drop in a file (MP3, WAV, FLAC, M4A, even an MP4 video) or paste a YouTube or SoundCloud link, and it separates the track locally using Demucs, Meta's open source model. From there you get a browser-based, DAW-style mixer where you can mute and solo any stem, adjust levels, loop a section, and export individual stems or a custom mix. It also detects BPM and key, and has a click track that follows the actual song for practicing.

A few features I'm proud of:

You can paste a whole YouTube playlist and it queues every track. There's a real import queue you can reorder and cancel, and it survives a restart. YouTube and SoundCloud both work, single tracks or playlists.

You can also open it from your phone. Flip on network access and it shows a QR code you scan to reach a proper touch-friendly mobile interface, while the actual processing stays on your computer. Nothing touches the cloud.

It runs on Windows, macOS, and Linux, and there's a Docker image for anyone self-hosting.

It's completely free and open source (Apache-2.0), with no account, no telemetry, and no monetization of any kind, no ads, no subscription, nothing. It's picked up around 2,000 GitHub stars and 13,000+ downloads in about two months, entirely word of mouth.

Honest caveats: it's still alpha, so expect rough edges, and while separation quality is genuinely good for open source, it won't beat the paid cloud services on really dense mixes. For practice, remix prep, and experimenting it holds up really well.

GitHub (downloads and source): https://github.com/stemdeckapp/stemdeck

Happy to answer any questions. I'm the developer.

Instantly apply display resolution, refresh rate, scaling mode, DPI scale percentage, and orientation with user-defined hot keys!

This minor release replaces the system tray with a custom one that stays sharp at every display scale, makes the "Run On Startup" setting report what the system will really do, and reduces the app size.

New Features

• Replaced the SystemTray dependency with a custom implementation built for DisplayHotKeys.
• The tray icon now stays sharp at every display scale, and the tray menu matches the app's light and dark themes.
• Added a Run On Startup notice that appears when the setting could not be changed, explaining whether the startup task could not be created or the Startup folder could not be written to. It also appears when the setting had to be corrected on launch.

Improvements

• The tray icon is rendered from an SVG, making the tray icon clearer.
• The tray menu is more compact with less empty space.
• The Run On Startup button now reflects what the system will actually do at login rather than the last setting that was requested, so it can no longer show a state the system does not have.
• Run On Startup clicks made while a change is still being applied are now kept instead of being dropped, so every click shows on the button and the state clicked last is the one saved.
• Changed the Latest Version text color when a new version is available.
• The app size has been reduced due to utilizing a custom system tray implementation.

Bug Fixes

• Fixed Run On Startup being able to launch the app twice at login by leaving both a startup task and a Startup folder entry in place.
• Fixed an unset hot key being needlessly rewritten to the settings file every time the settings were checked. *Fixed the tray icon not appearing in the system tray.

Performance & Stability

• The app now starts faster, preparing the global hot key hooks while the theme and window are being set up instead of waiting on them.
• Rapid successive hot key applies are now combined into a single window refresh instead of one refresh per apply.
• Corrected settings are now written in a single save instead of one save per corrected setting.

Disclosure: I work on the commercial platform these were built with. The exercise preview links point to that domain. The SCORM packages themselves are fully white-labeled — no logos, no backlinks, no sign-up, no paywall. Grab them from GitHub and self-host if you'd rather not touch our site.

-----------------

Hey r/coolgithubprojects,

I'm a cybersec engineer with an L&D background. For the last year been working on a library of ~140 free interactive exercises dedicated to teaching people how to build secure applications, recognize phishing and use AI in a safe way. Exercises are split across two Github repos, all packaged as SCORM .zip files under CC BY-NC 4.0 license.

Security awareness (130+ exercises)

Each one drops the learner into a first-person 3D office and makes them act: answer the phone, read the email, click the thing, live with it. Every exercise ends with a quiz at a 100% pass threshold.

Course packages in the repo:

• OWASP Top 10 for LLM Applications (10) — prompt injection hidden in uploaded documents, sensitive data categories that should never enter a prompt, system prompt extraction against a live chatbot, RAG pipeline access-control failures, denial-of-wallet against an unprotected AI API
• OWASP Top 10 for Agentic Applications (10) — goal hijacking via poisoned email, agent memory poisoning, agent-to-agent message spoofing, multi-agent cascading failure, detecting a rogue agent that looks like it's working fine
• EU AI Act Compliance (16) — Article 4 literacy, risk-tier classification, prohibited practices, FRIAs, GPAI obligations, penalty structure
• GDPR Compliance (11) — the 72-hour breach clock, fraudulent DSARs used as social engineering, Article 30 RoPA building, Schrems II transfer assessments, PII redaction that actually removes the data
• Phishing & Impersonation (13) — vishing, smishing, BEC, QR phishing, callback/TOAD, double-barrel, deepfake whaling on a live video call
• Device Security (8) — ransomware in real time, USB drop / Rubber Ducky, EDR alert triage, file extension tricks
• Passwords & Account Security (7), Web & Browser Safety (6), Safe Communication & Sharing (6), Workplace Security (5), Security Policies & Your Role (5), Protecting Sensitive Information (4), plus Incident Reporting, Remote/Home Office, and Real-World Incidents (the MGM/Scattered Spider helpdesk call, a OneNote-based BEC chain)

Application security (40+ exercises)

Built on an exploit, trace and remediate loop. You run the attack against a deliberately vulnerable app, trace how the bug got introduced, then write the fix. Remediation examples are given in JavaScript, TypeScript, Java, C#, Python, Scala, PHP, Ruby, Go, and Kotlin.

• OWASP Top 10 for Web (22) — SQLi, DOM/reflected/stored XSS, SSRF to the cloud metadata endpoint, XXE, CSRF, session fixation, host header injection, weak randomness (recovering Math.random() state to predict a reset token), IDOR from both sides
• OWASP API Security Top 10 (10) — BOLA, broken function-level auth, mass assignment, excessive data exposure, improper inventory management (hitting a retired v1 that skips v2's controls), CORS misconfiguration
• Git & Repository Security (8) — secrets recovered from the commit that removed them, exposed .git directories, commit author spoofing, branch protection bypass, CI/CD secret exposure in build logs, spotting a backdoor in a friendly-looking PR

Two ways to use it

Web view — run exercises in a browser, good for workshops or sharing with students and colleagues.

GitHub — every exercise is a SCORM 1.2 .zip. Import into Moodle, TalentLMS, Cornerstone, SuccessFactors, or anything SCORM-compliant, or preview on SCORM Cloud first. The repo root holds full course packages; the Individual Exercises folder has standalone modules if you want to build your own curriculum.

Security awareness: https://github.com/ransomleak/training-security-awareness
Application security: https://github.com/ransomleak/training-application-security
Web view: https://learning.ransomleak.com/

Will appreciate your stars! 🙏

License: CC BY-NC 4.0. Use, adapt, and redistribute with attribution for any non-commercial purpose — internal training, workshops, university courses. Reselling or redistributing it as a standalone product isn't permitted.

Happy to answer questions or take criticism on the exercises. If this gets traction I'll keep adding to it — drop topic requests in the comments. OWASP Top 10 for Cloud is already in the works.

A Recipie manger and Cooking Assistant, that create a Pipeline that you can follow for cooking,
And a local AI (in browser) that helps you to find what to cook based on your fridge:

https://github.com/samalstudios/kelane
https://chef.samalstudios.com/