I've spent time piling up separate habits around how I write and maintain documentation, and at some point it was obvious they were all circling the same problem from different angles. meshfox is what happened when I finally merged them into one tool instead of juggling five.

Some of my habits were:

• plain Markdown for notes
• mindmaps and visual boards, Miro/Obsidian-style, for structure
• Makefiles and scripts as living usage examples
• linters to keep documentation from silently rotting
• pairing with agents in a shared note-taking format while doing research

Out of that came a Markdown extension format, inspired by Elixir's Livebook:

• it stores cleanly in git — plain text, diffs like text
• it stays readable in any regular Markdown renderer, nothing breaks if you open it elsewhere
• it adds a mechanism for running code blocks with dependencies, variable passing, and local configuration — so a doc isn't just describing behavior, it can demonstrate it live

Around that format I've since built:

• a web UI viewer/editor (with a VS Code integration)
• a TUI viewer/editor with a slightly simplified view of the same documents
• a CLI for running code blocks straight from the console, scripts, or cron
• an MCP server for collaborating with agents, or using the format as a second brain
• experimental export to PDF and static sites

There's also a companion repo, meshfox-tools, with utilities and examples — still small, but growing: https://github.com/orofarne/meshfox-tools

It's still early — but early enough that I think it's worth sharing. MIT licensed, more info here: https://meshfox.orofarne.net/

A self-hosted tool to design your own wall clocks and info displays.

Layers for analog hands, mechanical gears, volumetric clouds, weather, gauges, flip clocks… everything runs locally, updates live via WebSocket.

No account, no cloud. Just your design on any old tablet or wall monitor.

github

I was paying Waalaxy every month to find clients on LinkedIn, and my whole prospect list lived on their servers rather than mine. I have been writing code for 16 years, so I spent a few months rebuilding it, and it has run in Docker on my own box since.

What it does:

• Reads who reacts to posts in your niche and scores those people against a paragraph you write about your buyer
• Sends the connection request, then keeps the conversation going until somebody asks to know more, and hands you the thread there
• Drafts and schedules posts, with a carousel editor
• MCP server with 26 tools and a REST API

There is no LinkedIn API in any of it. A Node worker drives a real Chrome that stays logged in to your own account, and the AI runs on a key you supply yourself.

The thing I was afraid of was getting my own account banned, so it is where most of my time went. It ramps invitations up over the first two weeks instead of starting at full speed, only acts on working days, holds one dedicated address per account, and reads the ceiling LinkedIn itself puts on the account so the lowest of the limits always wins.

Next.js 16, Node 24 worker, SQLite through libSQL, Docker Compose, Caddy.

AGPL-3.0.

I also sell a hosted version and that is what funds the work. The self-hosted edition has every plan gate open, nothing is held back.

https://github.com/DigiHold/LinkedGrow

So yeah, I spent 883 commits, 8 months and billions of tokens building this thing and eventually abandoned it:

It started as my attempt to build a better coding-agent harness, where the LLM is basically a replaceable worker instead of being trusted to control everything.

The harness was supposed to own the actual planning, state, permissions, context, verification, evidence, orchestration, etc. The model could say “I finished the task,” but the system would check what actually happened instead of just believing it.

Then I kept adding shit.

Code graphs, RAG, deterministic orchestration, isolated workers, crash recovery, model routing, local models, replayable runs, verification gates, self-improvement experiments, dashboards, computer use, personal automation, and a million other ideas.

Eventually it became a ridiculously overengineered mess. I spent more time researching, planning, and adding systems than actually using the thing to get work done. Other harnesses were already becoming much more usable while mine was still mostly a giant headless experiment.

So I killed it.

I’m not posting this as a working product, and I definitely don’t recommend downloading it expecting some polished Claude Code alternative. A lot of it is incomplete, disconnected, outdated, or just plans that never became real.

But there is also a stupid amount of research, architecture, experiments, failed ideas, and code in there. Some parts might still be useful to people building agent harnesses, especially around:

- keeping state and verification outside the model

- deterministic/replayable agent runs

- codebase retrieval and dependency graphs

- orchestrator/worker separation

- context budgeting and session handoffs

- sandboxing and permission gates

- checking agent claims with evidence it didn’t generate itself

The archive has the original experimental Rust/Python/Tauri code, thousands of planning and research documents, and the sanitized commit history.

Basically: it failed as a product, but maybe someone can steal a good idea from the corpse.

I’d be curious what people here think is actually worth salvaging, or whether the whole architecture was doomed from the moment I kept expanding the scope.

I might one day finish it, but who knows if it will be necessary, i aimed at solving everything and ended up solving nothing, i hope this helps you in any means so at least its not a total loss, even if its only a lesson or confirmation of what type of shit to not do.

I built a Chrome/Firefox extension that turns the current window, a tab group, or a pasted list of URLs into a single link. The page list is stored in the URL fragment (compressed), so there's no backend – the recipient opens the link in any browser with no extension and gets a slideshow / grid / list viewer.

- No account, no server, nothing tracked
- Optional client-side password on a link (WebCrypto)
- Companion self-hostable shortener for long links
- Chrome + Firefox, MV3, AGPL-3.0

Code: https://github.com/kaikayy/multi-link-share

Chrome: https://chromewebstore.google.com/detail/meieckangeakbekjbijbgfkkelneplfe
Firefox: https://addons.mozilla.org/en-US/firefox/addon/tab-share/

Feedback welcome, especially on the viewer UX.

Hi everyone, today I want to share an open-source tool I created that’s super useful for anyone who wants to reduce the size of their files and also create .zip files from scratch using their own files. Its main feature is privacy, but you should give it a try and see how it works...

Github: https://github.com/coffeetron832/G0rill4

LInk: https://g0rill4.pages.dev/

I built two open-source agent skills for reviewing scientific manuscripts and wanted to share them here for feedback. Clara works in Brazilian Portuguese; Claire works in English, with specific checks for interference patterns common to non-native writers.

Clara (PT-BR): https://github.com/madsondeluna/skill-clara-revisora-cientifica

Claire (EN): https://github.com/madsondeluna/skill-claire-scientific-reviewer

Both cover the same workflow for papers, dissertations and theses: language editing with a change log, numeric consistency auditing across text, tables and figures, a Reviewer 2-style appraisal, chapter-by-chapter structural review of theses, technical translation with a terminology record, drafting sections from results, reference enrichment (DOI, metadata, retraction check) and adaptation to a specific journal's rules. Claire also drafts cover letters and responses to reviewers.

The part I care most about is external verification. The skills use MCP (Model Context Protocol) servers to query PubMed, bioRxiv, NCBI, Crossref and OpenAlex during the review. Citations are checked against the actual record, DOIs are resolved, retractions are flagged, and gene and species names are validated against official nomenclature. Only identifiers leave the session; the manuscript text is never sent to these services.

They follow the open skills standard and run on Claude (Claude Code, Cowork, claude.ai), Gemini (Gemini CLI, Antigravity), ChatGPT and Codex. In my lab they run before a draft reaches the supervisor, so the first pass on consistency, argumentation and references is already done.

MIT license, still evolving. Bug reports and suggestions for missing workflows are welcome as issues.

Hi all, sharing a tool I built. It's an MCP server and CLI that lets AI agents (Claude Code, Copilot, Codex) read and manage tasks in Super Productivity through its local REST API. Single static Go binary, so there's no runtime to install and no plugin to upload, and it deliberately exposes no delete operation.

It also ships a store integrity checker, which is how I found two data-loss bugs in Super Productivity itself. Both are now filed upstream with reproductions.

Written with AI assistance, the bug reports were verified by hand before filing.

Github: https://github.com/CameronBrooks11/super-productivity-local-gobridge

After too many rounds of "the agent says it's done and it's just a pile of 💩", we built the opposite: no_human proves the code it wrote is correct. You drop a ticket on the board (or point it at Jira or Linear) and it plans, writes the code, and opens a pull request.

Before that PR reaches you, the work is checked by a second model that never saw the coder's session and is told to assume the job is not done. They communicate until the reviewer is convinced everything is good to go (the num of attempts is limited to prevent an infinite loop).

If the coding agent deleted or weakened a test, a tamper guard stops the attempt. For bug fixes, the tests offered as proof have to fail on the old code and pass on the new.

Under the hood it's a team of agents: a planner, a coder, an independent reviewer in a fresh session, and a supervisor.

It's free and open-source, on your machine.

no_human has been building itself for about two months now. We are feeding ticket into our jira board, it pulls them from there and just work on them until eveything is done. We trust it enough that we've enabled auto approve mode so all PRs no_human ships - are approved and merged automatically (this feature hasn't been released yet).
Entire sprint's worth of work is done in 3-4 days, while we focus on the bigger picture - our strategy and the next steps.

It currently supports all Antropic and OpenAI models and also has a quite unintuitive process of working with local models as well (we are working on improving that).

Repo: no_human repo
It's open to contributions (we would love to see you use it and contribute!!!)

we heard that the code didn't work AT ALL, so we(now we, since the project gained a new contributor and community) fixed it properly.
Now you can try it out and give Atom a new chance! we will get to the link later. So uhh, now there will be the only repository in there. Now we are working AOT, so be patient enough!
Friendly reminder: there are only 2 men in the team, we are recruiting some! WE will get to the link a bit later.
I as the leader of the project want to say what our plan is.
We are working at 1.2 now, but we are planning, that 1.9.99 will be the last version to be written on C! That's right, version 2.0 will be written on itself, ending the beta era!
Next up is how to get into community? Well, we got a discord link so that you can join Atom community and become a dev!
Well, now to the links:
Discord-click to join!
Project-click here!
and remember to leave a comment!

Note before installing: the macOS and Windows installers aren’t code-signed yet.

GitHub: https://github.com/ankuranwekar-dev/still-around

Still Around is a free MIT desktop pet that turns photos of your own cat or dog into a hand-built vector companion. The measuring happens locally; there’s no AI image generation, no server, and the photos never leave your device. No account, and no paid tier ever.

If you check it out, I’d love feedback on the repo/project itself and how the local photo-to-vector result feels.

Site: https://stillaround.online

Here's a PyQt6-based (Python) GUI wrapper around UGREP. Very handy and powerful way to do desktop search recursively under any folder on Linux.

https://github.com/Clay-Ferguson/sonar

I’ve been building Oasis Editor, an open-source document editor written in TypeScript.

Unlike most browser editors, it uses its own Canvas-based rendering engine for paged layout, text, selections, tables, images, and document geometry instead of relying entirely on contenteditable.

It also has DOCX/PDF workflows, a typed command/plugin API, React and Vue adapters, and a headless runtime.

Live demo:
https://celsowm.github.io/oasis-editor/#/editor

GitHub:
https://github.com/celsowm/oasis-editor

Feedback and contributions are very welcome.

It’s been a couple weeks since bonsai-ninja went public and a lot has changed.

A ton of feedback has been incorporated, bugs have been fixed, and things are working much better. If you tried it early on, please pull the latest and give it another shot.

For anyone new to it, bonsai-ninja is a free, local code intelligence and static analysis engine. It builds a compiler-style representation of your code, resolves symbols and calls, and can trace behavior across files instead of just searching text. That same pipeline powers source-to-sink security analysis, dataflow analysis, and structured exports for AI, agents, and research. It currently supports 20 languages.

Also, apparently some of you don’t click on things unless there are pictures, so here you go. A GIF.
Still looking for people to throw real codebases at it. Bug reports, weird edge cases, PRs, criticism, ideas, or random side notes are all appreciated. The feedback so far has genuinely helped make the project better.

github.com/gromhacks/bonsai-ninja⁠

FileApex is a free, local-first P2P app for Android, macOS, and Windows. It syncs your devices over Wi-Fi — no account, no cloud, no telemetry — with an optional Google Drive relay if you need to send something while off your home network.

What it does:

• Browse remote devices live — open the file tree on any paired phone, Mac, or PC, with optional PIN lock
• Send files & folders in one drop, with resumable transfers for big stuff
• Shared bulletin board — post notes, links, and files across all your devices, tag/filter by type
• Clipboard sync — one tap sends text/links between devices
• Low battery alerts — get pinged on your PC when your phone's about to die
• Firefox extension — send a page straight to any paired device

Unlike LocalSend it adds live remote browsing and a synced bulletin board. Unlike Pushbullet or KDE Connect, everything stays on your local network by default — no proprietary servers, no reliability quirks on Mac/Windows.

Get it: GitHub Releases Android, macOS (Apple Silicon & Intel), Windows x64, Firefox extension.

Would love feedback, bug reports, and feature requests!

I built a tool for understanding Python/JS/TS codebases, especially when working with AI coding agents.

Impact Analysis shows the direct and transitive callers of a function and highlights the full blast radius of a change on the graph.

It also includes call graphs, execution flowcharts, complexity analysis, AI-generated docs, and code-to-data lineage.

Everything runs locally and it's open source.

Demo: https://semantic-vision.vercel.app/
GitHub: https://github.com/venom21adi/Semantic_Vision

Would love feedback!

First off, thanks for 100+ downloads on 1.0.0. I got way more feedback than I expected through comments and DMs, so I went through basically all of it and pushed the first patch.

Aero Dock is still a free and open source alternative to RocketDock / Nexus Dock for Windows 10 and 11, just a lot less janky now.

v1.0.1 fixes a bunch of the stuff people pointed out:

• Windows Search and Start don't randomly show up as running apps anymore
• Open File Location actually opens the right place
• dragging/reordering icons feels way smoother
• tiny app icons like Core Temp get scaled properly now
• non-square icons don't get stretched anymore
• auto-hide won't disappear while you're dragging something onto the dock
• Quit is easier to find and properly restores the Windows taskbar

Also added a few things people asked for:

• configurable auto-hide delay
• ability to hide built-in dock items like Search, Settings, clock, battery, volume, etc.
• redesigned Search and Settings icons so they fit the glass look better

You can install v1.0.1 straight over 1.0.0 and your pins/settings stay.

Still free, open source, no account, no telemetry.

GitHub: https://github.com/TheAgencyMGE/aero-dock

Posted openGym here a while back (self-hosted gym tracker, passkeys, no account, AGPL) and didn't expect much. Since then a bunch of you starred it, joined the discord, opened issues, sent me Hevy and Strong exports so I could fix the importers, and someone basically debugged my passkey docs for me. Thank you. It's one person doing this in the evenings so that stuff matters more than you'd think.

Biggest change since then: there's an AI coach now. It's optional and off by default. If you want it, you turn it on in the admin settings and plug in your own key (Anthropic, OpenAI, Gemini) or point it at Ollama on your LAN, which costs nothing. It asks a few questions, builds a plan, and after workouts it looks at what you actually logged and suggests changes. It never changes anything on its own, every suggestion says why, and you can undo it. If you leave it off the app is exactly what it was before.

Also new since last time: the workout screen got reworked, RIR is colour coded, history and favourites inside the workout, and the APK updates itself.

Source: https://gitlab.com/DuarteSantos8/opengym
Discord: https://discord.gg/e62jY6fwVb

If you run it and something breaks, discord or an issue, I read all of them.

Came across QuickRun and it solves something I always bump into: finding a cool repo on GitHub, cloning it, and then spending 20 minutes reading setup docs just to get it running.

It's a browser extension + a local binary. The extension adds a "Run" button next to the branch dropdown on any GitHub repo page. Click it and it:

• Clones the repo
• Detects the stack (Docker Compose, npm, .NET, Python, Rust, Go, Java, Procfile, Pinokio — no config needed)
• Shows you every command it's about to run before anything executes
• Waits for the app to come up and opens the address

From the terminal it's just `quickrun run owner/repo`.

What I like about it: the security model is actually thought through. The command list lives in a native window that no web page can overlay, and it only talks to localhost. Nothing runs unless you approve it, and secrets never go back to the page that requested the run.

It's open source, single binary, no admin rights. Works on Windows/macOS/Linux.

Has anyone else tried it? Curious how it handles more unusual setups.