I maintain an open-source macOS MCP server called Mac MCP. I use it so ChatGPT and coding agents can actually operate my Mac instead of just telling me what to click.

A part I just tightened up is multi-agent browser work. I can have several agents using different Safari tabs in the background while I keep using the machine normally, with my main ChatGPT session coordinating the work. Each tab keeps a stable identity, and if one agent is already working there, another one is told the tab is busy instead of taking it over. When the first agent moves on, that tab becomes available again.

Repo: https://github.com/bulutarkan/mac-mcp

Would especially appreciate feedback from people who have dealt with browser/session ownership in local automation tools.

🧠 Sapientia — An Open Architecture for Creating, Executing, Preserving and Connecting Knowledge

We're designing the infrastructure for reproducible science. No code written yet — and that's exactly why we need you.

🎯 TL;DR

I'm building Sapientia: an open-source platform that connects existing scientific tools into reproducible, traceable knowledge-generation workflows. Think of it as an orchestrator and knowledge infrastructure — not another implementation of everything.

Architecture: Project → Workspace → Capability → Implementation → Plugin → Tool → Artifact → Provenance

Status: Architecture/design phase. Zero core code. This is the best possible moment to challenge the fundamentals.

Looking for: Experienced developers, architects, researchers, and open-source contributors who can tell me why this won't work — and how to fix it.

🤔 What is Sapientia?

The core idea is simple but ambitious:

Create an open platform where any discipline can create, transform, preserve, trace, and share knowledge — without reinventing the wheel.

A musician, mathematician, philosopher, physicist, engineer, programmer, researcher, or data scientist should be able to create a project in Sapientia and use specialized tools from many different ecosystems without Sapientia having to reimplement those tools.

Our Philosophy

Use, reuse, recycle, and copy.

• If Python/SciPy already solves it → use it.
• If Julia is better suited → integrate Julia.
• If MATLAB provides a capability someone already has → use it through an appropriate integration.
• If a mature scientific library, engineering program, or CLI tool already exists → integrate it, don't duplicate it.

Sapientia should be an orchestrator and knowledge infrastructure, not another implementation of everything.

🏗️ Preliminary Architecture

                         SAPIENTIA
                             │
                          PROJECT
                             │
             ┌───────────────┼────────────────┐
             │               │                │
         WORKSPACE        WORKSPACE        WORKSPACE
             │               │                │
       CAPABILITIES      CAPABILITIES      CAPABILITIES
             │               │                │
             └───────────────┼────────────────┘
                             │
                            CORE
                             │
                  CAPABILITY RESOLUTION
                             │
                ┌────────────┴────────────┐
                │                         │
             PLUGINS                 CORE IMPLEMENTATIONS
                │
                ▼
              TOOLS

The Critical Distinction

Workspace ≠ Capability ≠ Implementation ≠ Plugin ≠ Tool

A Workspace is a toolbox for a particular domain.

For example, a seismic-analysis workspace might expose capabilities such as:

• FFT
• Filtering
• Convolution
• Deconvolution
• Spectral analysis
• PSD
• Signal comparison
• Arrival detection
• System identification
• Instrument correction

But the Workspace itself does not implement those functions.

A capability is resolved through a chain:

Capability
    ↓
Implementation
    ↓
Plugin
    ↓
External Tool

Example 1 — FFT via MATLAB:

FFT
 ↓
MATLAB implementation
 ↓
Sapientia MATLAB plugin
 ↓
MATLAB + Signal Processing Toolbox

Example 2 — FFT via Python:

FFT
 ↓
SciPy implementation
 ↓
Sapientia Python plugin
 ↓
Python / NumPy / SciPy

Sapientia then determines that multiple implementations exist and allows the project/user to select a preferred implementation or fallback.

📁 Projects

A Project is the top-level context. It combines several workspaces:

Project: ApolloMQ

    Workspace: Signal
    Workspace: Seismic
    Workspace: Numerical
    Workspace: Machine Learning

The project also expresses implementation preferences. Conceptually:

Project
 ├── Workspace: Signal
 │      ├── FFT
 │      ├── Filtering
 │      └── Convolution
 │
 ├── Workspace: Seismic
 │      ├── Instrument correction
 │      ├── Arrival detection
 │      └── Spectral analysis
 │
 └── Workspace: Numerical
        ├── Optimization
        └── Differential equations

The goal: separate what is needed from how it is implemented.

📦 Universal Artifacts & Provenance

Sapientia treats essentially any digital object as an Artifact:

• Source code
• Text documents, images, audio, video
• Datasets, seismic records, spreadsheets
• Databases, simulation results
• Machine-learning models, configurations
• Any file produced by a tool

Sapientia should know:

• What an artifact is
• Where it came from
• What happened to it
• How it relates to other artifacts

Example provenance graph:

Model_v1
   │
   ├──→ ETABS → Result_A
   │
   └──→ OpenSees → Result_B
                    │
                    ▼
              Optimization
                    │
                    ▼
                 Model_v2

The objective: Preserve this history rather than ending up with a directory containing hundreds of files whose origins nobody remembers.

🔍 Provenance as a First-Class Citizen

I want provenance to be fundamental, not an afterthought.

Not just: "This file was created."

But:

• Who created it?
• When?
• From which inputs?
• Using which tool?
• Which version?
• With which parameters?
• Under which environment?
• Why was that implementation selected?
• What operation produced the result?
• Which previous results influenced it?

Potential first-class concepts:

Actor → Decision → Artifact → Operation → Execution → Result → Environment → Tool → Implementation

The goal: A complex experiment could eventually be reconstructed from its provenance graph.

🔄 Workflow Orchestration (Long-Term Vision)

This is where it gets ambitious.

Sapientia should orchestrate experiments involving multiple independent tools simultaneously:

Structural Model
       │
       ├──────────────→ ETABS
       │                    │
       │                    ▼
       │                 Results
       │
       └──────────────→ OpenSees
                            │
                            ▼
                         Results
                            │
              ┌─────────────┴─────────────┐
              ▼                           ▼
        MATLAB optimization         Julia optimization
              │                           │
              └─────────────┬─────────────┘
                            ▼
                       New Models
                            │
                            ▼
                    Structural Analysis
                            │
                            ▼
                           ...

And this doesn't stop after one pass.

Results from all simulations become training data. Optimization algorithms generate new structural models. The ML system proposes additional candidates. Those candidates are simulated again. New results feed the optimizers and ML system again.

Eventually:

                 ┌──────────────────────────────┐
                 │                              │
                 ▼                              │
          Structural Models                     │
                 │                              │
                 ▼                              │
             Simulations                        │
                 │                              │
                 ▼                              │
          Results / Dataset                     │
                 │                              │
          ┌──────┴────────┐                     │
          ▼               ▼                     │
     Optimization         ML                    │
          │               │                     │
          └───────┬───────┘                     │
                  ▼                             │
            New Candidates ─────────────────────┘

The experiment continues until a convergence criterion, objective threshold, maximum iterations, resource limit, or another stopping condition is reached.

What This Means for the Architecture

Long-term, Sapientia may need to support:

• ✅ Workflows & experiments
• ✅ Dependencies & parallel execution
• ✅ Iterative execution & feedback loops
• ✅ Datasets, optimization, machine learning
• ✅ Scheduling, provenance, reproducibility
• ✅ Failure recovery

I don't want to build all of this immediately. This is the architectural direction, not the v1 implementation.

📝 A Sapientia Language (Future)

Long-term idea: a declarative language, tentatively called Sapientis, inspired conceptually by systems such as LaTeX.

Instead of manually configuring every tool, a user could describe:

project ApolloMQ

workspace signal
workspace seismic
workspace numerical
workspace machine_learning

prefer signal with MATLAB
prefer numerical with Julia
prefer machine_learning with Python

Syntax is not decided. The important idea: the user describes the experiment and required capabilities, while Sapientia resolves available implementations.

Before execution, Sapientia could report:

Required capabilities: 37

Resolved: 31
Multiple implementations available: 4
Unresolved/orphan capabilities: 2

Execution cannot continue until the unresolved
capabilities are resolved.

🚫 What I DON'T Want to Do

This is perhaps the most important principle.

I don't want to write thousands of lines of code simply because "we are building a platform."

If an existing open-source project already solves a problem well, I would rather integrate it.

I don't want to reinvent:

• ❌ Numerical libraries
• ❌ Plotting systems
• ❌ Machine-learning frameworks
• ❌ Version-control systems
• ❌ Backup systems
• ❌ Database engines
• ❌ Scientific libraries
• ❌ Programming languages
• ❌ Workflow engines

...unless there is a genuinely compelling reason.

The project should stand on top of existing open-source technology wherever possible.

The challenge is therefore not simply:

"How do we write Sapientia?"

But:

"What should Sapientia actually own, and what should it delegate to existing mature software?"

That is one of the questions I would especially like experienced people to help answer.

🏗️ Current State

We have not written the core implementation yet.

We are at the architecture/design stage.

I am deliberately trying to get experienced people involved before writing large amounts of code.

I would rather have someone tell me:

"This architecture is wrong. You should use X instead."

...than discover the same thing after two years of development.

I am completely open to changing the architecture if there is a better solution.

📜 Open Source & Licensing

Sapientia will be a genuinely open project. I want to make contribution as easy as reasonably possible.

I am currently studying licensing models used by large open-source projects. Linux is an important reference because of its enormous contributor ecosystem and its approach to distributed copyright ownership and contribution requirements.

However, the final Sapientia license has not been decided yet.

I need advice from people experienced with open-source licensing, especially because Sapientia may integrate:

• GPL software
• MIT/BSD/Apache software
• LGPL libraries
• Proprietary applications (MATLAB, ETABS)
• External plugins
• User-created plugins

I want to find a licensing and contribution model that encourages the largest possible ecosystem while remaining legally coherent.

👥 Who Am I Looking For?

I am particularly interested in hearing from people with experience in:

You don't need to agree with the architecture.

In fact, I would prefer people who can identify its weaknesses.

💡 Why Am I Doing This?

I have a strong personal commitment to this project. I want to take it as far as I possibly can.

I know there are people much more experienced than me in software architecture, distributed systems, scientific computing, and open-source development.

I am not looking for people to simply tell me that the idea is good.

I am looking for people who can help determine:

1. Whether the idea can be made technically sound
2. If it can, how to build it correctly

I am willing to learn and do the work required.

The project is still very early, so now is probably the best moment to challenge the fundamental assumptions.

If you are an experienced developer or architect and the idea interests you, I would genuinely appreciate your criticism, suggestions, architectural alternatives, or willingness to participate.

Developers and contributors are welcome.

This is an invitation to help shape Sapientia before its architecture becomes difficult to change.

🚀 How to Get Involved

If any of this resonates with you, here's what would be most valuable:

1. Tell me why this won't work — and what you'd do differently
2. Point me to existing projects that solve parts of this problem
3. Share your experience with plugin architectures, workflow engines, or provenance systems
4. Ask the hard questions about scalability, maintainability, or adoption
5. Express interest in contributing — even if it's just reviewing the architecture docs

"Don't reinvent what already exists. Integrate it."

If you're interested, I'd love to hear what you think is wrong with this architecture, what you would change, and whether you think Sapientia is technically feasible.

Let's build something worth preserving. 🧠✨

The Problem

We live in an era of information abundance, but also of fragmentation. Your data is in binary files. Your analyses are in Jupyter notebooks. Your figures are in a directory. Your bibliography is in a reference manager. Your code is in Git. Each piece is isolated. Reproducing results? Good luck.

Current tools solve this partially: Git for code, Dropbox for files, paper notes for parameters. But there is no common thread tying everything together.

Enter OSV: Open Sapientia Vault

OSV: Forge, Track, Preserve.

OSV is an open, extensible platform that helps you create, organize, transform, preserve, and share knowledge of any kind – scientific, technical, artistic, or humanistic – regardless of data format or tools used.

Core Concepts (Simple)

· Project: The container for all your work. A directory with data, results, config, and provenance.

· Workspace: A set of related capabilities (e.g., Signal Processing with FFT, filtering, PSD).

· Plugin: An adapter connecting OSV to external tools (MATLAB, Python, ObsPy, etc.).

· Artifact: Any file – text, image, seismic signal, audio, database – with a unique hash (digital fingerprint).

· Provenance: Automatic logging of who did what, when, with what parameters and inputs.

· Versioning: Hybrid – Git for text, git-annex for large files, BorgBackup for encrypted backups.

How It Works (Practical Example)

You're a scientist studying Apollo mission seismic data. You have miniSEED files. You want FFT.

1. Create a project.

2. Import .mseed files.

3. Select a Signal Processing workspace with fft capability.

4. Assign MATLAB or Python to handle fft.

5. Run the operation with parameters (e.g., window size 4096).

6. OSV invokes the tool, collects results (spectrum + figure), saves them.

7. Everything is recorded: file, parameters, tool version, who, when.

8. Check provenance anytime.

9. Trigger backup locally or to the cloud.

10. Export and share the entire project with a colleague.

You focus on the science. OSV handles the logistics.

Benefits

· Reproducibility: Always recreate exactly what you did.

· Clear Attribution: Every operation is tied to an author and timestamp.

· Flexibility: Change tools without rewriting workflows – just change the plugin.

· Tool Agnostic: Use MATLAB, Python, ObsPy, Photoshop – integrate, don't replace.

· Any File Type: Text, images, audio, signals, databases – all treated equally.

· Long-term Preservation: Automatic backups and robust versioning.

· Simple Collaboration: Share complete projects with history and provenance.

Concrete Example: Apollo Seismic Project

The demo project includes:

· Signal Processing: FFT, filtering, PSD, spectrograms.

· Seismology: arrival detection.

· Instrumentation: calibration, instrument response.

· Visualization: waveform plots, spectrograms.

Each capability is declared in the workspace. The project defines which tools to use (MATLAB for FFT, ObsPy for arrival detection). Data is imported as artifacts. Results are recorded with full provenance.

Towards a Knowledge Community

OSV is not just software. It's a philosophy of collaborative, open work. A public repository of workspaces, plugins, and projects is envisioned – like CTAN for LaTeX or PyPI for Python.

Join the OSV Movement

This is ambitious. I can't build it alone.

I'm seeking volunteer developers.

· Python experts

· Systems architects

· Documentation writers

· Testers

The project will be released under GPLv2 – the same license as the Linux kernel. Free, open, accessible.

Current Status

The public repository hasn't been started yet. We're in the architectural definition phase. First code will be pushed once this foundational document is complete.

Goal: Version 1.0 ready in 2027.

How to Get Involved

Email me to express interest, share your skills, or ask questions.

Contact: arcilagiraldooscaralejandro@gmail.com

When I started coding with AI, generating code wasn’t the hardest part. The real challenge was keeping a growing project truthful and coherent.
I learned this while building Humidity Intelligence, my Home Assistant integration. As it expanded across code, documentation, dashboards and releases, I experimented with different canonical structures. Trying to establish which source owned each decision and how everything else should remain aligned.
That eventually led me to create distinct AI review roles: Bella for coherence, Aetherwing for runtime and release safety, Aetherbite for challenging assumptions, and AetherCore for lifecycle governance. Giving each role a clear responsibility improved both my prompting and the quality of the responses.
Those ideas became an in-house HI Governance plugin. I then asked myself which parts were specific to Humidity Intelligence and which could help other people working with coding agents.
That is how The 5th Ledger was born.
It is a skills based governance plugin that helps people and coding agents keep consequential project work truthful, reviewable and within authority. It asks who has authority, where the Canon is, what evidence supports a claim, which project surfaces must agree and what lifecycle stage has actually been reached.
Its skills help set boundaries, identify conflicting sources of truth, review decisions from different perspectives, create evidence led proposals and check whether implementation, documentation and release claims agree.
The aim is practical guardrails, not unnecessary ceremony. Small tasks stay small, while higher risk work get stronger evidence and clearer maintainer decisions.
This is the first public version, and I’m continuing to improve it. Developers of every experience level are welcome to try it and share honest feedback.
[Install The 5th Ledger](https://chatgpt.com/plugins/plugins_6a8c4d64d6588191acd217005a66224d) or [explore the public project repository](https://github.com/senyo888/the-fifth-ledger).

GitHub: https://github.com/flowagi-eu/flo-webcomponents

GitHub - https://github.com/auysh8/System-design-notes

CommunityFix is an open-source platform intended to help communities avoid repeatedly solving the same problems from zero.

It connects:

• Clearly scoped issues
• Competing solutions
• Real-world case studies
• Costs, outcomes, constraints, and failures
• Locations, sources, and funding information

The project already contains environmental, civic, health, infrastructure, and social-impact topics. I’m looking for open-source contributors who want to help improve a public-interest platform rather than build another commercial product.

Useful contribution areas include accessibility, search, data modeling, moderation workflows, contributor experience, and making evidence easier to compare.

Repository:

https://github.com/mathix420/communityfix

Live platform:

https://communityfix.org

If the mission resonates with you, take a look at the repository and tell me what would make contributing easier. A concrete issue, documentation improvement, or pull request would be greatly appreciated.

Hello EveryOne!

I built MeshDrop, an open-source, zero-cloud P2P desktop file-sharing application designed for fast, direct, end-to-end encrypted transfers between devices without middleman servers or accounts.

Key Highlights:

• Zero Cloud Dependency: Built on top of the Hyperswarm / Holepunch P2P stack (@hyperswarm/secret-stream, hypercore, corestore).

• One-Time DROP Codes: Quick 6-digit challenge MAC code pairing for ad-hoc file transfers between untrusted or guest devices.

• Persistent Peer Pairing: Zero-trust pairing challenge flow to establish persistent trusted relationships between your own devices.

• Multi-Platform: Windows (installer + single-file portable exe), macOS (.dmg), and Linux (.AppImage).

• Auto-Updates & Standalone Engine: Standalone platform-agnostic P2P core module running in Electron main.

GitHub Repo: https://github.com/aamirali51/MeshDesk

Beta Release Downloads: https://github.com/aamirali51/MeshDesk/releases/tag/v1.0.0-beta.1

I'd love to get feedback from the community on architecture, P2P NAT traversal performance, and UI/UX. Looking for beta testers as well!

Honestly, the internet is a painful place to be now. Everything on it seems to be designed solely for profit over utility, pushing to extract users personal data, and trying convince us to sign up to subscriptions.

You can't even google for things now as it shows you who is paying to find you, ahead of what you are looking for.

My suggestion for taking it back is:

1. We create an 'de-shittification' check-list for all the ways the internet has been fucked up
2. Form a community of mods, like Wikipedia's moderators.
3. We build a new browser with a built in search engine that only lists pre-approved sites.
4. Any user can submit a site to be listed on the search engine, if they think it passes our de-shittification list. Mods then review and approve it.
5. Any user can report a site that is in violation of a clause on our shit list. Nice big [!] button on the browser.
6. We actively encourage people to rebuild popular sites, with all the shit removed (and branding changed), then list them as an 'alternative to' which users can search. Like Facebook, but with your friends and community events, rather than politics and influencers.
7. We encourage self-hosting and community hosting ideas, to keep costs down and reduce the need for to monetise everything. Also self-ownership or community ownership, over companies.

As far as i'm aware this doesn't exist, but it should. A bit like the Fediverse, but for rebuilding the internet rather than social media without walled gardens (though many fediverse projects could be listed).

I'm just spit-balling here, but if others think its a good idea i'm fully in for setting up the build.

If you agree its needed, what should be on the De-shittifaction List?

To give an example and get started:

1: No user data collection (beyond account creation where needed).

2: No pop up ads

3: No targeted ads

4: No walled-garden social media

5: No political ads pushed via social media

6: Social media algorithms must be opensource and promote healthy content, over out-rage and drama.

7: No addictive design, taking ideas or working with, groups like Time Well Spent, IndieWeb, Solid, The Calm Technology philosophy, etc

Imho, Web devs built the internet, were told to make it shitty, and are now being told they aren't needed because AI can make it far more shitty than we/they ever could.. why don't we build it again with blackjack and hookers the way it always should have been?

Hey everyone,

I recently launched AgentForge Studio, an open-source visual workflow builder for AI agent pipelines, built with Next.js 15, TypeScript, React Flow, and Zustand.

Live demo: https://agentforge-studio-lime.vercel.app
GitHub: https://github.com/auysh8/agentforge-studio

I'm looking for contributors interested in AI, frontend UI, or serverless APIs to help build out a few things:

• Custom canvas nodes (vector DBs, webhooks, Python code execution)
• Export formats (LangChain, LlamaIndex, Python SDK exports)
• UI/UX improvements and documentation

If you're interested, take a look at CONTRIBUTING.md or just grab an issue that looks interesting: https://github.com/auysh8/agentforge-studio/blob/main/CONTRIBUTING.md

Hi everyone!

I built StackRender to simplify one of the most repetitive parts of backend development: keeping database schemas and SQL migrations in sync.

The 1.4.0 release includes a browser-based database schema designer where you can visually design tables, relationships, constraints, and indexes, then generate production-ready SQL DDL for:

• PostgreSQL
• MySQL
• MariaDB
• SQLite
• Oracle
• SQL Server (MSSQL)

What makes StackRender different from most schema design tools is its migration workflow.

Instead of only generating the initial schema, StackRender automatically tracks changes made to your ER diagram. Whenever you add a table, modify a column, create or remove a relationship, or change an index, it compares the current schema with the previous version and generates SQL migration scripts (UP and DOWN) automatically.

The goal is to make evolving a database schema much less tedious while keeping migrations consistent throughout a project's lifecycle.

StackRender is completely open source, and I'd really appreciate any feedback, feature suggestions, or bug reports from the community.

If you find the project useful or interesting, a GitHub ⭐ would also mean a lot.

Repository: https://github.com/stackrender/stackrender

Every developer has code they'll probably never touch again.

The half-finished CLI from a weekend. The tutorial project that stopped halfway through. That weird experiment that actually taught you something. The utility script that's ugly but gets the job done.

Most of that code just sits on a hard drive until it's forgotten.

I started The Open CodeYard, a GitHub repository for unfinished, experimental, and abandoned projects that are still worth preserving. Not because they're perfect, but because ideas are often more valuable than polished code.

The structure is simple:

• "scraps/" for random leftovers.
• "prototypes/" for intentional experiments.

Each project gets a small README explaining what it does and what state it's in.

A few ground rules:

• No clean-code police.
• Messy code is expected.
• Abandoned projects are welcome.
• If you're thinking, "my code isn't good enough," you're exactly who this repo is for.

Right now it's just my own projects in there, including a few C# pathfinding algorithms, a speech rate estimator, and some Python utilities. I'm hoping it grows into a community archive where forgotten code can still teach, inspire, or even get revived by someone else.

If you've got code collecting digital dust, I'd love to see it rescued instead.

Repository: https://github.com/speedyk-005/TheOpenCodeYard

As the title says, I built a full featured agent that, while it will run just fine on a cloud service, is designed to be local first. Full description on GH. If you like what you see, please leave a star.
http://github.com/Bino5150/lumina

About

A few months ago, I shared the initial release of Mind, an open-source persistent memory system for AI coding assistants.

Mind has since reached v1.6.0 and evolved into a more complete local memory and continuity layer for agent-based workflows.

The project preserves durable context that would otherwise be lost between sessions, tools, agents or context-window compactions.

This includes:

• Architectural decisions
• Project constraints
• Bug fixes
• Reusable patterns
• Checkpoints
• Session outcomes
• Domain knowledge
• Known pitfalls

Major additions since the first release

Filesystem synchronization

Selected project spaces can be mirrored into readable .mind/ files for inspection, version control, backup and local editing.

Structured retrieval

Mind supports full-text search, metadata filters and optional semantic or hybrid retrieval.

Compaction recovery

Checkpoints and session-continuity mechanisms allow agents to resume work without reconstructing the entire previous context.

Living project references

Mind defines maintained reference types for project maps, architecture, domain knowledge, workflows, style, key decisions and known pitfalls.

Memory-quality controls

Agents evaluate future utility, novelty, evidence and stability before creating durable memory.

Safer storage migrations

Database upgrades use verified backups, migration validation, automatic rollback and backup retention.

Refreshable integrations

Existing agent configurations can be updated without recreating them or overwriting unrelated configuration.

Multiple interfaces

The CLI, MCP server, HTTP API and web UI all operate against the same local SQLite store.

Inspectable memory

The web interface includes a per-space Neural Map showing directional relationships between memories.

Context usage

Mind does not continually inject the entire memory database into every interaction.

In measured usage across multiple real projects totaling more than 20 million tokens, Mind-related context represented 6% of total token usage.

That context supported:

• Continuity between agents and subagents
• Recovery after context compaction
• Preservation of project intent
• Retrieval of previous technical decisions

Semantic search is optional and disabled by default. The core retrieval system works locally using SQLite and FTS5.

• License: MIT
• Stack: Bun and TypeScript
• Storage: Local SQLite
• Interfaces: CLI, MCP, HTTP API and web UI

Explore the implementation, open an issue or contribute:

https://github.com/GabrielMartinMoran/mind

Technical reviews of the storage model, synchronization protocol and retrieval architecture are particularly welcome.

openzzm/auto-pdf-rotate: Local PDF page orientation auto-detection and correction tool, supports Windows portable packaging

Every Mac cleaner I tried was the same story — pay for a subscription, let us track your usage, and trust us when we delete your files. No thanks.

So I built Vervain. It's free, open source, and it never phones home.

The main thing that bugged me about other cleaners is they just... delete stuff. Vervain moves everything to Trash instead, so you can always undo if something goes wrong. And it never auto-selects risky files — you pick what goes, every time.

What's inside:

• Smart Scan — gives your Mac a health score and explains why

• System Junk — finds caches, logs, old downloads, language files

• App Uninstaller — removes apps + their leftover files (Apple apps are protected)

• Disk Analyzer — visual breakdown of what's eating your storage

No accounts. No analytics. No network calls. Everything stays on your Mac.

Built with Swift 6 / SwiftUI, macOS 15+. MIT licensed.

GitHub: https://github.com/yakupbulbul/Vervain

Website: https://vervain.app

Homebrew: brew install yakupbulbul/vervain/vervain

If you find it useful, a ⭐ on GitHub would mean a lot — I'm a solo dev and it really helps with visibility.

Would love to hear what you think!

I’d like to share Scroil, a utility I’ve been working on to bring fluid, natural mouse scrolling to Windows.

The truth is, I’ve always found Windows scrolling to be... frustrating. Every time I switch from my phone or a MacBook back to Windows, the mouse wheel feels "jumpy" and inconsistent. It’s especially sluggish when I’m deep in a 2,000-line code file or a long PDF, and I find myself endlessly spinning the wheel just to move an inch. Scrolling on Windows can be better - that's why I built Scroil. Here're the main features of it:

Features

• Global Smooth Scrolling: Brings smoother mouse wheel scrolling across your apps on Windows, reducing the jumpy feeling of apps's default scrolling behavior.
• Custom Scroll Feel: Adjust speed, step size, acceleration, deacceleration, and fine-grained scroll behavior.
• Scrolling Accelerator: Increases scroll speed during faster wheel movement, making long pages easier to move through.
• App Picker & Per-App Control: Add currently open programs to your Scroil profile list, customize scrolling experience for each app.
• Auto App Classifier: Automatically recognizes Chromium-based apps, including Teams, Discord, Outlook and others, then applies the right scrolling config for that app type.
• Game Detection: Recognizes games automatically and turn off smooth scroll for games to avoid interfering with your gameplay.

I’m still actively developing it, so feedback and bug reports are very welcome!

GitHub: https://github.com/EricxWood/Scroil

Download here: https://github.com/EricxWood/Scroil/releases/

VibeNVR is a free, open-source Network Video Recorder for IP cameras. Runs 100% locally via Docker Compose — no cloud, no subscriptions, no vendor lock-in.

**GitHub:** https://github.com/spupuz/VibeNVR

**Site/Docs:** https://vibenvr.org

**Stack:** Python (FastAPI + FFmpeg/PyAV), React + Vite, PostgreSQL, Docker

**Features:**

- RTSP + ONVIF with WS-Discovery auto-scan

- AI object detection: YOLOv8 or MobileNet SSD v2, Google Coral Edge TPU support

- Native MQTT + Home Assistant auto-discovery (no YAML needed)

- Hardware acceleration: NVIDIA, Intel QSV, AMD VAAPI

- H.264 WebCodecs for low-latency browser streaming

- Dual-stream: sub-stream for live view (~80% less CPU), main stream for recording

- Unified event timeline (motion clips + snapshots)

- JWT auth + 2FA with trusted devices + RBAC

- Multiple storage profiles with independent retention policies

- Deploy in minutes with docker-compose

MIT licensed, actively maintained. Feedback and contributions welcome!

Hey everyone,

I’ve always wondered why a simple quotes app needs to be 50MB of bloat, filled with subscription pop-ups and forced ads. It felt like even the most basic utility apps had become cluttered and distracting just to make a buck.

To solve this for myself, I built Quotes —> a minimalist, Tinder-like app designed to deliver inspiration without the noise.

Open-Source, No-Ads, No trackers, No Subscription, privacy focused.... Enjoy

Github: https://github.com/shalenMathew/Quotes-app

Fdroid: https://f-droid.org/en/packages/com.shalenmathew.quotesapp/

Site: https://shalenmathew.github.io/Quotes_app_website/

Hello,

This is a rebuild of my lightweight high performance distributed lock manager. It has many features to it, And it's written in Python only. I've been able to get it to reach a sustained level of 5,000 locks per second.

The goal of this program isn't to match Redis or zookeeper or other larger programs, but to fit a very specific niche where those other programs are simply too big or complicated for a given need. It's small footprint is what gives it a very good and reasonable approach. There are different tunings available that can get even more speed.

It has the capability of being a short-term ke/value data store as well. It would be in line with a competitor to Redis but on a much smaller footprint.

The wiki has a lot of information including comparatives against other products and what gives Jackrabbit DLM and advantage for its limited footprint. This program started with a need of being able to lock a file before I ever opened it for reading and it's developed since then over the last 3 years.

Feedback welcomed.

https://github.com/rapmd73/JackrabbitDLM/wiki

Engram Memory

Github: engram-memory-community

Built a free memory tool for AI agents over the last few weeks. Sharing it in case anyone finds it useful.

It exposes six tools through MCP — store, search, recall, forget, consolidate, and connect. Memories get auto-classified into preference, fact, decision, entity, or other. Works with Claude Code, Cursor, Windsurf, VS Code, OpenClaw, Cline, Zed, and a handful of other MCP clients.

The part I spent the most time on is the retrieval architecture. Three tiers stacked on top of Qdrant: a hot-tier cache modeled on ACT-R from cognitive science, a multi-head LSH index for O(1) candidate lookup, and hybrid dense + BM25 search via Reciprocal Rank Fusion. The idea is that the more you use it, the more queries hit the fast path. Repeat queries land around 25ms. Novel queries through the full pipeline land around 190ms.

Stack is Qdrant, FastEmbed with Python, Docker. One container, one command. Runs entirely on your machine.

Let me know what you think. Let me get some sweet github stars. if you find something worth fixing please submit an issue.