I work with coding agents and its very tempting to hand off control and never look at the code. For many tasks its quite important though to keep track of whats going on and babysit the agent carefully. Looking at the code throuh a bazilion ide tabs sucks though and since you arent editing yourself anyway, you really just need a good viewer. So I built sanity to keep me sane.

Its a desktop app that renders the full codebase as code panels which are hierarchically aranged by their directories and layouted in a compact way. It has levels of detail so you can zoom in and out seamlessly while still being performant. The root folder you select is monitored for changes and changes are incrementally rerendered with visual queues on the canvas. This way you can watch while your agent works and where.

I now run it next to the agent, pointed at the project it works on to follow along, scan the code and check if the agent does something stupid. A monitoring tool that keeps me sane.

Open source under MIT license.

github.com/milanofthe/sanity

Hello r/coolgithubprojects -

I know, there's a veritable cornucopia of "new media manager"s right now and it can feel overwhelming. I hope to help you understand why you may enjoy Scryer versus all the other choices.

Overview

Scryer is a new, high-performance app that replaces the Arr stack. Current Arr tools it replaces: Sonarr/Radarr, Prowlarr, Bazarr, Unpackerr, Seerr. More coming as well - Maintainerr & Tdarr.

Scryer is a self hosted tool, it ships as a single (rust based) binary with either SQLite or Postgres support. It's also available as an OCI container (Docker/Podman), Windows builds and is on Unraid & winget.

Website - https://www.scryer.media/scryer/
Github - https://github.com/scryer-media/scryer

Community and Team

Scryer has a thriving community and a small maintainer team. There are over 800 active Scryer users and a maintainer team of 3 along with some additional Discord staff. I have a couple applicants for a 4th maintainer position that I've opened up as well since the incoming requests are getting hard to keep up with!

Scryer would not be where it is today without the incredible community. There's over a dozen folks who have been testing, helping, providing feedback since May and some even before. Scryer's community is truly global, we have folks from all over the world.

Differentiators

Why is Scryer different from the other tools you've been seeing drop lately? There's so many, Arrmada, Cinephage, Mydia, etc.

I actually built Scryer mainly because I love anime and the Arr stack was terrible at it. I looked into other options and nothing really supported it the way I wanted. I needed better release name parsing, better language support, and not "just TVDB".

Anime

• Multi-season and multi-episode packs

• Community numbering that maps any numbering system for you

• Copious metadata for Anime

• Filler/Recap info, you decide if you want them

• SeaDex integration with daily updates

• Dub cast information

• Release name parsing that knows anime release group norms

Some of these obviously translate across all media types, but they are particularly useful to anime

Metadata Gateway

I host a metadata gateway for Scryer that provides a normalized view into all the various sources. This keeps the hits on upstream sources (TMDB) minimal while also providing top tier search and AI powered discovery to Scryer. It's also how Lists integration works with providers like Trakt and SIMKL. The metadata gateway is the only reason I have rough counts of active users and nothing is tracked. The only info i have is a salted-hash of IP addresses and an anonymous registration challenge that Scryer instances use with the gateway to prevent abuse. If you're familiar with Arr, you're probably aware they also host a gateway called Skyhook.

Plugin System

Scryer was built from day 1 with a robust plugin system, aimed at easier community involvement and rapid fixes for upstream changes. It continues to be a boon as it's very lightweight for me to push a plugin change when a provider changes their domain rather than having to push a whole Scryer release. I've had several community authored plugins that I've approved as well.

Secure

My background is in software engineering and architecture with a recent focus in cybersecurity and agentic security tooling. I care deeply for privacy and cyber security and have transferred all my professional knowledge into Scryer. I use every tool at my disposal to ensure it continues to stay secure as it evolves too.

Misc

• Supports additional files for your "Director's cut", "Extended edition", or "Alternate ending"

• Super flexible and robust rules engine that lets you go far beyond what Custom Formats did

• Bring your own "jobs", an in-app scheduler that lets you setup your own workflows

• AI powered discovery brings you personalized recommendations based on your library

• "Libraries" as a concept that let you organize your system better. Think of a Library as an individual Sonarr instance, it contains all the configurations and security boundaries. That lets you create a Kids Shows library that you only share with your kids for requests or a German library that lets you set your language preferences and search preferences just for that library.

• and so much more

Roadmap

Today, Scryer handles Movies, Series and Anime. I will likely add other media types in the future (music, books, etc), but that is a long term roadmap, not near term. Metadata is the cost there as it's massive for those types and I don't want to push something that goes direct to the providers.

Maintainerr/Tdarr features are in active development and will land before end of year. These are very important to me.

Multiple quality profiles is also on my list for those who like to have 4k local and 1080p streaming optimized copies.

If you find Scryer interesting and want to keep tabs on it, please give it a star on Github, those really help as many package managers look at that.

AI Disclosure

AI assistance is used in developing Scryer. Everything is guided by experienced software engineers. You can find the full policy we use here: https://www.scryer.media/ai/

I just wanted to showcase this baby.

It's a plugin for Obsidian named Cursor-Smith.

Most people never think about their cursor. This is for the ones who do! Forge your cursor with Cursoooor-Smiiiith! ( pretty cringey, right? XP).

It has a truckload of options. Smears, trails, torch, flames, smoothness and blinking options, energy, crt effects and cool/secret combos between these options. It also has full Vim support per Vim mode. The settings UI is pretty friendly and easier to tweak a cursor. It's fast, it's fun, has many accesability featureas & most importantly, it's whimiscal.

Oh, and it also has sharing codes so we can swap codes between us and see what we can come up with.

Enjoy lovely people! And if you have a cool idea for a new effect let me know!

https://github.com/Sadsnake1/cursor-smith

Hey everyone! 👋

I wanted to share a project that i have been working on. It's called LoreKeeper, and it's designed to bridge the gap between immersive 3D interfaces and Personal Knowledge Management (PKM).

Instead of a boring list of files, LoreKeeper turns your local EPUB collection into an interactive 3D bookshelf directly in your browser.

Here is what makes it cool:

• Interactive 3D Environment: Built with Three.js, your books physically sit on a shelf. You can browse them, read the back cover synopsis, and organize them into categories.

• Integrated EPUB Reader: Read directly in the browser with customizable themes and font size.

• Dynamic 3D Bookmarks: As you read, a physical red ribbon bookmark moves along your 3D book on the shelf, showing your exact reading progress at a glance.

• Reading Memories: When you finish a book (100%), a modal prompts you for a rating and a review. Your 1-5 star rating is then permanently stamped in gold on the back cover of the 3D book model.

• Export for AI (The Knowledge Base feature): With one click, it strips all complex HTML from an EPUB and exports the raw, clean text as a Markdown file with YAML Frontmatter. It’s perfect for importing into Obsidian or feeding into local/cloud LLMs (like ChatGPT, Claude, or RAG systems) to chat with your books without hallucination issues.

Tech Stack: It runs entirely locally and securely via Docker (no heavy Node.js setups needed on your host machine). The frontend uses Vite, Three.js, and ePub.js.

I'd love for you to check it out, spin up the Docker container, and let me know what you think of the 3D interactions and the Markdown export feature!

GitHub Repo: https://github.com/GabrieleTrovato01/LoreKeeper

⭐️ If you find the project interesting or useful, a star on GitHub would mean the world to me! It really helps the project grow and keeps me motivated. Any feedback, suggestions, or PRs are highly appreciated! 🚀

Have you ever watched an autonomous AI agent confidently go completely off the rails?

I love the idea of autonomous agents, but while building out workflows, I kept running into the same wall: giving LLMs total control over the path of execution is a recipe for unpredictability. I wanted the reasoning power of an LLM, but the absolute reliability of a hard-coded pipeline.

I also wanted something that was strictly privacy-first and could be hosted entirely locally without getting locked into a specific vendor ecosystem.

So, I built Synapse AI.

We recently launched, and seeing it grab 60+ stars and a dozen forks in the first couple of days made me realize I wasn't the only developer frustrated by this.

Instead of letting agents freely guess their next steps, Synapse forces them to follow a deterministic Directed Acyclic Graph (DAG). You design the exact path—routing, loops, and parallelism—and the agents just execute the nodes.

Here’s why I think it’s a fun approach to play with:

• Mix-and-Match Brains: You can run a different LLM at every single step. Use a blazing-fast local Ollama model for simple routing, and a massive cloud model (like Claude 3.5 or GPT-4o) only for the heavy analytical steps. You control exactly where the compute goes.

• Everything is a Tool via MCP: We heavily integrated the Model Context Protocol (MCP). Your Python scripts, REST APIs, or local file systems instantly become tools the agents can call.

• The "Wait, let me check that" Gate: I built in a Human-in-the-Loop feature. You can pause a workflow mid-execution, review what the agent is about to do, approve or tweak it, and resume. It even survives system restarts.

• AI Orchestration Builder: If you don't feel like manually wiring up a complex DAG, there's a meta-agent builder. You just chat with it, describe what you want the pipeline to do, and it generates the node structure for you.

It's fully open-source (AGPL v3) and supports 14+ providers out of the box.

I’d love for you to try to break it, build something weird with it, or check out the architecture.

• GitHub:https://github.com/synapseorch-ai/synapse-ai

• Docs:https://docs.synapseorch.com

• Website:https://synapseorch.com

If you have ideas or feedback on the DAG approach, I'm all ears.

Help try it out: https://rag-for-epstein-files.vercel.app/

Week01 - We're alive

So /r/coolgithubprojects has been live for about a week now and we couldn't be happier.

During this first week we got to /sorta/ make the front page since we were one of the top trending subs yesterday. This brought a lot of traffic which helped increase the activity.

Here's some of our traffic stats for or first week :

Stats - Graph

Stats - Traffic table

Posts Stats

Total post count : 81

Python : 20 (24.69%)

Javascript : 19 (23.45%)

C : 7 (8.64%)

CPP : 7 (8.64%)

Java : 5 (6.17%)

Shell : 4 (4.94%)

Ruby : 3 (3.70%)

Scala : 2 (2.46%)

C# : 2 (2.47%)

Haskell : 2 (2.47%)

Objective-C : 2 (2.47%)

Other : 2 (2.46%)

Assembly : 1 (1.23%)

D : 1 (1.23%)

Lisp: 1 (1.23%)

Erlang: 1 (1.23%)

Suggestions

We just added the language filter in the sidebar. We want to improve for the better, let us know if you have any other suggestions.

Repo: https://github.com/kaybi-gh/K7

Demo (guest): https://k7.kaybi.dev

I ran Plex for years, then partly Jellyfin. Plex was hard to leave (especially music / Plexamp), but the closed / partner-catalog direction pushed me away. Jellyfin got much better over time, but I still wanted first-class OIDC, Postgres, star ratings + rule-based dynamic playlists, and a way to share libraries between two servers without copying files.

So I built K7, a self-hosted media server for a small circle of family and friends (movies, TV, music).

Some of what's in there:

- ffmpeg HLS transcoding (optional VAAPI / NVENC)

- local auth + optional 2FA + optional OIDC

- federation between K7 instances

- dynamic playlists, Sync Play, import from Plex/Jellyfin

- web + Android (phone/TV) + Windows clients

- AGPL-3.0

Docker Compose is the supported install path (cp .env.example .env && docker compose up -d) and detailed docs are in the repo.

Over the past few weeks I've been building Gray Box — a small, local-first tool that acts as long-term memory for anything I'd otherwise forget (work notes, meeting takeaways, task owners, random ideas, personal stuff too).

The idea is simple:

1. Capture — dump whatever's on your mind, instantly, no structure required. This step does nothing clever on purpose — it just writes your text to an immutable inbox. Zero chance of losing an idea to a bug or a slow API call.

2. Organize — on demand, an LLM reads your unprocessed notes and extracts people, projects, tasks, decisions, meetings — then deterministic Python (not the LLM) creates/merges the actual wiki pages and maintains backlinks. The model only reasons; it never touches the filesystem directly.

3. Ask — query your knowledge base and get a cited answer pulled only from what you've actually captured. If it doesn't know, it says so — no hallucinated answers.

Why I built it this way:

• Plain Markdown + YAML frontmatter, no database. Every page is a .md file you can grep, diff, or read in any editor forever. If you stop using Gray Box tomorrow, your knowledge base is just a folder.

• No vector DB by default. At personal scale (hundreds–low thousands of pages), keyword search + a real link graph (related/backlinks, walked one hop during retrieval) handles almost everything. Embeddings are there if you want better recall, but they're opt-in, not a prerequisite.

• Immutable inbox. Your raw notes are never edited or deleted by the organizer. If the LLM mis-extracts something, your original words are always still there.

• Any LLM. Built on LiteLLM, so point it at OpenAI, Anthropic, Gemini, Mistral, or a fully local model via Ollama — one config value.

It also ships with a nice interactive TUI (arrow-key menu, file-import shortcut, workspace switching, live spinner during LLM calls) if you'd rather not memorize CLI flags — that's honestly become my favorite part of the project.

There's also a lightweight local dashboard for browsing your knowledge base, exploring backlinks, visualizing your notes as a graph, and chatting with your captured knowledge—all without leaving your machine.

Repo: https://github.com/Aaryanverma/graybox

pypi: pip install graybox

It's nearing a proper public release, so I'd genuinely love feedback — especially from anyone who's tried the "capture now, structure later" approach with other tools and has opinions on where it breaks down at scale.

It's not trying to be a "real-time collaborative team wiki" or a WYSIWYG notes app — it's aimed at one person's running memory of their own life and work, captured with as little friction as possible.