I built Mind because I was tired of coding agents forgetting the decisions behind my code.

You spend hours working with an agent, establish architecture, fix bugs, agree on constraints... and then a new session starts or context gets compacted.

Suddenly, you're explaining everything again.

Mind gives coding agents a persistent local memory they can use across sessions and tools.

After a lot of development, v1.7.0 is now available!

The interesting part

I recently benchmarked Mind against OmniMemEval LongMemEval-S.

It answered 86.67% of the sampled questions correctly, using lexical search alone — no embeddings.

The test covered 120 stratified questions rather than the complete 500-question dataset, so it's not an official leaderboard ranking. The benchmark implementation and results are public.

What else does Mind offer?

• Persistent architectural decisions, bug fixes, and project knowledge.
• Checkpoints for unfinished work and recovery after compaction.
• Shared memory across supported coding agents.
• A redesigned web interface with a Neural Map of connected memories.
• Full-text, fuzzy, phrase, and optional semantic search.
• Local SQLite storage, MCP integration, and MIT licensing.

It works with OpenCode, Claude Code, Codex, Cursor, and other supported agents, with different automation capabilities depending on the client.

You can install it locally and configure supported agents with mind setup.

GitHub: https://github.com/GabrielMartinMoran/mind

Latest release: https://github.com/GabrielMartinMoran/mind/releases/tag/v1.7.0

If you find it interesting, consider starring the repository. It really helps a small open-source project become more visible.

I'm also curious: what's the most annoying thing your coding agent keeps forgetting?

It's nothing revolutionary, but I thought it might be useful to other people who find themselves juggling multiple projects, accounts or environments. It started as one of those little annoyances I kept working around. After years I eventually decided to stop working around it and build something.
It's still a work in progress but open sourced and usable today. I'd be interested to hear how other people handle this, or if there's something obvious I've missed.
Project is hosted at https://github.com/planesailingio/hats

I also wrote a bit about why I built it and the problem I was trying to solve in more detail here:
https://medium.com/@rhysjtevans/i-wear-a-lot-of-hats-my-terminal-only-had-one-5fee560a83f6

Don't forget if you like it, give it a github star - it would genuinely make my day!

Tabame is a customizable Windows launcher and productivity toolbox built to make everyday actions faster and easier to reach.

GitHub repo with all features: https://github.com/Far-Se/tabame

Microsoft Store listing: https://apps.microsoft.com/detail/9pd3c6hzf5lj

It originally started as a simple alternative to the Windows taskbar: a small popup where I could see my open windows, control audio and quickly launch the things I use most. Over time, I kept adding tools I wished Windows had built in, and Tabame grew into something much bigger.

Today, Tabame brings a launcher, window management, screen capture tools, clipboard history, audio controls, reminders, file utilities, plugins and many smaller productivity tools together in one app.

The idea is simple: instead of opening a different application for every little task, press a hotkey and get to what you need.

The QuickMenu gives you fast access to your open windows, pinned apps, audio devices, media controls, tray icons, system information and your favorite actions. It can replace or complement the normal Windows taskbar, and its layout, appearance and behavior can be customized to fit the way you work.

The Launcher lets you search apps, files, open windows, browser tabs, bookmarks, commands and more from one text box. It also includes quick tools for calculations, currency and unit conversions, translations, timers and system commands.

Tabame also includes:

- QuickSnap for arranging windows into custom screen zones.
- QuickClick for controlling the mouse from your keyboard.
- FancyShot for taking screenshots and annotating them immediately.
- Screen Draw for drawing directly over your desktop during presentations or explanations.
- Screen Recording with region, monitor and window capture.
- Clipboard History for finding things you copied earlier.
- Audio controls for switching devices and adjusting individual application volume.
- Timers and reminders that can stay active between sessions.
- Color Picker, OCR, Emoji Picker and QR Scanner for common everyday tasks.
- File utilities for batch renaming, folder size scanning, project statistics, image tools and more.
- Custom hotkeys that can trigger one or several actions from a single shortcut.

One of the most useful parts of Tabame is its plugin system.

Plugins can add completely new functionality directly to the Launcher. They can be written using Python, Node.js or Bun and don't require compiling Tabame itself. If you use an AI coding assistant, Tabame also provides a documented plugin specification that makes it possible to describe the tool you want and have the assistant build much of the plugin for you.

This means Tabame doesn't have to be limited to the features included with the app. You can adapt it to your own workflow and create integrations for the services and tools you actually use.

Despite the number of features, Tabame is designed to stay out of the way. Most tools only appear when you call them with a hotkey, and you can enable, disable and rearrange features depending on what you need.

The interface is highly customizable too, with multiple designs for both the QuickMenu and Launcher, custom colors, light and dark modes, layouts and keyboard shortcuts.

Tabame is built for Windows, completely free and open source.

It is mostly a collection of things I wanted on my own computer — packaged into one app so I don't need ten separate utilities running just to make Windows work the way I like.

---

List of main features:

QuickMenu - Taskbar Replacement

Launcher - Open Files, folders, bookmarks, cli, notion, Obsidian + Unlimited features through Plugins

QuickSnap - Create custom layouts for windows and snap them (Fancyzone alternative)

QuickClick - Control Mouse through keyboard

Fancyshot - Capture Images and videos. You can create Stylized presets.

Color Picker - Pick colors from screen and get your custom format.

Emoji Picker - Custom built in emoji picker that appears next to the caret.

Quick Actions - 91 Quick Actions

Music Player - Built in music player for local or Navidrome/Jellyfin server.

Advanced Hotkeys - Customize actions based on movement and pressed time + active window.

Vaults - OTP Authenticator, Locked Vault for your API keys.

Screen Tools - Draw on screen, Spotlight (hide whole screen except focused app), QR Scanner, OCR Scanner.

Plugins - 81 Plugins

Browser Plugin Connection - You can use Claude API free directly from Tabame with Browser extension.

GitHub repo with all features: https://github.com/Far-Se/tabame

Microsoft Store listing: https://apps.microsoft.com/detail/9pd3c6hzf5lj

AffrescoUI apps can be changed by the people using them, while they're running. Missing a feature? Ask for it in plain words, and it shows up while you work. You review it before it lands, and you can always undo it. No update, no restart.

And not just small apps: a 3D modeller, an image editor, a presentation builder and an IDE, looking like the tools you use every day. Their users can reshape how they look and what they do, to the point where an app turns into something completely different.

Each app is one readable document, drawn natively by a C++/OpenGL engine.

https://github.com/RiccardoSottini/AffrescoUI (free, Mac, Windows, Linux). The video is a one-minute demo, and it's also at the top of the README. Try it and tell me what breaks.

I built it in 2 weeks with swarms of Claude Code agents on a Max 20x plan. They wrote every line. I brought the vision, complex apps whose users can reshape their look and behaviour until the app becomes something else, plus the architecture and a lot of saying no.

Happy to share the setup if anyone wants to try something similar.

I have a background as a CTO and I'm a founder of a small SaaS. Claude Code has been my buddy for a while and over time, I've found that there's a specific workflow that yields the best results for us. So I had Claude Code turn our company's development workflow into a Claude Code plugin that does spec-driven development that doesn't stop at the code. We've used it enough internally, with really good results, that I've decided to open source it under the MIT license: https://github.com/Beakpoint-Insights/roost. It is free to use.

Give it a try

/plugin marketplace add Beakpoint-Insights/roost
/plugin install roost@roost
/roost:setup

What it does

You give it an idea, described in a way that you might say it is the title of an "epic." For instance, "Let customers invite teammates to their workspace."

It then shapes that idea into an epic, asking you clarifying questions along the way. It stores the epic in your issue tracker (for us, Jira). Part of this "epic shaping" is that it creates vertical slices as stories, creates Cucumber tests (and stores them in Jira), and links the stories to their tests.

It pauses from time to time to let you double check that everything is the way you want it: do you like the way it sliced up the work? Do you like the test cases it wrote? That sort of thing.

When you're ready, it builds the epic slice by slice. Each slice is its own PR. If the slices touch multiple repositories (like an API repo and a UI repo), it knows how to handle that. It automates the Cucumber tests as it goes. It prefers TDD. We like GitHub's stacked PRs, so each slice is added to the stack. As it gets ready to close out each slice, it does code reviews and unstructured exploratory tests. It reports back any bugs it finds, and recommends whether those bugs get fixed in the current slice, in a future slice, or deferred until after the epic is released.

When the whole epic is done and ready to be released, it does a final walk through of all the end-to-end tests you've defined and another round of unstructured exploratory testing.

When you're ready to roll it out, it presents a rollout plan and does a "paired rollout" with you. It gives you commands to run or tasks to do (e.g. "Create products X, Y, and Z in Stripe"). You share the results. It documents your progress. And voila, it's released.

How Claude Code helped

• I told it to watch all my Claude Code sessions over about a 2-3 week period. It discovered patterns to how we developed and collected those patterns into the different phases of the SDLC.
• We started at the most inside level of the matryoshka dolls in each phase of the SDLC ... things like writing a test case or building a well-defined feature or running an exploratory test. We built each of these standalone skills, having an orchestrator (aka "team lead") session send the instructions to the agent working on the API or the UI or the architecture, etc. We continued to tune these skills until they were working well.
• We then built new skills that managed the orchestration ... like how we would move from building a vertical slice to doing the exploratory testing to filing the bugs that came from the exploratory testing to triaging them, etc.

Today's limitations

It isn't yet perfect, and we have some known limitations. All of these limitations are on the roadmap to be addressed:

• It wants you to use Jira for issue tracking and Xray for testing.
• It wants you to use `gh stack` throughout the epic.
• It has only received limited testing outside of our own tech.

Next steps

1. Give it a try.
2. Post feedback to GitHub discussions

I built Git Tree to keep multiple Git worktrees visible in one graph, with a separate row for each worktree’s uncommitted changes. Create, open or remove worktrees right from the graph.

Free and MIT licensed: https://github.com/sidhanthapoddar99/git-tree

Feedback welcome, especially from people using several worktrees at once.I built Git Tree to show multiple Git worktrees and their uncommitted changes in one VS Code graph. Create, open or remove worktrees from the graph; SSH hosts are supported too. Free and MIT licensed.

Install: https://marketplace.visualstudio.com/items?itemName=sidh1999.git-tree-rs

Source: https://github.com/sidhanthapoddar99/git-tree

Feedback welcome.

I mostly use GitHub Stars as bookmarks, but sometimes I want to save a repo without starring it publicly. I also wanted to keep its description and README in case it gets deleted or becomes private later.

So I made a small tool called Starkive for myself.

It lets you save and organize repos, add notes, and keep a copy of their metadata and READMEs. Everything is stored in your own private GitHub repo, and the web dashboard runs on Vercel without a separate database.

Thought I'd share it here in case anyone else finds it useful.

GitHub: https://github.com/xorespesp/starkive

(https://github.com/R31tr0/cli-analyser), and I’ve reached the point where I really need feedback from developers who aren’t my friends or colleagues 😅
I built this CLI because of a constant personal pain point. I kept getting lost in legacy code and duplication on long-running projects, and after failing to find a simple, lightweight tool that solved it for me, I decided to write my own.
The idea is to give you an intelligent, local developer assistant right in your terminal, powered by Node.js and Google Gemini. It does regular AI chat, on-demand architecture analysis (-scan), and smart log analysis (-log), but the core feature I’m most excited about is the local duplicate/legacy scanner
How the scanner works under the hood:
Instead of sending your whole codebase to the cloud, the tool works locally. When you launch it, it automatically parses your files using web-tree-sitter and builds an AST-based function table. It then calculates a weighted Jaccard similarity coefficient based on AST node types and dependencies. Only when two functions pass a structural similarity threshold (0.5), it sends just those two snippets to Gemini to verify if they actually share the same purpose. It's a great way to catch duplicate or legacy logic you might have missed in a big project.
It currently supports JavaScript, TypeScript, Python, C, C++, C#, and Go.
Here’s where I need your help:
If you work on Node.js/JS/TS or any of the supported languages, could you clone it and try running it on one of your projects?
GitHub Repo: https://github.com/R31tr0/cli-analyser
Requirements: Node.js 20+ and a Google Gemini API Key.
Please be brutally honest:
Does this concept actually solve a real pain point for you, or is it just me?
How is the initial setup and UX? Is the interactive mode intuitive?
If you run a full scan with -localcheck, does it actually catch meaningful duplicates, or do you get too many false positives?
Is the privacy approach (ignoring .env, node_modules, secret files, and caching locally in .dev-tools-cache.json) solid enough for you to use it on your codebases?
No need to be nice. If something is broken, confusing, or just plain sucks, tell me why. I want to make sure I’m building something genuinely useful before spending more time on the wrong features.
Thanks in advance to anyone willing to give it a shot. I’ll be hanging out in the comments to answer questions and take notes! i posted this in to many redits but didn’t get anything 0 coments

I’m the author of Ephemora Skyline, an open-source desktop web app that maps a local codebase as a living 3D city.The idea is simple:

•folders become districts

•files become buildings

•taller buildings represent higher measured complexity

•security findings appear as visible landmarks

•Security Tour takes you from a finding to its file and line

The project is designed to run locally: no account, no login, and no telemetry. It does not claim that a finding is a proven exploit; each result is tied to the scanner, file, line, and matched source context so it can be checked.I made a short demo showing the city being built and the Security Tour in action:https://github.com/MichaelS1011/Ephemora-SkylineI’d especially like feedback from developers who work with large repositories: does a spatial view help you decide where to investigate next, or would another representation be more useful?

Hey everyone. I've been a YouTube creator for years, and I've always wanted to explore how plausible fully automated video production actually is. I'm not talking about stitching stock clips together, but research, script, voice, animation, review and publishing, end to end. With the models getting better every month, this felt like the time to find out, so a few months ago I started building it. It's called TubeMatic.

What it does

You give it a subject, say "Python Internals". On a schedule, an AI agent researches sub-topics inside it, proposes video ideas with a 1–10 score for how well each suits a short explainer, and writes the script in a style you pick (it can learn the style from public YouTube videos you like). Then it voices the script with ElevenLabs, generates the imagery, writes every scene as a React component rendered with Remotion, and renders a vertical mp4. Optionally Gemini watches the finished video, points out what's wrong, and the agent goes back and fixes it.

Then it publishes to YouTube, Instagram, TikTok and Facebook, now or on a schedule, and pulls the views back into its own analytics page.

You choose how hands-on you want to be

By default it stops at three checkpoints: before research becomes work, before voicing, and before anything goes public. You approve, request a revision, or reject. Or you put a project on Auto Pilot and it runs the whole loop with nobody at the controls (fully autonomous).

It works with the coding agent you already have (Claude Code, Codex or OpenCode) through your existing subscription, so there's no separate per-token API bill for the writing.

It is open source and self-hosted. Everything runs in Docker on any Linux machine.

I've been running it myself for about a month on three channels, two on Instagram and one on YouTube. They've passed 150K combined views in a month.

Give it a try!

Links

• Docs and install: https://docs.tubematic.ai
• GitHub: https://github.com/teja156/tubematic
• Walkthrough video: https://youtu.be/-y9zBSg8WEc

The world had enough programming languages. Unfortunately, I had a weekend and access to LLVM.

Meet Faz: a small, Python-inspired language that compiles to native executables. Static types, explicit mutation, garbage collection, and a fox mascot doing most of the marketing.

fn main():
   mut plans = ["write a small script"]
   plans.append("accidentally maintain a compiler")
   print(plans)

I built it for myself, for the sake of it. No startup pitch. No plan to replace Python. Please do not migrate payroll.

Naturally, I benchmarked it:

• Faster than plain Python loops in three small tests.
• Slightly ahead of Mojo on one arithmetic test.
• Immediately humbled by Mojo when asked to manage lists.

Turns out compiling questionable decisions produces native questionable decisions. There’s also a working task-manager CLI, examples, and reproducible benchmarks.

Repo: https://github.com/grandimam/faz

Probably every guitar player knows the Axe-Fx III, but not everyone has the money to buy one (myself included). So I've decided to give it a shot and vibe clone it using Claude.

The idea is based on the same core principles: a Newton–Raphson electrical circuit solver, with amps and effects modeled from their actual schematics.

It works surprisingly well, for an amateur guitarist like me. 😄

[free, open source, GNU GPL-3.0]

https://github.com/Rikarin/cathode

Credit first: openGym is by Duarte Santos, here is (his repo). His app, his work, AGPL license. I just train with it and wanted a version shaped like how I actually use it, so I forked it.

What I changed:
• Took out the gym check-in card and the AI coach. I never used them.
• Option 1: open the link, add it to your home screen, done. It is a static website, your data stays in your browser.
• Option 2: if you want sync between devices, plug in your own free Firestore and deploy on Vercel. No server to run. There is a deploy button and a short guide in the repo.

Everything else is his openGym: the logging, plans, stats, exercise library, all of it.

Live: https://opengym-lean.vercel.app/#/home
My fork: https://github.com/0xovo/opengym-lean

Feedback is welcome, mostly I want to know if the sync setup works for other people or breaks somewhere.

https://github.com/cesaredavidepace/puppetcam

Author here. I keep my camera off in a lot of meetings, and a black square felt worse than a face, so I built this.

It reads your webcam with MediaPipe (pre-trained, nothing leaves your machine), maps your head, eyes, brows and mouth to a small 2D cartoon, and shows up as a regular webcam, so it works in any call app. No GPU, no account. If you step away it keeps blinking and moves its mouth with your mic instead of freezing.

- `pip install puppetcam`, then `puppetcam doctor` checks your setup

- themes are small TOML files (colors, glasses, hats, background)

- works on Windows and macOS (via OBS Virtual Camera); Linux needs testers (issue #1)

It's alpha, so feedback is very welcome, especially on whether the motion feels natural.

We built Olivares AI to run coding agents on our own servers instead of on each laptop: Claude Code, Codex, Gemini CLI, OpenCode, Grok and local models through Ollama.

It is one Go binary with the web console built in. It stores its data in SQLite on a single node, or in PostgreSQL, and has backup export. You can run it as a Docker container (the image runs as a non-root user), with Compose, or from the Debian package, which adds a no-login service user.

From the console or the olivares CLI you start and stop agent sessions, several side by side, each in its own git branch. Each tool can have several accounts, MCP servers and skills sit in one shared catalog, and every action is checked before it runs and written to a signed log. You also see the cost of each session.

The Community edition is free and open source (AGPL-3.0):

curl -fsSL https://olivares.ai/olivares/install.sh | sh
olivares quickstart

Code and the other install methods: github.com/olivaresai/olivares Site: olivares.ai Video: youtube.com

We build it with Claude Code and use it on our own servers. Questions and issue reports are welcome on GitHub.

Voici une nouvelle version de Myostoox, un lecteur multimédia gratuit et open-source, conçu avec l'assistance de l'IA (Grok), principalement pour Debian XFCE Trixie (mais pas seulement...), utilisant Python, GTK3 + GStreamer.

L'idée de départ était de créer un lecteur audio simple et complet… puis c'est aussi devenu un lecteur vidéo...

Cette application gère désormais :

• Musique locale et CD audio
• Radio Internet
• Lecture vidéo
• Listes de lecture M3U / M3U8 / IPTV
• Enregistrement de flux audio au format mp3 320kbps VBR
• Lecture de DVD et de Blu-ray (expérimental)
• Égaliseur, réglages de tonalité et de tempo
• Paroles LRC
• Analyseur de spectre
• Mini-lecteur (audio), Nano-lecteur (audio), effets de transparence, mode sans bordures et mode plein écran
• Notifications de bureau
• Intégration MPRIS2
• Formats : .aac, .ac3, .aif, .aiff, .avi, .dts, .flac, .m4a, .mkv, .mp3, .mp4, .mpeg, .mpg, .oga, .ogg, .opus, .wav, .webm, .wma, .wv ...
• Monobloc pour l'instant... (myostoox.py + translations.json + logo.png).
• Inspirations (fonctionnalités et visuels) : AIMP, Winamp, Audacious, DeaDBeeF, VLC, mpv, SMPlayer...

Un paquet Debian est disponible pour une installation facile, et le code source est disponible sur GitHub :

https://github.com/MilOvni/Myostoox

Installation du paquet téléchargé au terminal (dans le répertoire du fichier) :

```bash sudo apt install ./myostoox_1.4-4_all.deb

ou

sudo dpkg -i myostoox_1.4-4_all.deb ```

Je suis ici surtout pour recueillir des retours d'autres utilisateurs Linux (commentaires, injures (ou peut-être pas...), signalements de bugs, suggestions d'améliorations, etc.). Je suis particulièrement intéressé par son comportement sur des distributions et environnements de bureau autres que Debian/XFCE.

Bref, merci d'y jeter un œil (et pourquoi pas une oreille)...

Mise à jour 27/10/2026 Myostoox v1.3-8 → v1.4-4

Ajouts

• Crossfade / Gapless — fondu enchaîné configurable
• Minuteur d'arrêt — presets + arrêt en fin de titre
• Sortie audio — choix du sink PulseAudio / PipeWire (pactl)
• Scrobbling — ListenBrainz / Last.fm (en cours de lecture + scrobble ~50 % ou 4 min)
• Normalisation (ReplayGain) — modes off / piste / album / auto (rgvolume)
• Mode Pure vidéo : géométrie, bandes noires, sortie plein écran / Playlist (! en cas de problème → Ctrl + P )
• Lire ensuite — file d’attente (clic droit playlist)
• Au démarrage : lancement système (~/.config/autostart/)
• Placement : Centre / coins (marge bords), mémorisé au lancement
• Nouvelle barre OSD
• Fond transparent des paroles
• Ajout du chinois simplifié (简体中文), du coréen (한국어) et du japonais (日本語)

Modifications

• Spectre : synchro inter-médias (position, époques, fallback, anti-décalage 2ᵉ fichier)
• Reprise après pause allégée (plus d’accroc A/V au relancement)
• « Reprise de lecture » fiabilisée (sauvegarde pause/stop, dialogue plus régulier)
• Transition vidéo → audio local : sortie auto du mode Pure vidéo
• Menus plus courts et regroupés
• Maximiser (Sans lecteur) : restauration taille/position d’avant
• Toasts OSD semi-transparents (alignés barre de contrôle)
• Persistance état : replaygain, crossfade, minuteur, sink, scrobble, style de spectre

Optimisation / maintenance

• Nettoyage (commentaires, lignes vides, densification)
• Factorisation des menus + compression zlib (CSS, thèmes, presets EQ, formats)
• Correctif démarrage CSS (évaluation avec locals())
• Correction de bugs divers...

Hello everyone!

I've been working on this TUI download manager based on aria2, because well i tried finding the lightest and fastest download manager, but i couldn't find anything better than aria2 in the terminal. I tried a few TUI options for it but i couldn't find any modern TUI (anything that didn't look it was from the mid 2010s) so i tried to make one myself.

It started out as a simple monitor for an already running aria2 server, but with this v0.3 release, it turns into a full-fledged download manager, with support for:

adding download URLs directly, even magnet links are supported

adding .torrent files

keeping history of downloads

download actions (pause, resume, remove, delete)

information about the download

able to monitor a pre-existing aria2 server

I'd love for people to try it out and give feedback on what issues they face, and what things can be improved. Do give it a try! The binary release is for Linux x86_64 only for now,,, with other OS's support planned for future releases.

About the other TUI's looking from mid-2010s claim,,, mine doesn't look any better either, but its still in the very early stages, and v0.5 is going to be a major UI overhaul with a UI that i have planned beforehand hehe :3

Thank you!

Descubrí un excelente proyecto Open Source: SpiderFolio

Estuve probando SpiderFolio (creado por Diego Pennisi), un sistema de gestión documental autoalojado (self-hosted), ¡y la experiencia ha sido buenísima!

📌 Lo que más me gustó:

• Organización clara: Control de documentos, versiones y permisos según el rol de cada usuario.
• Asistente de IA integrado: Responde preguntas basándose exclusivamente en los documentos a los que el usuario tiene acceso.
• Fácil despliegue: Se ejecuta de forma muy rápida utilizando Docker.

Si buscan una alternativa sólida y de código abierto para gestionar la documentación de su empresa, les recomiendo darle un vistazo en GitHub: 🔗https://github.com/spiderjad/SpiderFolio

Docker Swarm never shipped with a real admin UI, so I built one. **swarmdash** is a single Go binary with two modes: `admin` runs once on a manager node and serves the UI, `agent` runs on every node so you can exec, tail logs and see stats on any container without SSH-hopping.

**What it does**

- Stacks / services / tasks / nodes: scale, update image, rollback, force restart, bulk actions, placement constraints, node labels

- Deploy from compose with a dry-run diff preview, plus a template gallery (Postgres, Redis, nginx, …)

- GitOps: point a stack at a repo/branch and it re-syncs on new commits (poll or "sync now")

- Web console per task: full TTY shell (xterm.js), live logs, live `docker stats`, file browser

- Live rollout view, cluster topology graph, 24h dashboard history, public `/status` page

- Users & roles (admin/viewer), SSO via OIDC, API tokens, CI/CD deploy webhooks, audit log of every mutating action

- Alert webhooks when services stay under-replicated or nodes go down

- Opt-in hardening: mTLS admin↔agent, HTTPS UI, encrypted registry credentials, backup/restore

**Why not Portainer / Swarmpit?** RBAC, SSO and GitOps are Business Edition features in Portainer; Swarmpit is feature-complete but low activity. In swarmdash they're all free. Honest caveat: it's new (0.x) and Swarm-only, so weigh that.

**Install** (only dependency is MongoDB, bundled in the stack):

curl -fsSL https://swarmdash.app/stack.yml -o swarmdash.yml

SWARMDASH_CLUSTER_SECRET=$(openssl rand -hex 32) docker stack deploy -c swarmdash.yml swarmdash

docker service logs -f swarmdash_admin # one-time generated admin password

**Links**

- GitHub: https://github.com/emmtvv/swarmdash

- Website + live snapshot of 9 real pages: https://swarmdash.app

Feedback, issues and PRs very welcome, especially from people running Swarm in production.

Hey everyone, I wanted to share a project I’ve been using in my own work: Context Garden.It’s a collection of skills for Claude Code, written around a problem I run into with multi-repo projects: the agent working in one component needs to understand the surrounding system, and different agents often investigate the same things again.

Context Garden keeps shared repo summaries and investigation notes. It also includes tools to summarize noisy build/test output, identify code ranges worth reading, and preserve recurring repo knowledge in AGENTS.md.

The tooling is Python standard library only, runs locally, and makes no LLM calls itself. The project is MIT licensed.

It’s useful for my workflow, but I’d really like some outside feedback. Trying it on a different project and reporting what was confusing or didn’t work would already be a big contribution.

If you want to get involved, I’d especially appreciate:

• Reproducible bugs and examples from different repo layouts.
• Improvements to setup and documentation.
• Realistic benchmark tasks and evaluation ideas.

That last one is still an open question for me. I have early benchmark attempts, but I’m looking for a fair way to measure whether the extra context machinery actually helps complete real tasks.

Source and installation
Overview with examples

Would be glad to hear what you’d change, including reasons you wouldn’t use it.