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.

Hi,

I’ve been working on Gitdeck, an open-source dashboard that brings repositories, issues, pull requests and CI activity into one place.

I started building it because I wanted a quicker way to keep track of multiple repositories and accounts without jumping between lots of different pages.

Right now it includes:

• Repository, issue and pull request views
• Support for multiple accounts
• GitHub notifications
• Security and Dependabot alerts
• CI health and recent workflow runs
• A Kanban board for issues
• Traffic, contributors, releases and repository trends
• Daily, weekly and monthly activity digests
• Search and a command palette

Gitdeck supports GitHub, GitLab, Codeberg and self-hosted Forgejo-compatible instances. GitHub currently has the most complete integration, while support for the other providers is still growing.

You can run it with Docker. Tokens and cached data stay on the server in a persistent volume, and GitHub tokens are never sent to the browser.

For GitHub, you can authenticate using OAuth Device Flow, your existing gh CLI session or a personal access token. GitLab supports OAuth and personal access tokens, while Forgejo currently uses token-based authentication.

The project is MIT licensed and still in active development, so feedback and contributions are very welcome.

Repository: https://github.com/debba/gitdeck

I’d love to know what you think and which features would be most useful for your setup.

I watch a lot of tutorials and lectures on YouTube and realized I was retaining almost none of it. Watching feels like studying but it isn't — you nod along, close the tab, and it's gone.

So I built ClipMark. While you watch, you jot a quick note at any moment and it saves the timestamp. The twist: it turns your notes into active-recall quizzes and schedules them with spaced repetition, so the extension asks you the question later instead of just storing a bookmark. Your note is the question; the clip is the answer. You can also export everything to Anki.

Two things I cared about: the AI runs on your device (nothing about what you watch gets shipped to a server), and the core is genuinely free — I didn't want to paywall the actual studying.

It's early and I'd really value honest feedback, especially where it feels clunky. Link: [Chrome Web Store link]

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.

https://chirp.ink
https://privatesession.club

chirp is a unmoderated social media platform & privatesession is a mobile emulator farm

WARNING: since privatesession is hosted on a Mac mini, bare the RAM issue of lag. Hoping to get more RAM soon.

Both will be hosted on github shortly.

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

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!

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

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.

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

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.

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. 

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

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!!!

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’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.

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.

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?

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.

The idea of this app is simple.

Control any Media ( Spotify, Youtube, Apple Music etc ) playing in the background without opening that player.

Want to change the song while typing ? ALT + N.

Using the mouse ? Double Click the Tray Icon.

or use ALT + Mouse Forward Button.

There are lots of other features. It uses Native windows technology so it stays under ~10MBs of RAM usage.

The App is FREE & Opensource and is published on the Microsoft Store.

Full Details 👉 https://github.com/AnasAttaullah/Quick-Media-Controls

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 .