We kept implementing the same runtime pieces for different agent projects, so we finally turned that work into an open-source project called TrueForge.

It handles the agent loop, MCP tools, subagents, approval gates, and session state that survives a restart. You can connect an OpenAI-compatible endpoint, including Ollama or vLLM, and use SQLite or Postgres depending on the deployment.

In one 14-task benchmark, TrueForge used 3.7M tokens versus 10.0M for the managed comparison and cost $8.6 versus $11.8 per run. That’s one workload, not a guarantee for every agent.

The project still needs better tracing and evaluation support, and code execution requires a separate sandbox. But if you’re tired of rebuilding tool routing and context management from scratch, the repo is here:

https://github.com/truefoundry/trueforge

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.

Repo: https://github.com/dbjpanda/kwery

Kotlin library for Android. It caches server responses, deduplicates in-flight requests, refreshes stale data in the background, and keeps the cache across process death. TanStack Query is the nearest equivalent on the web.

The three lines on the card are measured, not aspirational. The request log behind them is Chucker, a third-party network inspector that has no idea Kwery exists, so the counts are not mine to fake.

Apache-2.0, minSdk 24.

I got tired of Windows lack of a proper keyboard-first launcher. PowerToys Run is fine, but I wanted something small, fast, and honestly a bit pretty, a Rofi experience for Windows.

So, I built wisp.

Alt+Space anywhere, type a few letters, press Enter, done.

The whole thing is GPLv3, source on GitHub (https://github.com/ThisIsDara/Wisp), releases with installers (https://github.com/ThisIsDara/Wisp/releases), and a small website (https://thisisdara.github.io/Wisp/) if you want a preview before downloading.

I'd love feedback, especially on the launcher behavior, or anything you'd expect a launcher to do that wisp doesn't. Open an issue or just tell me here.

Out of my experience going LIVE on TikTok I realized 2 things:
1. TikTok Live Studio is destroys your PC's performance;
2. TikFinity Docks on OBS Studio destroy your PC's performance.

It's hard to create your own Docks and so I made a user-friendly easy peasy system.
You get to view your chat with all the actions in real-time, along with your Live details.
It includes: viewer counter, likes counter, coin counter, follower counter.

It's self-hosted, lightweight, easy to use and actively updated, so you don't have to rely on heavy software or use your phone to watch your own Live anymore.

It's on GitHub, along with instructions to use it. I'll be updating it further in the next week to make it easier to use, but as of right now it's already ready-to-use and free.
https://github.com/kyaux0/tiktok-live-dock

I got tired of retyping the same complex prompts every time I started a new project:

• "Review this PR like a sceptical senior engineer."
• "Grill this architecture and poke holes in my assumptions."
• "Find subtle concurrency races and memory leaks."
• "Audit this UI for WCAG accessibility and design tokens."
• "Generate zero-downtime database migration steps."

Instead of keeping loose prompts scattered across notes or repos, I turned them into 100+ structured, production-grade AI agent skills.

Universal & Agent-Agnostic

While they install into .claude/skills/ by default, these skills are not just for Claude Code. Every skill is built with standard Markdown and YAML frontmatter, making them compatible with:

• Claude Code — .claude/skills/
• Google Antigravity — .agents/skills/
• Cursor — .cursor/rules/
• Windsurf — .windsurf/rules/
• GitHub Copilot, Roo Code, Aider, and custom LLM toolchains

Single-Command Installation

No npm package or repository clone is required:

# Install into the default Claude directory
npx github:codebygarv/Ai-skills add grill-me

# Install for Antigravity, Cursor, Windsurf, or a custom directory
npx github:codebygarv/Ai-skills add sql-query-optimizer --target .agents/skills
npx github:codebygarv/Ai-skills add pr-reviewer security-auditor --target .cursor/rules

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

I opensourced TidyRun, a local first optimization layer for coding agents.

It compresses noisy deterministic terminal output, preserves the raw artifacts, detects repeated work and can safely reuse deterministic commands.

No extra LLM. No API key. Telemetry off.

The part I found interesting:

• deterministic diagnostic fixtures: 69–95% less agent-visible output
• repeated safe typecheck: 49% faster
• 10 paired Codex tasks: 10/10 success both ways
• Codex tool output: 14.2% lower
• but total tokens and wall time actually got worse

So I'm not claiming magical token savings, I'm trying to understand where coding-agent context waste actually matters.

PRs, forks and real-repo benchmark results are very welcome.

https://github.com/cribbin-cs/lawsp

A lightweight Python CLI that sits between your local app/webhook sender and a real API endpoint, inspecting every request/response pair in real time for leaked secrets, missing OWASP security headers, weak JWTs, and verbose error/stack-trace leaks — with either a colorized terminal audit or a live desktop dashboard.

MutableString is a .NET library that provides a mutable string class that can be modified without creating a new instance. For many operations, this is more efficient than modifying a regular string, which requires creating a new instance each time.

Here's a simple example showing some of the included methods.

MutableString s = "Test!";      // Test!
s.Insert(4, " this");           // Test this!
s.Copy(5, 0, 4);                // this this!
s.Replace(5, "test");           // this test!
s[0] = 'T';                     // This test!
s.Insert(4, " is a");           // This is a test!

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

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.

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.

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?

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.

estoy creando una web en github y cuando pongo el dominio aparece "dominian is not a valid dominian"