I’m still not a fan of MCP, but what follows is what I’ve learned about making tool chains actually work, condensed from swearing at logs rather than reading papers.

Disclaimer:This is a condensed version of CHAINING.md, which was itself stapled together from a bunch of notes in my Obsidian vault. The full version has more code examples and a techniques inventory table that Opus just _had to add, and I’ve since beaten that out of it and restored most of the original text (minus typos).

The short version: the MCP servers I design do most of the work, while the model walks breadcrumbs.

They look at the conversation, scan the tool list, and grab whatever looks more probable. That’s it. There is no hidden planner. If you want chains that finish somewhere sensible, the server has to make the next call blindingly obvious at every step.

After a year or so, I have pared down my approach into these three things, roughly in order of how much pain they save you:

• A small named core verb set covering most intents
• Output that suggests the next call
• An addressing scheme that survives between calls–anchors, IDs, paths, anything but line numbers.

The Office server exposes over 100 tools. Its get_instructions() funnels models toward eight:

…start with office_help, then prefer office_read, office_inspect, office_patch, office_table, office_template, office_audit, and word_insert_at_anchor. Treat specialised tools as fallback, diagnostic, legacy-compatibility, or expert tools when the core flow is insufficient.

That single sentence does an outsized amount of work–it tells the model there is a recommended path, that the path is verb-shaped (help -> read -> inspect -> patch -> audit), and that everything else is opt-in.

Without it, models cheerfully reach for word_parse_sow_template when office_read would do, and you end up with five-call detours for one-call jobs.

So I quickly realized that I needed to be ruthless about which tools to surface and when. The specialised ones still ship–hidden under a “for experts” framing, and a handful of legacy ones filtered out of tools/list entirely.

I also make liberal use of activation sets–the surface the model sees is small; the surface it can reach is large.

Again, models chain whatever is most likely (or rhymes), and the most effective tactic, for me, has been taking advantage of that.

All Word tools are word_*, all Excel excel_*, all unified office_*. A model that just called office_inspect will reach for office_patch next, not word_patch_with_track_changes, because the prefix matches.

This particular server also makes liberal use of annotations and a little intent/inferrer hack that reads those prefixes to assign readOnlyHint/destructiveHint automatically, so naming discipline turns into safety metadata for free.

The prefix is the plan. The verb is the step. If you take one thing from this entire post, I’d suggest this notion…

This was the single change that made things behave on smaller models. The big ones will plan a chain from a tool list and a goal; the wee ones won’t–they grab the first plausible tool and stop.

The fix is stupid simple: every response ends with a breadcrumb dictionary of hints to follow. At minimum next_tools: [...], plus usage: "<exact call>" whenever the current tool produced a value the next one needs.

A model that can’t assemble arguments from a schema can copy the usage string verbatim. In fact, they will copy it, because it is still the most likely outcome as it fills in tokens, and thus those usage hints funnel the path the model takes.

Another thing I hit upon was that signposting needed to be curated.

Borrowing a page from intent mapping, office_help(goal=...) returns a structured record–recommended chain with rationale, fallbacks, diagnostic strings to watch for, one imperative next_step sentence. Not prose. Not a README, not skills. Data the model can act on without reading comprehension.

Called with no arguments, it returns the catalogue. Called with an unknown goal, it returns the supported set rather than an error, which turns a potential workflow-stopping error into an actual useful catalogue.

The biggest reason simple models can’t follow chains is the model losing the thread between calls. “Insert a paragraph after the introduction” is fine in English but catastrophic if you expect it to remember a byte offset across three tool calls.

In this particular scenario, I cheated and since most Office documents have headings (or cells, or internal structured paths inside OOXML), I used either verbatim text from the document or immovable coordinates (which was particularly hard in PowerPoint, by the way).

So besides suggestions and hints, return identifiers your tools will later accept as input. If you find yourself returning data the model has to describe back to you in natural language, you’ve made a chain that will misfire on a Tuesday afternoon when you’re not watching.

I started out with individual editing tools per format, which was very easy to do automated tests for but incredibly wasteful of context, so at one point I decided to make things much simpler for initial discovery, and since I needed to make all outputs auditable, I then tagged available sub-operations risk-wise.

office_patch is the same code path whether you ask for dry_run, best_effort, safe, or strict. One tool, four modes, one entry in tools/list.

Discovery cost scales with tool count, not mode count. And dry_run -> safe -> strict is an escalation chain the model figures out on its own without being told.

If you have N tools that differ only in how cautious they are, collapse them. You’re wasting everyone’s context budget.

Linear chains are easy. Real chains have loops, and loops only happen when the server invites the model back in. Every mutating tool returns a standard envelope with status, matched_targets, unmatched_targets, and next_tools.

The model then branches on a small subset of options “locally” without needing to go over the entire context, and if you name the diagnostic fields with exact strings the model will see again in your instructions, it will just reinforce them.

In this particular case, again, I cheated. I figured out that the models were starting to call tools at random because they couldn’t introspect the document well enough and ended up breaking files, so I always gave them at least one read-only tool, so the penalty for “I’m confused, let me look again” is one extra round-trip, not a destructive cock-up.

• Pick five to ten core verbs and name them in get_instructions() or your local equivalent
• Use consistent prefixes by surface
• Provide a discovery tool that returns recommendations as data, not prose
• Make the discovery tool browseable–no-arg returns the catalogue, unknown input returns the supported set
• Embed forward breadcrumbs in every tool response
• Provide a map/anchors tool so addresses survive between calls
• Give every mutating tool a mode enum including dry_run
• Return named diagnostic fields and cite the recovery tools
• Standardise the mutation envelope. If one tool changes something in a specific way, make sure the others are consistent (arguments, semantics, etc.)
• Reject unknown arguments strictly (this is much easier in some runtimes than others)
• Provide an audit tool so the model has somewhere to land
• Cache anything the recovery loop calls more than once, because, well, it will get called dozens of times even if you carefully curate paths through your tooling with hints.
• Make repeat calls safe–models retry, and they should be allowed to (idempotence is hard, and often impossible).

Do the boring work in the schema and the descriptions. The model will happily do the clever bit if you stop making it guess.

It took about five minutes to get the core working, and maybe another hour of incremental tweaks spread over a day or so. That ratio–five minutes for the thing, an hour for the polish–tells you something about the state of the problem it solves.

Web App Viewer is a tiny native macOS shell that opens a URL in a WebKit window with no browser chrome. No address bar, no tab strip, no toolbar, no Safari-style fullscreen frame. One web page, one native window, as little visible UI as macOS will reasonably allow once a page is loaded (it hides traffic lights and scrollbars when the mouse is away).

You can drop URLs onto it in the Dock, send them from the Share sheet, a .webloc file, or a custom webappviewer:// URL scheme.

Why

Safari’s “Add to Dock” Web Apps have been around for a while now, and the idea is sound–pin a website as a standalone app, give it its own icon, get it out of the browser tab pile. The execution, though, is maddening, and it has always been broken across the board, but on macOS it is horrendous.

The resulting windows still carry persistent browser chrome I can’t hide, and the whole flow of creating one (find the menu item, wait, hope it picks up the right icon, hope it doesn’t break on the next Safari update) feels like an afterthought rather than a feature anyone at Apple actually uses.

This is one of dozens of Apple papercuts that accumulate into a kind of low-grade daily friction, and I have a growing list of them that I intend to write about at some point. But this one was fixable before dinner, so I fixed it.

I fired up Codex with the kind of detailed mini-spec I described in my agentic development piece–what the window should look like, how URLs should be accepted, what the drag behaviour should be–and told it to reuse the window styles and approach from Daisy and the USB Video Viewer (another small Swift project I built to test SBCs via USB capture without adding more monitors to an already cluttered desk).

Disclosure: OpenAI provided me with a 6-month trial of Codex for my Open Source work (which has also helped me fully isolate that from work), but you could probably do this with an brick-brained open-source local model (even if Swift is a mess and under-represented in LLM training sets, which is a problem even with SOTA models).

The core is just WKWebView in a native window with chrome that fades in on hover. The Share Extension, the macOS Service, and the URL scheme were bits I tacked on after, and all the scaffolding (Makefile, signing, etc.) was AI-generated, because there is absolutely no reason to do that by hand in 2026.

There were, however, two things that were a right pain:

• Adding an invisible drag strip needed a nudge from memory, but Codex was useless there. I knew how I’d have done it in Objective-C and just guided it through the Swift equivalent until it worked. Everything else was straightforward.
• Web manifest icon detection in Swift was… oh boy. The fact that Swift still does not have a sane async model (at least like I would expect) and would poke at the page and web manifests but fail to wait and load the bigger icons took me a few tries to get right.

But it was totally worth it. I now have six instances of this running, and I found (and fixed) subtle bugs when trying to create each one of them, so I’m pretty much calling it “done” other than some manual UX tweaks I want to do to the menus and dialogs.

The original motivation was wrapping Piclaw’s web UI as a frameless native-feeling app, and that works exactly as I wanted. But the nicer surprise has been dropping other self-hosted URLs into it–Grafana dashboards, Proxmox consoles, internal tools–and getting a clean, chromeless window for each. It turns out that removing the browser frame makes everything feel lighter.

And I am casting one of them to an Android device via AirPlay (more on that later when I get that one stable), and the lack of browser chrome makes it… just great. Zero wasted pixels, no distractions, just the content.

But the way it really improves on what Apple didn’t do for me is usability and practicality. Drop in a URL, check it out, then hit Cmd+I and a new copy is installed to my ~/Applications folder, ready to launch from Spotlight, without cluttering the Dock or trying to figure out where they hid it in the sharing pane.

Bliss.

I was a happy Fluid user years ago, and I know there are paid apps that do roughly this. But the uncomfortable truth for Apple indie developers in the age of AI is that there is zero reason to pay for any of them when I can build a tailored version for my own needs this fast.

That’s not a criticism of those apps. It’s a warning sign about what AI-assisted development does to the economics of small, focused utilities–and, in the context of Mac apps, which were always a tiny cottage industry, is going to be worrisome for many.

But the real lesson here, I think, should be about what Apple ought to have just built into macOS instead of shipping the half-baked Web App support that provoked all of this in the first place.

I will have more words on that.

In fact, I’ve yet to have a reason for building something with it (other than the occasional test), but it pays to keep an eye on things.

while parsing a block mapping
  in "<byte string>", line 2, column 1
did not find expected key
  in "<byte string>", line 115, column 1

A brisk, brilliantly coded tutorial on vector quantisation: how far you can push compression on model KV caches and embeddings without breaking what matters. The interactive sliders and diagrams do the teaching before the maths catches up.

Someone’s clearly done this with care. Bravo.

I built vibes in January, then turned it into piclaw in February, because I wanted an agent interface that actually fits around my day. Federico Viticci’s Remodex review Remodex is a neat reminder of why this matters: yes, a Codex remote is useful, but building around a single vendor app still feels a little brittle.

I have a Codex Pro plan and I do enjoy it; I just can’t see myself using it exclusively on the Mac when the same workflow should follow me everywhere.

I also re-read Project Hail Mary–partly because I needed something absorbing that wasn’t a screen, and partly because Weir is one of the few authors who makes engineering problem-solving feel like a page-turner. It holds up, and I can’t wait to see the movie.

Last week’s PPC detour is, surprisingly, working much better than the 68k JIT, but already paid off: my naïve take on memory layouts meant that I hit one of the banes of modern emulation very fast–ASLR on aarch64 Linux was randomising addresses that the JIT needed to be fixed, but now I understand a lot of the issues I was having with 68K version.

The fix for now was to have the binary disable its own ASLR at startup via personality(ADDR_NO_RANDOMIZE) and re-exec, which is ugly but works and is the sort of thing nobody documents. And after doing that on the BasiliskII side as well, a lot of issues went away.

Both JITs now have proper Makefile workflows with tmux targets, which means I can build, test, run and kill either emulator from a single command–which I’ve been doing with my iPad, from the comfort of my couch.

As to the Cydintosh, it is not assembled, because the resistive touch screens I have are borderline unusable for precise tapping (so good thing I only 3D printed a test fit with old filament). I ordered a couple of larger capacitive ones and a bunch of other ESP32 stuff, so I expect to come back to that next weekend.

My little Proxmox hack has been working great–although I had to fix a few things after upgrading one of my nodes (regression testing is the bane of my existence these days), pve-microvm now supports all the operating systems I care about, a few I had never considered using, and other than the fact that I am creatively patching Proxmox’s interface, it has been pretty stable, which was unexpected.

I got piclaw to hack in a custom OCI dialog to replace the Create VM wizard, an xterm.js console tab for microVMs (noVNC makes zero sense for serial-only machines), and a bunch of other features.

And of course it broke when Proxmox shipped a patch release, but since I have a z83ii as a sacrificial node I can contain the blast radius of any upgrades. Mostly.

But right now I’m converting most of my LXCs to microVMs, and it’s been a blast–the speed is fantastic, and the fact that I can run Plan 9 in a microVM is just icing on the cake.

Like I wrote above, regressions are the bane of my existence, and I am getting really annoyed at TypeScript because despite all the nice tooling, it can still pass most linting and “compiling” and fail spectacularly at runtime. And since the upstream Pi packages have been undergoing considerable churn and breaking changes, a lot of piclaw broke in various ways, and experimenting with different models really doesn’t help.

Even as I’m typing this, I am (yet) again waiting for an OpenAI model to audit some UI breakage that Anthropic’s models caused, because they just drop chunks off the code when editing it sometimes, but I am getting really annoyed at fixing things three times in a row…

And yet, the flexibility of Pi and its extension model is pretty amazing–I decided to adopt it wholesale and have started breaking off pieces of piclaw into a piclaw-addons repository, into which I can throw all the mad experiments I want–for instance, yesterday I hacked together a “cheapskate” addon (a cost-conscious model router) that lets you use a bunch of free tiers across various providers, something that would be impossible to do in most harnesses…

And yet, I think it’s time to have a backup. So I created gi, a Go harness inspired by Pi and designed for extensibility, but where all the extensions are externalized to the point where they can’t (hopefully) break the core, and where I want to try to rewind the clock to the simpler times of LISP machines–take your workspace, copy a state dump to another machine, and just carry on.

So I designed it as a single Go binary that can pack everything into a single SQLite database, and that binary embeds both a Clojure dialect (via Joker) and a JavaScript engine that can hook into the state machine–so extensions can be written in either and live inside the SQLite blob alongside everything else.

And in true belt and suspenders style, I’m going to pack both a TUI and a web UI in the same binary.

But, most importantly, I’m taking a completely different approach at dependencies and testing–starting with bringing together most of my previous stuff in various forms, and writing a functional test suite and not just a code one. Still missing tool execution, keychain, workspace indexing–but it’s at the point where I can sit down and have a conversation with it.

Yeah, I know. Another project. But I realized that I needed to remind myself of how to bootstrap a kernel on bare metal before I even try to get Haiku running outside QEMU, so I started poking at porting 9front to one of my ARM SBCs.

Plan 9’s ideas about distributed computing and per-process namespaces have been rattling around in my head since the 90s, but more to the point it is a very simple system, and shifts the bulk of the effort into getting uboot and hardware bootstrapping to work instead of trying to figure out everything at once.

As a fun detour from that, I ended up creating a simple USB Video viewer to pull up video output from a USB capture card to watch things crash spectacularly.

Yet Another Website

While I was at it, I finally got around to refreshing rcarmo.github.io–my open source landing page, which had been accumulating a decade of pixel dust while I was off doing other things.

It’s nothing fancy: a single page that groups some of my repositories by topic (AI agents, cloud, hardware, infrastructure, libraries, macOS, terminal stuff) with one-line descriptions for each, and acts as a sane front door for anyone who stumbles onto my GitHub profile and doesn’t fancy scrolling through 380-something repos.

The rest of the week’s GitHub activity was the usual scattering: a small go-ai update (the unified LLM client I’m using inside gi), some ground-init and mdnsbridge cleanups, a zmk-config-totem tweak for the split keyboard I’ve been slowly getting used to, and a couple of apfelstrudel commits–because if I’m going to break my brain on emulators all week, I might as well let an AI agent help me make some weird music every now and then.

Flint, my “very stable” agent, kept earning its keep on the side: I finally split out MLX and embeddings as their own AI subsections (consolidating entries that had been awkwardly squatting in the language tables) and tucked away a couple of agentic odds and ends–notably pi-draw and a baloney detection kit–into the relevant pages.

None of this is glamorous, but the resource pages have been drifting for a while, and having an agent do the boring sorting (and ask me sensible questions about edge cases) is exactly the kind of thing to deal with chores I’ve been putting off for years.

And yeah, I know it’s too much, and that I’m spreading myself too thin.

For background on how Pi.dev and the agent evolved, see Mario Zechner’s write-up.

This page tracks the Pi-centric projects, adapters, and clients that extend the core agent, including alternate front-ends, web access tooling, and automation bridges within the wider Agentic Systems collection.

Field	Category	Date	Link	Notes
Agent Platforms	Tools	2026	Mercury	Personal AI assistant that runs in pi workspaces, bridges WhatsApp/Slack/Discord, and orchestrates containerized agents per space with APIs, chat routing, and extensions.
			pi-generative-ui	Reverse-engineered generative UI extension for pi that streams interactive HTML/SVG widgets into native macOS windows via Glimpse, letting the LLM render live charts, sliders, diagrams, and dashboards.
			Glimpse	lightweight macOS micro-UI toolkit for agent scripts using WKWebView + JSON-lines IPC, useful for pi companion windows, overlays, and generative UI experiments.
			pi-gdocs	pi extension that lets agents read and update Google Docs design docs directly, preserving comments and formatting anchors better than Markdown copy-paste.
			my-pi	Personal pi extension/skill bundle that adds todo, subagent, clipboard, notifications, file-watcher, code-ast, antigravity-image-gen, and memory, plus bundled browser/search + superpowers skills.
			pi-tmux	tmux helpers for pi that coordinate long-running commands via pi-semaphore locks, offering tmux-bash/capture/send/kill/coding-agent, /tmux-list, and the /supervise <task> orchestrator while blocking unsafe git restore calls from the builtin helpers.
			pi-side-agents	pi extension that spawns short-lived tmux/worktree side agents via /agent, tracks them in the statusline, offers /agents oversight, and provides agent-setup plus orchestration helpers for running asynchronous coding sprints.
			pi-boy	Goofy pi extension that runs Game Boy/Game Boy Color ROMs via a bundled mGBA bridge, rendering inline or overlay with Kitty/ANSI fallbacks, ROM picker, and audio toggles.
			Pi for Excel	open-source multi-model AI sidebar add-in for Excel with 16 built-in spreadsheet tools, MCP gateway, and workbook recovery
Code Agents			pi_agent_rust	high-performance Rust port of pi-mono coding agent with instant startup, low memory footprint, and capability-gated security model
			pi-queue	a lightweight task runner that accepts webhook tasks, requires human approval, and executes pi jobs in isolated git worktrees
			Graphone	cross-platform desktop UI for the pi-mono coding agent, built with Tauri 2.0 and sidecar pattern
			pi-agentic-compaction	pi extension that replaces one-shot prompt compaction with a virtual-filesystem summarizer that explores /conversation.json via jq/grep, supports configurable models and thinking levels, and accepts /compact <note> guidance.
			pi-token-burden	pi extension that parses the assembled system prompt and shows a token-budget breakdown by section with a stacked bar and drill-down table
			pi-companion	a web, mobile and desktop client for pi.
			pi-mono	a coding agent and toolkit for building and managing LLM-driven agents and deployments.
			pi-packages	collection of pi packages including extensions, skills, prompt templates, and themes such as multi-provider model, firecrawl, and image-generation integrations.
			pi-autoresearch	pi extension + skill for autonomous experiment loops that benchmarks changes, auto-commits candidates, shows a live status widget and dashboard, and keeps or reverts edits based on measured results.
			pi-btw	pi extension that adds a /btw command for immediate side questions, showing answers in an overlay without interrupting the current agent run and optionally saving the result.
			pi-multi-pass	multi-subscription extension for pi with automatic OAuth account rotation, TUI /subs and /pool management, and cooldown-based failover across providers.
			pz	a Zig-based, single-binary drop-in replacement for the pi coding agent
			pi-tramp	TRAMP-like remote execution for the pi coding agent over SSH or Docker
			rho	an always-on personal AI operator derived from pi that runs in the background, remembers context, and checks in on a schedule across macOS, Linux, and Android
			pi-draw	a drawing/diagram extension for the pi coding agent by Armin Ronacher
			pi-boomerang	token-efficient autonomous task execution with context collapse for pi coding agent.
			pi-interactive-shell	an interactive-shell extension for the pi coding agent with full PTY emulation and observable overlays
			pi-mcp-adapter	Pi adapter that collapses MCP tool access into a lightweight proxy with lazy server startup, optional direct tools, and built-in MCP UI session support.
			pi-web-access	web search, content extraction, and video understanding plugin for the pi-mono coding agent with smart provider fallbacks
			PiApp	toy macOS/iOS app for experimenting with the PiSwift coding agent, with Claude chat, file browser, and terminal
			pi-acp	ACP adapter that bridges pi’s RPC mode to ACP clients like Zed over JSON-RPC stdio
			PiSwift	Swift port of pi-mono for embedding a coding agent in apps, with in-process subagents and prompt templates
Interfaces	Desktop		pi-gui	Electron desktop shell for pi sessions — lists workspaces and sessions, creates new conversations, and persists UI state; macOS arm64 beta with Homebrew cask planned

]]> https://taoofmac.com/space/ai/mlx?utm_content=atom 2026-04-25T12:00:00+00:00 2026-04-25T12:00:00+00:00 Rui Carmo https://taoofmac.com A collection of tools, frameworks, and models built on or optimized for Apple’s MLX array framework and the Neural Engine (ANE) on Apple Silicon. MLX is Apple’s answer to PyTorch/JAX for the M-series chip, with lazy evaluation, unified memory, and first-class Python bindings.

Field	Category	Date	Link	Notes
Audio	Models	2026	mlx-audiocraft	MLX port of Meta’s AudioCraft for Apple Silicon — music and audio generation via MusicGen and AudioGen
Frameworks	Core	2023	MLX	An array framework for Apple Silicon — the foundation for all MLX-based tools
	Examples		mlx-examples	Official Apple MLX examples covering LLMs, image generation, speech, and more
Inference	Libraries		ml-ane-transformers	Apple’s Transformers library optimized for the Neural Engine
			Python Bindings for Apple Intelligence	Python bindings to Apple’s on-device foundation models
Research	Tools	2026	autoresearch-ANE	Autonomous Apple Silicon LLM research suite combining ANE, MLX, and legacy MPS training paths

]]> https://taoofmac.com/space/ai/embeddings?utm_content=atom 2026-04-25T12:00:00+00:00 2026-04-25T12:00:00+00:00 Rui Carmo https://taoofmac.com Libraries, databases, and models for generating, storing, and querying dense vector embeddings — the backbone of semantic search, RAG pipelines, and similarity-based retrieval across text, images, and other modalities.

Field	Category	Date	Link	Notes
Embedding Models	Libraries	2026	gte-pure-C	Pure C implementation of the GTE-small text embedding model (dependency-free, 384-dim) focused on semantic similarity and search
		2024	txtai	embeddings database for semantic search, LLM orchestration, and RAG pipelines
Search Retrieval		2026	nndex	high-performance Rust nearest-neighbour vector search with Python bindings, SIMD/rayon CPU backend and wgpu GPU backend
	Tools		doppelgangers	clusters GitHub issues and PRs with embeddings and UMAP for visual triage
Vector Databases	Libraries		Zvec	in-process vector database built on Alibaba’s Proxima engine for low-latency similarity search
		2025	OctaneDB	lightweight Python vector database with HNSW indexing and flexible storage options
		2024	tinkerbird	vector database atop IndexedDB for in-browser semantic search
		2023	pgvector-python	Python client for using Postgres as a vector database via pgvector

]]> https://taoofmac.com/space/ai?utm_content=atom 2004-01-22T21:22:58+00:00 2026-04-25T12:00:00+00:00 Rui Carmo https://taoofmac.com That grand, spacious (and long ignored) branch of computing that I never really found a reason to graduate in (big mistake I only realized 30 years later) and that, these days, deals not just with thinking machines (so-called “hard” AI), but mostly with enhancing the usefulness of machines in general by exploring mechanisms to express and manipulate harvested knowledge.

Or just pretty pictures and sophisticated text generation. Either way, it seems we’re currently between AI winters, with a lot of investment in GPU hardware that still needs to prove itself consistently, measurably useful in real life use cases.

Note: Items pertaining to Large Language Models, Agentic Systems, Model Context Protocol, Speech, Stable Diffusion/Image Generation, MLX/Apple Silicon AI, and Embeddings & Vector Search are now in their own section, as this page was getting too crowded. I will be moving other sections out of here as well as they grow over time, so that this page can focus on the more general aspects of AI and ML.

Field	Category	Date	Link	Notes
General	Examples	2025	edgeai-for-beginners	a collection of tutorials and examples for running AI models on edge devices
		2024	flash-attention-minimal	a minimal implementation of Flash Attention
	Frameworks		tinygrad	A 8000 LOC deep learning framework
		2023	marvin	A generic wrapper for various AI APIs
	Gateways	2026	GOModel	high-performance AI gateway in Go — unified OpenAI-compatible API for OpenAI, Anthropic, Gemini, Groq, xAI and Ollama with observability and streaming
	Jupyter	2023	jupyter-ai	an official Jupyter plugin that can handle multiple AI back-ends (although it seems less flexible than the others right now)
	Libraries	2025	go-attention	a full attention mechanism and transformer in pure Go
		2023	unstructured	a library for handling and segmenting unstructured data of various kinds, from text to common file formats
		2020	TextHero	an NLP library for large-scale text processing
		2018	go-neural	neural network in Go
			goml	stream-oriented ML library in Go
			gonn	neural network in Go
			word2vec	word2vec model support in Go
			golearn	a machine learning library for Go
			neurgo	a neural network library in Go
		2009	Alchemy	A toolkit providing a series of algorithms for statistical relational learning and probabilistic logic inference, based on Markov logic representation
			discomll	a ML framework for Disco
	Networking	2024	scuda	a GPU over IP bridge that allows remote GPUs to be utilized by CPU-only machines
	Tools	2025	ClaraVerse	a privacy-first local AI workspace (LLM chat, agents, tool calling, automation, image generation)
		2024	scrape-it-now	A flexible scraper implemented in Azure
			treescope	An interactive tensor visualizer for IPython notebooks.
			pico-tflmicro	a port of TensorFlow Lite Micro to the Raspberry Pi Pico
		2023	basaran	An Open-Source alternative to the OpenAI text completion API, with a compatible streaming API for privately hosted models.
			explainerdashboard	a web app that explains the workings of a (scikit-learn compatible) machine learning model
			NVIDIA Triton Inference Server	A high-performance inference server
		2022	Project Bumblebee	Pre-trained and transformer neural models in Elixir.
		2021	Perceptilabs	free visual ML model creation tool
		2020	netron	a viewer for neural network, deep learning and machine learning models
Large Language Models	Frameworks	2025	NLWeb	an approach to make websites easier to integrate into conversational interfaces
		2024	Pathway	a Python ETL framework for stream processing, real-time analytics, LLM pipelines, and RAG
	Libraries	2023	agency	an LLM library for Go
	Tools	2026	PicoLM	a minimal C11 LLM inference engine for GGUF/LLaMA models that streams weights with mmap on low-RAM edge devices
		2023	pykoi	a unified interface for data and feedback collection, comparing models, and doing basic RAG
Multimodal Models	Libraries	2024	zerox	a library that performs OCR on documents and converts them to Markdown
	Models		Hybrid-Net	Real-time audio to chords, lyrics, beat, and melody.
	Music Generation	2025	NotaGen	a tool for generating music from text prompts
	Tools	2024	swift-ocr-llm-powered-pdf-to-markdown	a tool that processes PDF files into structured Markdown format
Time Series Forecasting	Models	2025	moment	a time series forecasting model
Tools	Tools	2026	PowerInfer	GPU/CPU hybrid LLM inference engine that preloads hot neurons to the GPU, offloads cold states to CPU, and exposes llama.cpp-compatible examples along with PowerInfer GGUF weights and predictor tooling for fast local serving on consumer GPUs.
Vision	Libraries	2025	grayskull	a lightweight library for vision operations in resource-constrained devices
	Tools	2024	machina	a CCTV viewer that connects to RTSP streams and performs real-time object tagging using YOLO and ollama

]]> https://taoofmac.com/space/dev/rust?utm_content=atom 2020-09-01T10:41:00+00:00 2026-04-25T10:33:07+00:00 Rui Carmo https://taoofmac.com The language that helped coin the moniker Rust Evangelism Strike Force, and which is slowly starting to get to me.

Category	Date	Link	Notes
Backend	2024	trailbase	a self-hostable Firebase replacement
Data	2021	ballista	an Apache Spark-like distributed execution environment
	2023	lance	a modern columnar data format that is optimized for ML workflows and datasets, compatible with pandas
Editors	2026	Ferrite	A fast, lightweight text editor for Markdown, JSON, YAML, and TOML files built with Rust and egui
Embedded	2024	embassy	a framework for ESP32, Pico and Nordic MCUs
	2026	mousefood	a no-std embedded-graphics backend for ratatui
GUI	2024	dioxus	GUI library for desktop, web, mobile, and more, using the system webview
		egui	a simple, fast, and highly portable immediate mode GUI library for Rust.
		graphpu	a 3D GPU graph visualization application
	2025	azul	a desktop GUI framework for Rust
Game Engines	2020	Bevy	a data-driven game engine
		GameLisp	a scripting language for Rust game development
		RG3D	a 3D game engine
Learning	2024	rustlings	a collection of small exercises to get you used to reading and writing Rust code
Libraries	2020	lunatic	a platform for building actor systems running WebAssembly
		pulldown-cmark	Markdown paraer
		rust-crdt	A family of CRDT’s supporting both State and Op based replication
		syntect	Syntax highlighting using Sublime Text definitions
	2021	bastion	a distributed fault-tolerant runtime system
		comrak	a Rust port of cmark-gfm
	2023	ratatui	a library for developing text user interfaces
		ractor	an actor library
	2024	kameo	a lightweight library for building fault-tolerant, distributed, and asynchronous actors
	2025	ratzilla	a library for building terminal-themed web applications using Rust and WebAssembly.
		pagefind	a static site search engine that runs in the browser
	2026	FrankenTUI	minimal, high-performance terminal UI kernel for deterministic, flicker-free inline UIs with a diff-based renderer and strict cleanup guarantees (Rust nightly, WIP)
		xmloxide	A memory-safe Rust reimplementation of libxml2 that passes the W3C XML conformance suite, provides XML/HTML parsers, XPath, validation, canonicalization, and a xmllint-compatible CLI.
Microservices		openworkers	a self-hostable implementation of Cloudflare workers
Networking	2024	koblas	a simple SOCKS5 proxy
Parallelism	2020	rayon	a data parallelism library
	2024	kay	An intriguing, mostly self-contained Actor system
Profiling	2020	heaptrack	a memory profiler
Reference	2023	The Rust on ESP Book	A very nice guide on how to do Rust development for Expressif ESP32 devices
Security	2026	LiteBox	a security-focused sandboxing library OS for reduced host attack surface
		monty	a minimal, secure Python interpreter in Rust for running AI-generated code
Servers	2022	meilisearch	another search engine with document-level access control
		tantivy	another search engine (Lucene-inspired)
		sonic	a fast and schema-less indexing/search backend
	2026	Garage	an S3-compatible distributed object storage service for small-to-medium self-hosted clusters
		narwhal	an extensible pub/sub messaging server for edge applications
Tools	2020	rust-musl-builder	Docker wrappers for building Rust binaries with musl
	2021	tauri	an Electron alternative that uses system webviews
	2022	mcfly	an enhanced ctrl-r replacement
	2024	dtui	a tool to inspect the system/session dbus
		zoxide	a port of the venerable z utility to Rust
	2025	monolith	a tool to save web pages in a unified HTML format
	2026	eilmeldung	a fast TUI RSS reader based on the news-flash library
		vcad	Parametric CAD in Rust; exports STL, glTF, USD, DXF
		Google Workspace CLI (gws)	One CLI for every Google Workspace API; discovers commands from Google’s Discovery Service, emits structured JSON for humans and agents, and ships dozens of reusable agent skills + an MCP server.
		siomon	Linux TUI/CLI hardware and sensor monitor written in Rust, ships as a static binary with zero runtime dependencies plus JSON/XML/HTML outputs, alerts, and CSV logging.
		Horizon	GPU-accelerated terminal board with an infinite 2D canvas, workspaces, and AI-aware panels for coding workflows.
Web Frameworks	2023	Rocket	a mostly complete async web framework
	2024	spring-rs	a microservice framework inspired by spring-boot

]]> https://taoofmac.com/space/ai/speech?utm_content=atom 2025-05-01T18:15:00+00:00 2026-04-25T10:33:07+00:00 Rui Carmo https://taoofmac.com This page is a collection of notes and links related to AI speech technologies, including Text-to-Speech (TTS), Speech-to-Text (STT), voice synthesis, voice cloning, and other related frippery in the modern AI space.

Field	Category	Date	Link	Notes
Generative Audio	Models	2023	bark	a text-prompted genereative audio model
Speech Agents	Tools	2026	RCLI	an on-device Apple Silicon voice agent for macOS that combines STT, local LLM inference, TTS, 38 local actions, and document RAG in a low-latency TUI/CLI.
		2025	Asterisk-AI-Voice-Agent	An Asterisk-based AI voice agent project integrating telephony with voice AI workflows.
Speech Recognition	Libraries		WhisperKit	a Swift package that integrates Whisper with Apple’s CoreML
	Models	2024	WhisperLive	a real-time text-to-speech system based on Whisper
			moonshine	a family of models optimized for fast and accurate automatic speech recognition on resource-constrained devices. Designed to run efficiently on smaller hardware.
		2023	distil-whisper	a distilled version of whisper that is 6 times faster
		2022	whisper.cpp	a C++ implementation of whisper that can run in consumer hardware
			whisper	a general purpose speech recognition model
	Tools	2026	TypeWhisper	A macOS dictation and transcription app that can use Apple’s speech stack as well as other local on-device engines, with optional prompt-driven post-processing.
			Handy	An offline, cross-platform speech-to-text app built with Tauri that transcribes locally. Uses Whisper and Parakeet models without sending audio to the cloud.
			Ghost Pepper	a 100% local macOS hold-to-talk speech-to-text menu bar app with WhisperKit transcription and local LLM cleanup.
			dictate	a Go-based local voice-to-text tool for Linux terminals that streams whisper.cpp transcription to stdout, files, or keystroke injection for dictating into focused terminal apps.
		2024	audapolis	an editor for spoken-word audio with automatic transcription
		2023	insanely-fast-whisper	An opinionated CLI for audio transcription
	Transcription Tools	2026	buzz	A cross-platform Whisper desktop app that works quite well on the Mac (including speaker diarization)
		2025	OpenTranscribe	an open-source all-in-one recording transcription and diarization stack
Speech Synthesis	Implementations	2026	pocket-tts.c	A minimal, dependency-free C scaffold for Pocket-TTS, aimed at CPU-only TTS. Includes a tiny CLI in the flux2.c style.
	Models		sopro	a lightweight text-to-speech model
		2025	csm	a speech generation model from Sesame that generates RVQ audio codes from text and audio inputs.
			Orpheus-TTS	an open-source text-to-speech system built on Llama-3b
			chatterbox	a text-to-speech model that can generate expressive speech with a variety of styles and emotions.
		2024	ChatTTS	a text-to-speech model designed specifically for dialogue scenarios, with decent prosody
			Real-Time-Voice-Cloning	a PyTorch implementation of a voice cloning model
			WhisperSpeech	a text-to-speech system built by inverting Whisper
		2023	StyleTTS2	A text to speech model that supports style diffusion
			silero-models	Multi-language neural text-to-speech models
	Resources		Training a voice for piper TTS	a detailed walkthrough of how to customize a voice model
	Tools	2026	Voicebox	an open-source voice cloning studio with DAW-like features, local-first voice synthesis powered by Qwen3-TTS, multi-track timeline editor, and REST API
			pocket-tts	A lightweight text-to-speech (TTS) application designed to run efficiently on CPUs that supports voice cloning
		2025	voice-pro	a toolkit for doing speech processing and voice cloning
			abogen	a tool for generating audiobooks from text using the Kokoro open weights model
			edge-tts	a text-to-speech module that leverages the Microsoft Edge TTS API
			podcastfy	a tool for generating podcasts from text
		2024	OpenVoice	a tool that enables accurate voice cloning with multi-lingual support and flexible style control.

]]> https://taoofmac.com/space/dev/golang?utm_content=atom 2013-06-28T10:12:00+00:00 2026-04-25T05:49:26+00:00 Rui Carmo https://taoofmac.com A great systems-oriented programming language I’ve taken up to complement Python due to its ability to cross-compile and produce (mostly) self-contained static binaries.

Shrinking executables via gccgo and upx:

go build -mod=vendor -gccgoflags '-Os -s' -o main && upx --best --lzma main

Category	Date	Link	Notes
Authentication	2025	obligator	a relatively simple and opinionated OpenID Connect (OIDC) server
		pocket-id	A simple and easy-to-use OIDC provider
		tinyauth	a simple authentication server that integrates with traefik
	2020	authelia	authentication and authorization server providing 2-factor authentication and single sign-on
		tobab	an identity-aware proxy
		Ory	a full IAP authentication solution with OpenID integration
		loginsrv	a standalone minimalistic login server providing a JWT login for multiple login backends
	2018	traefik-forward-auth	a forward auth service that provides OAuth support for the Traefik reverse proxy
Big Data		gohadoop	A set of libraries to build Hadoop jobs
	2015	Glow	An easy-to-use distributed computation (map-reduce) system in pure Go.
Configuration	2018	envconfig	simple, no-frills environment variable handling
	2017-01	viper	A flexible configuration solution for 12 factor apps (and more)
Data Science	2025	zasper	a Jupyter clone designed for massive concurrency with minimal resource usage.
	2018	go-freeling	Natural language processing
		gonum/floats	operations on slices of floats
		gonum/graph	Graph navigation/traversal
		gonum/matrix	Matrix algebra
		gonum/optimize	Gradient descent and minimization
		gonum/plot	Plotting and visualization
		gonum/stat	statistics package
		gophernotes	A Jupyter kernel for Go
		gota	DataFrames, Series and data manipulation
		regression	Multivariable regression
		csvutil	CSV and tabular data
Data Structures	2016	gen	Clojure-like immutable data-structures and functional helpers
Database	2025	pennybase	Poor man’s Backend-as-a-Service (BaaS), similar to Firebase/Supabase/Pocketbase
	2022	sqlite	a Go interface to sqlite3
		go-sqlite3-stdlib	a set of math and statistics extensions to sqlite
	2021	nakama	A game-oriented state server, backed by CockroachDB
	2020	dbmate	a database migration tool that supports MySQL, PostgreSQL, SQLite and ClickHouse
	2016	gorm	A Go ORM library
Desktop	2025	fynedesk	a desktop environment built with the Fyne GUI toolkit
	2022	wails	an Electron-like framework for desktop app development
Frameworks	2024	htmgo	a lightweight framework for building interactive web applications using Go and htmx without JavaScript
GUI		gio	a cross-platform GUI library for Go
		spot	a React-like destkop GUI toolkit for Go that supports FLTK and Cocoa
	2023	fyne	a cross platform GUI toolkit that can be used in Android and iOS
	2022	tinygui	a GUI toolkit for TinyGo
Graphics	2025	fauxgl	a software rasterizer and 3D renderer
		meshview	a 3D viewer for STL meshes
	2022	sdfx	a CAD package written in Go
	2016	gift	The Go Image Filtering Toolkiti
HomeKit	2022	hap	a rewrite of the brutella/hc HomeKit library
IoT	2020	tamago	compile and execute Go on bare ARM SoCs
	2018	gokrazy	a pure-Go userland for Raspberry Pi 3 appliances
		tinygo	an LLVM compiler for small devices
Learning	2026	go-kata	A collection of daily coding challenges to master idiomatic Go through deliberate practice
Libraries		go-bt	A minimalist behavior tree library for game AI, background workers and async logic
	2025	script	a library for building script alternatives
		event	simple internal event bus for Go applications
	2024	rill	a toolkit for clean, composable, channel-based concurrency
		darwinkit	a library for building Darwin (macOS) apps
		lo	a lodash-style library for generics, map, filter, contains, find, etc.
		go-funk	a library with map, reduce and other functional primitives
	2023	ergo	an impressive Erlang-compatible library for implementing OTP design patterns
		sdf	signed distance function shape generation
		oidc	OpenID Connect client and server library
	2022	maphash	Hash any comparable type using Golang’s fast runtime hash.
		imagemeta	supports EXIF, XMP and HEIC metadata parsing
		natiu-mqtt	a self-contained MQTT implementation
	2020	Chroma	a fast generic syntax highlighter
		olric	A distributed cache and in-memory key/value data store that can be used standalone or embedded.
	2019	bild	a collection of parallel image processing algorithms
	2018	go-imap	an IMAP client library
		goworker	A Resque-compatible library for background workers
		go-dsp	A digital processing package
		ffjson	Faster JSON for Go
		gjson	Fast JSON data retrieval
		scrape	A simple interface for Go web scraping
	2016	go-linq	LINQ-like functionality with coroutine support
		libchan	A network-enabled abstraction that mimics channels
Messaging	2024	SmoothMQ	is a drop-in replacement for AWS SQS
	2018	nsq	A message queueing system
Microservices	2020	flogo	a low-code environment with streaming support and a Node-RED like approach.
		flatend	an interesting take on deployment and discovery via P2P/Kademlia
	2019	go-micro	a microservices framework with pluggable components for discovery, transports, etc.
Middleware	2017-11	casbin	a flexible access control library
Networking	2023	blocky	DNS proxy/ad-blocker for local network (can run inside of gokrazy)
	2018	router7	A router based on gokrazy
Other	2021	macdriver	Objective-C bindings for Go
	2018	Shrinking Go binaries	By stripping debug symbols and using upx
		go-bindata	Pack external assets into a Go program as binary data
Parsers	2016-06	etree	An XML handling library modeled on Python’s ElementTree
Protocols	2026	Pion Handoff	a Go tool for moving a browser-created WebRTC session into a backend process so you can record, inject media, or inspect decrypted traffic.
	2016	go-vnc	An extensible VNC protocol library
	2015-03	torrent	An embeddable BitTorrent library
	2015-01	mangos	A network library for IPC patterns
Robotics	2014	Gobot	A set of robotics-oriented libraries
Search	2016	blevesearch	A Lucene-like indexing library
Servers	2023	mox	modern full-featured (SMTP, IMAP, DKIM, etc.) mail server
	2020	maddy	a composable, all-in-one SMTP/IMAP server
System	2018	suture	A library that implements Erlang-like supervision trees
Tools	2025	shiori	a simple Pocket-like bookmark manager with a web interface, able to archive pages like ArchiveBox
		minimalytics	a minimalist analytics tool backed by SQLite
		act	a tool for running GitHub Actions locally
		u-root	a Go-based userspace for embedded systems and cloud environments.
	2024	bruin	a data pipeline tool that integrates data ingestion, transformation, and quality checks.
		gozer	A simple static site generator
		monogon	a Linux userland in pure Go
		nano-web	Hyper-minimal webserver for serving SPAs and static content
		zoraxy	A general purpose HTTP reverse proxy and forwarding tool
	2023	glow	a CLI Markdown renderer in te spirit of more/less
		gojekyll	A partial reimplementation of Jekyll in Go
	2022	vhs	terminal demo recorder with GIF/ffmpegre output
		goweight	a CLI tool to identify which libraries contribute most to binary size
	2021	till	a web scraping caching proxy that handles most of the anti-scraping mechanics
		zinc	a lightweight alternative to elasticsearch that claims to run in less than 100 MB of RAM and has a broadly similar API
		pyroscope	a profiling platform with support for Go, Python and Ruby
	2020	Got	a tool/library that uses concurrent HTTP range requests for faster downloads
Transpilers	2014	Tardis Go	A transpiler to JavaScript
		funcgo	A simplified dialect that compiles to Clojure
		GopherJS	A transpiler to JavaScript
UI	2025	gotui	a cross-platform terminal UI library that supports terminal dashboards and charts
	2019	muon	a lightweight alternative to Electron with go bindings
	2018	termui	A terminal-oriented dashboard library
	2014	ui	A platform-native GUI library
Video	2024	go2rtc	a camera proxy that can surface RTSP cameras to HomeKit (and much more)
		broadcast-box	a tool for broadcasting video streams to multiple platforms using WebRTC
Web	2022	but	a full-stack web framework with server-side rendering and good JS integration
	2020	gearbox	A web framework built around fasthttp
	2018	Beego	Ships with an ORM and built-in monitoring
		QOR	A set of libraries for E-Commerce and CMS
		Gin	uses a Radix tree for routing, handles panics
		Gobuffalo
		Iris	Lots of features and plugins
	2017-07	HttpRouter	A high performance HTTP router
		Goji	A Sinatra-inspired, minimalist framework
	2016-06	echo	A high-performance HTTP server framework with LetsEncrypt support
Web Frameworks	2024	sandwich	a middleware & routing framework
		pocketbase	a Firebase-like web app realtime backend with SQLite, user and file management, and a dashboard UI.
Writing	2023	vale	an extensible linter for prose

]]> https://taoofmac.com/space/dev/python?utm_content=atom 2007-04-15T10:44:37+00:00 2026-04-25T10:33:07+00:00 Rui Carmo https://taoofmac.com Python is one of my favorite programming languages due to its terseness and amazing flexibility, and after decades using it I find it quite amusing that it is now the language of choice for data science and machine learning.

Year	Item	Notes
2016	Sushy	my current wiki engine
2015	rss2imap	The way I used read my news a while back
2009	PNG Canvas	a native Python PNG creation module, suitable for use in Google App Engine
2007	Yaki	my previous wiki engine
2006	MailArchive	a quick hack to file web pages as MIME compliant e-mail messages.
2005	PicoStats	a minimalist Apache log parser.
	IMAP Backup	another quick hack that apparently filled a long-standing need.
	The Python Grimoire	which I converted into TiddlyWiki format
2004	newspipe	which I used daily for a couple of years and occasionally contributed to
	PicoRendezvous.py	a minimalist (and dumb) Bonjour / Rendezvous client
	Growl native protocol implementation	this spawned numerous variants, including a proxy.

Resources

Category	Date	Link	Notes
Astronomy	2021	Skyfield	An astronomical library for Python
Audio	2024	pedalboard	a library for audio processing
Authentication	2023	authlib	OAuth, OpenID Connect and other niceties
	2021	aioauth	Oauth 2.0 framework and provider for asyncio
Automation	2024	helium	a library for automating browsers such as Chrome and Firefox
CAD	2025	sdfCAD	Simple 3D mesh generation with Python based on SDFs
	2024	build123d	a parametric BREP modeling framework for 2D and 3D CAD built on OpenCascade
	2023	sdf	Generate 3D meshes based on SDFs (signed distance functions)
		sdf (Gitlab)	Another version of the sdf library with additional functionality
CLI	2021	pqdm	parallel tqdm
	2020	pyp	a clever shell tool to do inline Python
		typer	A click-like library for building CLI applications
	2019	tqdm	a configurable progress bar
	2018	python-fire	a CLI wrapper for any Python object
		click	A very nice way to do composable CLI tools (see also argh, defopt, docopt, python-fire, etc.)
		Clint	A great module for developing CLI apps
		pbs	A nice, simple and consistent generic command wrapper.
		ptpython	The Python Prompt Toolkit
		plumbum	Another command wrapper, with SSH support.
Cloud	2026	Stelvio	a pure-Python framework for building and deploying AWS apps with the stlv CLI
	2020	pyinfra	a fabric-like agentless automation tool
Coding	2025	pyscn	an intelligent python code quality analyzer
Compilers	2022	codon	an LLVM compiler for a Python subset
	2021	mypyc	a compiler for a subset of type-annotated Python
		Transcrypt	Another JavaScript transpiler
Compression	2021	zipfly	a library for doing on-the-fly zip compression with low memory footprint
Concurrency	2024	dramatiq	background queueing/task processing library
		protean	framework for building event-driven applications using the CQRS pattern
		asyncpal	a unified approach at providing elastic task pools
	2023	mpire	a multiprocessing replacement with a number of additional features
	2020	aiomultiprocess	an asyncio Pool implementation to manage multiple processes with independent event loops
		Trio	a friendlier wrapper around asyncio for concurrent tasks
		OpenReplica	A coordination service that provides replication and synchronization support for large-scale distributed systems
		python-rq	A simpler queueing library
		Pulsar	Another actor-based multiprocessing library with asyncio support and a fair degree of network transparency
		Celery	My current go-to library for task queueing
		Pykka	An implementation of the Actor model, with gevent support
		offset	ports of the Go concurrency model
		aioprocessing	A set of asyncio equivalents of the multiprocessing library
		ray	A distributed execution engine that implements a pandas clone
		goless	ports of the Go concurrency model
		Littleworkers	Parallel job management without the hassles.
Console	2020	rich	a console library with various layout options
		bpython	My favorite REPL
		Colorama	Making ANSI color sequences work cross-platform (see also this gist)
		fabulous	Prints images to console
		urwid	A curses based library for building console UIs
Data Engineering	2024	polars-h3	a Polars extension that adds support for the H3 discrete global grid system
	2020	Little Ball of Fur	a graph sampling library that works with NetworkX
		riptable	a multithreaded array processing library
		Happy	A Hadoop library to run map-reduce jobs via Jython
		biplist	A library that can manage Mac binary .plist files
		pyparsing	a handy, flexible parser library that does away with lex/yacc.
		snakebite	A native HDFS client to access the Hadoop datastore.
		xlwings	An Excel plugin
		Bounter	A fast probabilistic counter
		voluptuous	A data schema validation library.
		fuzzywuzzy	A fuzzy string matching library
		PyCascading	A better way to write Hadoop jobs.
		xlwt	a library to parse Excel documents (cheatsheet.
Data Science	2025	DataSynthesizer	a library for generating synthetic data
		kreuzberg	a text extraction library supporting PDFs, images, office documents and more
		mimesis	a library for generating fake data
		Merlion	A time series forecasting library
		pydbgen	another library for generating synthetic data
	2024	sail	unifies stream and batch processing with a drop-in replacement for Spark SQL
		cuDF	a GPU DataFrame library leveraging CUDA
	2023	pygwalker	a Tableau-like dataframe exploration tool for Jupyter
		datapane	a data and reporting and analisys framework
		fugue	a unified interface for executing SQL, Python and Pandas code on Spark, Dask and Ray
	2021	Kats	a time series analysis library
		euporie	a text-based interface for Jupyter notebooks
		xeus-sql	a Jupyter kernel for SQL databases
		eztable	a simple table library
		pyxelate	a pixelation/dithering algorithm that uses a mix of algorithmic and ML approaches
	2020	papermill	a way to parameterize and automate Jupyter notebooks
		SciPy	scientific (including plotting) libraries for Python
Data Validation	2021	schema	another data validation library
		pydantic	Data validation using type hinting
		Schematics	A validation/schema handling library.
Database	2025	mssql-python	a Microsoft SQL Server driver for Python
		aiosqlitepool	a connection pool for aiosqlite
	2023	mongolite	another MongoDB-like database
	2021	pottery	a Redis library with Pythonic syntactic sugar
		dataset	trivial abstraction layer over SQLAlchemy
		Mongita	a MongoDB-like database library for in-process use
	2020	DuckDB	an embeddable SQL database with OLAP features
		montydb	a tiny MongoDB implementation in pure Python
		simple-graph	A simple graph database in SQLite
		pymssql	SQL Server and Sybase driver
		FreeTDS
		SQLAlchemy	tutorial
		Peewee	A small, very flexible ORM
		tinydb	A (very) lightweight document oriented database
		Goatfish	An even smaller schemaless ORM
Debugging	2020	Scalene	A high-performance CPU and memory profiler
		PrettyErrors	an error handler that prettifies output
		Eww	Insert a REPL into a running application
		Pycallgraph	Generate a program flow graph Graphviz
		Hypothesis	A very nice testing framework
		pudb	A console debugger
		lptrace	A pretty amazing single-file strace-like tool for Python
		assertEquals	a testing framework with a great screncast
Django	2025	django-qrauth	a Django library for QR code-based authentication
		django-tastypie	a Django library for building RESTful APIs
		plain	an opinionated fork of Django
		django-rest-framework	another Django library for building RESTful APIs
		django-admin-sortable	a library for adding drag-and-drop sorting to Django admin
	2024	django-organizations	a Django library for managing organization accounts
	2023	django-unicorn	a Reactive framework for Django that uses minimal JavaScript
	2022	django-ninja	for building APIs with Django and Python 3.6+ type hints
	2021	diskcache	a Django-compatible caching library
		wid.gy	A Django-based CMS framework
		Django	Probably the best app framework I’ve every used.
		Wagtail	Another Django-based CMS framework
		django-micro	A lightweight wrapper to use Django as you would Bottle
Electronics	2024	micropython-fusion	a sensor fusion library for MicroPython
		Kalman-Filter-Python-for-mpu6050	a Kalman filter for the MPU6050 IMU
	2023	belay	a library and helper for developing MicroPython projects, including an on-device REPL
	2021	pinout	Helps create SVG pin-out diagrams for electronic hardware
Embedded	2025	MicroPythonOS	a MicroPython-based operating system for embedded devices that can run on ESP32 (and likely the CYD)
		archimedes	a Python framework that lets you develop and analyze algorithms in NumPy and automatically generate optimized C code for embedded systems
Enterprise		toil	A cross-platform pipeline management system with Common Workflow Language support
Environments	2020	snakeware	a Python userspace for Linux
Frameworks	2024	Platypush	a modular platform for home automation with easy MQTT event handling and a graphical editor
Functional Programming		Hy	An awesome LISP dialect that sits atop the runtime.
		funcy	A nice, fairly complete functional library
		Toolz	A functional complement to the standard library.
		pyrsistent	A persistent data structure library
GIS	2021	prettymaps	A minimal Python library to draw customized maps from OpenStreetMap data
		geopy	an amazingly flexible geocoding library.
		reverse-geocoder	A fast offline reverse geocoder
GUI	2025	pytauri	a Tauri binding for Python
	2024	CustomTkinter	offers customizable widgets and supports system appearance modes across platforms
		mesop	a rapid web development framework for Python
		micropython-nano-gui	A lightweight MicroPython GUI library
		nicegui	a library for creating Web UIs
	2022	flet	creates realtime web, mobile and desktop apps using Flutter
	2021	encodermenu	a MicroPython library for GUI creation, using uasyncio
	2020	Gooey	a wxWidgets wrapper for quickly building GUI versions of CLI tools
		DearPyGui	a Linux/Windows GUI library atop ImGUI (C++)
	2019	fman build system	a complete build system for Qt applications
	2018	Toga	a cross-platform GUI that works on the Mac
		kivy	A sophisticated UI/UX library with Android support
		PythonCard	A bit basic, but interesting.
		VPython	3D OpenGL libraries for quick visualization
		winGuiAuto.py	for Windows automation
		pyglet	a cross-platform windowing and multimedia library with OpenGL support
		PySide	A recent Qt binding (up to and including 4.7) with QML support
		PySimpleGUI	a simple tkinter-based GUI wrapper
Graphics	2026	slamd	a lightweight Python 3D visualization library with a GPU-accelerated viewer for point clouds, meshes, camera frustums, and scene-graph style transforms
		splathash	Encodes any image into 16 bytes (22-char base64url) and decodes to a 32×32 preview orders of magnitude faster than BlurHash, with Go/TS/Python reference libs and identical hashes across languages.
	2025	piligraphs	a library for creating charts using PIL
		html2pic	a library for rendering HTML/CSS to images using pictex
		pictex	a layout library for creating component-based graphics in Python, using skia
	2024	renderer	rendering and rasterizing library for STL
		pyrender	glTF 2.0-compliant OpenGL renderer for visualization of 3D scenes
		pygfx	render engine targeting Vulkan/Metal/DX12
	2023	pyxel	A retro game engine for Python
	2022	taichi	a high-performance graphics library
	2021	image-blender	a Cython implementation of Adobe Photoshop blend modes
	2020	blurhash	A way to encode image placeholders as strings
		hiplot	high dimensional interactive plotting
		diagrams	a library for drawing cloud architecture diagrams (Azure, AWS, k8s, etc.)
	2019	douglas-quaid	a library for image matching and correlation
		imagededup	uses several different algorithms (including NNs) to detect duplicate images
		plottyprint	printable formatting for matplotlib
		smc.freeimage	A wrapper for the freeimage library that can handle various TIFF and fax formats as well as ICC color profiles
		Graphite	a real-time graphing system similar to RRDTool
		Skip's Python Bits	lots of useful snippets
		Pygal	An SVG charting library with a variety of built-in formats.
		Pyx	Oldie, but goodie.
		pygame	a game-oriented library with SDL support
		pyprocessing	A Processing clone in Python.
		Vapory	A library to generate photorealistic renderings using POV-Ray
		drawille	Uses Braille characters for TTY charting
		Cropmap	Face-aware image cropping.
HTML		lxml	a different libxml binding, with excellent HTML parsing performance
		cssutils	a CSS parser
		Gnosis Utilities	all sorts of XML goodies
		pygments	syntax highlighter able to handle multiple nested languages
		pyquery	A jQuery-like library for manipulating documents.
		BeautifulSoup	The most powerful HTML parser out there.
		squeezeit	A CSS and JavaScript bundler/minifier
Interpreters	2026	monty	a minimal, secure Python interpreter written in Rust for running AI-generated code
	2024	RustPython	A Python Interpreter written in Rust
	2023	pocketpy	an embeddable C-based interpreter in 5000 LOC
		PyScript	a WASM runtime using Pyodide for web embedding
Languages	2025	SPy	a variant of Python designed to be statically compilable with an interpreter and compiler
Libraries	2026	fast-ebook	A Rust-powered Python EPUB2/EPUB3 library for reading, writing, validation and Markdown conversion
		shreg	a Python library for regularizing line segments and closed contours using various algorithms.
	2025	readability-python	an implementation of Mozilla’s readability algorithm for extracting the main content from HTML documents
		trafilatura	another readability variant for extracting text from HTML documents
		automerge-py	a Python library for building collaborative applications with CRDTs
		pythonista-stubs	a collection of type stubs for the Pythonista app, useful for writing scripts that run on iOS devices
		smartfunc	a library for using LLMs via docscrings and introspection and introspection
		aiopandas	a library for using Pandas with asyncio
	2024	unsafe-python	A library to assist writing memory-unsafe code, without any imports
		domscribe	converts HTML to semantic Markdown while preserving structure and meaning
		foc	an intriguing collection of higher-level functions using operators for composability
		BM25S	an ultrafast implementation of BM25 in pure Python
	2023	fastkafka	A Kafka library inspired by fastapi
		reader	A modern RSS/Atom/JSON feed reader library.
	2022	slack-machine	A Slack bot library that uses socket mode and asyncio
		mintotp	a tiny TOTP library
	2021	Sorted Containers	a fast C-backed collections library
		seedir	A utility library to render filesystem tree diagrams
	2020	minotaur	an asynchronous inotify interface
		minibatch	a simple stream processing library
Machine Learning		Tensorflow	Usual staple, largely superseded by PyTorch
Mail	2021	imapautofiler	an IMAP mailbox sorter that I unwittingly replicated (with less features)
	2018	aiosmtpd	an asyncio version of smtpd.py
		Salmon	an SMTP mail server
		slimta	a mail app framework for building MTAs
Messaging	2023	Propan	a declarative Python MQ framework inspired by fastapi
Music	2025	music21	a library for computer-aided musicology
	2023	musicpy	A domain-specific language for writing music
	2020	pippi	an audio processing/music library
		pymidi	a library for building MIDI over IP/RTP applications (compatible with Apple specs)
Networking	2023	p2pd	an async networking library with P2P and UDP support
	2019	opendrop	a partial implementation of AirDrop
	2018	asphalt	An asyncio framework for network oriented applications, with a considerable number of modules
		PyRendezvous	neat little Bonjour module I use a lot
		telnetscript	a simple module to do scripted telnet sessions.
		IPy	an IP address manipulation library.
		pyvnc	A ctypes interface to the VNC libraries
		ircutils	A relatively modern async IRC framework
		Eventlet	Amazing event-oriented framework
		ftputil	a high-level interface to the ftplib module
		Python smtplib progress indication	Might come in useful some day.
		gunicorn	A WSGI server that supports a number of different worker daemons and is highly customizable.
		dpkt	packet creation and parsers
		Pcapy	a packet manipulation library
		uwsgi	A C application container that speaks WSGI and is seriously good.
		PuSSH	SSH wrapper
		RPyC	an awesome RPC library
		SleekXMPP	A more modern XMPP library
		Tftpy	a pure Python TFTP library, useful for implementing UDP file transfer testbeds.
		ThriftPy	A pure Python implementation of Apache Thrift
		pyxmpp2	another one, probably more interesting.
		pyrobuf	a Cython implementation of Google’s protobuf library
		pyapns	An Apple Push Notification Service provider based on Twisted.
OCR	2025	olmocr	A toolkit for training language models to work with PDF documents in the wild.
	2024	surya	OCR library supporting 90+ languages
PDF	2025	plutoprint	another PDF generation library
	2024	marker	a PDF to markdown converter optimized for books and scientific papers, using surya
	2023	peepdf	a Python tool to explore PDF files in order to find out if the file can be harmful or not.
	2021	borb	a library for creating and manipulating PDF files
	2020	camelot	a library to extract tabular data from PDFs
		Kiva	a Display PDF library
		PyPdf	a PDF toolkit
		WeasyPrint	Alternatives to PrinceXML for generating formated PDF documentation.
		xhtml2pdf
Packaging	2026	go-to-wheel	build Python wheels that bundle cross-compiled Go CLI binaries
	2021	PyOxidizer	a better way to distribute Python bundled apps than pyinstaller
		shiv	builds self-contained applications for easy deployment
	2019	Poetry	a dependency management and packaging tool
Presentations		pydown	An HTML presentation generator
Reference	2023	python-cheatsheet	a modern reference, useful for kids
Reporting		Relatorio	A very neat reporting library with multiple output formats
		ReportLab Toolkit	a pure Python PDF library that includes a presentation tool.
Resources	2024	awesome-micropython	another curated list of MicroPython resources
		awesome-micropython	a curated list of MicroPython resources
	2023	python-package-template	a template project for building packages
Robotics	2026	Cozmo Direct Control	PyCozmo-powered GUI with AI chat, keyboard/mouse driving, visual node lab, MediaPipe face tracking, and procedural speech/animation pipelines for commanding Cozmo over WiFi without the official app.
		Cozmo Explorer Tool	Flask-powered GUI that combines Cozmo’s camera feed, keyboard remote controls, event monitor, and animation explorer for prototyping behaviors without the stock app.
		Cozmo Python SDK	Official Anki SDK for the Cozmo robot, with the cozmo module, sample scripts, an event monitor, simulation support, and documentation at cozmosdk.anki.com/docs for wiring your own behaviors over Wi‑Fi.
		PyCozmo	Pure-Python alternative SDK and app that speaks Cozmo’s UDP protocol directly, bundles tools for dumps/replay/animation updates, and exposes docs/examples for firmware, OTA, and Wi-Fi based control.
		kabuki	A declarative control library for MicroPython
Runtimes	2022	pikascript	an embedded Python runtime for the STM32 and other tiny MCUs
	2021	Pyjion	Pyjion, a JIT extension for CPython that compiles your Python code into native CIL and executes it using the .NET 5 CLR.
	2020	Pycopy	a fork of MicroPython
		Nuitka	An interesting batch compiler.
		Pyjamas	Some interesting twists on using Python on the way to JavaScript.
		Brython	a fairly complete in-browser runtime
		Skulpt	Some interesting twists on using Python on the way to JavaScript.
		tinypy	Python in 64K of code.
		Js2Py	A JavaScript interpreter written in pure Python
		Hope	A specialized JIT compiler
Scraping	2020	InvoiceNet	a neural network for extracting invoice information from PDFs
		Mechanize	a programmatic web browser for screen scraping.
		subliminal	A library for looking up movie subtitles in various languages.
		pholcidae	A web crawler library.
		urlwatch	A flexible page modification monitor
Site Generators	2023	django-distill	Minimal configuration static site generator for Django
	2020	MiniConf	a lovely site generator for managing conferences
	2019	portray	a static site generator for Python project documenntation
TUI	2026	rovr	a post-modern terminal file manager built in Python with Textual, offering themed navigation, configurable layouts, and modern packaging via uv/pipx.
	2023	trogon	a genius way to automatically generate a TUI for click-based applications
		pyTermTk	an impressive text UI toolkit
	2021	textual	Text user interface widgets and fields
Task management		doit	a task runner that can replace make for many use cases
Tools	2026	HeloWrite	a distraction-free terminal writing environment built with Python
	2025	posting	an amazing terminal-based Postman replacement
	2024	hancho	a simple, pleasant build system
		berylliumOS	a Python-based shell for CircuitPython devices
	2023	ssh-crypt	a clever way to manage secrets on remote servers
		frogmouth	a TUI Markdown browser
		pypipe	a Python command-line tool for pipeline processing that can export pipelines as standalone scripts
		marcel	a shell that can pipe structured data (like PowerShell, but done right)
		flameshow	a terminal flamegraph viewer
		termgraph	simple terminal charting
		reloadium	advanced hot reloading and profiling
	2022	reloading	a decorator for hot reloading code
		Doctool	a tool to manipulate .docx files
		honcho	a process supervisor that uses Procfiles and can be used for multi-process Docker containers
Tutorials	2021	ugit	a step-by-step git implementation
Unicode		Unidecode	Does character transliterations.
Video	2021	webcam-filters	a set of GStream filters for doing live webcam background segmentation and blurring
Visual Programming	2024	nodezator	a graphical node workflow editor based on PyGame
	2022	PyFlow	a another (confusingly, identically named) visual programming environment
		Ryven	a flow-based programming environment with a Qt front-end
		PyFlow	a desktop-based visual programming environment
Web	2025	justhtml	a pure Python HTML5 parser
	2022	newscatcher	a cute scraper database/fetcher combo
Web Frameworks	2026	micropidash	An asynchronous MicroPython web dashboard library for Raspberry Pi Pico 2 W and ESP32, built around non-blocking updates, dark mode, and simple hardware integration via uasyncio.
	2025	fastapi-voyager	a FastAPI extension for visualizing endpoints
		air	a FastAPI-backed HTML framework
	2023	socketify.py	another libuv wrapper
		litestar	another high-performance ASGI API framework with rigorous typing
		robyn	an async Python framework with a Rust connection handler
		sse-starlette	Server-Sent Events for Starlette and FastAPI
		ucall	a JSON-RPC library that claims to be 100x faster than FastAPI
	2022	pynecone	a full-stack Python web framework that automatically renders Next.js components
	2021	FastAPI	decorator-based, runs under uvicorn
	2020	blacksheep	an ASGI web framework that uses decorators
		starlette	an ASGI web framework that runs under uvicorn
	2019	appkernel	a microservices framework
	2018	zatt	An asyncio implementation of the Raft consensus algorithm (some of the forks add significant enhancements)
		Bottle	Tiny, flexible, awesome. My favorite since 2011.
		Draco	Old and busted, to various extents.
		Falcon	A Cythonizable framework with little magic and good performance
		Karrigell	Old and busted, to various extents.
		pecan	Based on object dispatching
		eve	Another RESTful foundation framework
		wheezy.web	A high-performance framework that seems to get along well with PyPy
		Snakelets	A minimalistic app server, my old web platform of choice.
		Twisted	Old and busted, to various extents.
		medusa
		CherryPy
		Tornado	non-blocking, which is pretty interesting.
		Zope	Old and busted, to various extents.
		sandman	A simple RESTful wrapper
		Vibora	An asyncio framework that seems to beat Sanic in static performance
		Moya	a new(ish), template-centric web framework with some interesting twists
Wikis	2024	silicon	another Markdown-focused wiki
		otterwiki	a nice git-backed wiki
Writing	2023	proselint	a linter for prose

Techniques

• daemon.py, an example daemon script.
• Pydoc built-in Web help, anytime, anywhere
• How to Write a Spelling Corrector - an interesting technique that can come in handy to fix/suggest search terms, etc.
• Python Webcam Color Track
• Python webcam fun - motion detection

Create a file named .pydistutils.cfg in your home directory with the following contents and set $PATH accordingly:

[install]
install_lib = ~/Library/Python/$py_version_short/site-packages
install_scripts = ~/Library/Python/$py_version_short/bin
install_data = ~/Library/Python/$py_version/share

This will install packages to your Library folder rather than to the system directory, saving you the trouble to use sudo or risking messing with the system installation. Of course virtualenv does a better job for keeping track of project-specific dependencies, but this is great for common/complex dependencies and is sure to survive operating system upgrades.

And then you can use easy_install or pip install --user with impunity, although you might need to do something like:

ARCHFLAGS=-Wno-error=unused-command-line-argument-hard-error-in-future easy_install pandas

…for getting around some clang oddities.

#!/bin/sh
python -c '__import__("SimpleHTTPServer").test()'

• Estimating the Airspeed of an Unladen Swallow

So I thought it would be a good idea to have a policy in place to make sure everyone is on the same page:

1. I don’t do paid reviews. I realize there is a fine line between getting “free” stuff to review and being paid to review it, but I’m not interested in crossing it–this site does not generate any form of income for me, and I’d like to keep it that way.
2. I only review things I have a personal interest in (i.e., things that I would ordinarily have an actual use for, learn from or would otherwise consider buying) or that would be interesting for the people I occasionally provide consulting services to.
3. I don’t do scripted reviews (i.e., there is no content placement, I write about the features I find important, etc.)
4. There are no editorial tweaks–vendors get to read my reviews at the same time as the general public.
5. I don’t participate in vendor affiliate programs–I’m OK with handing out discount codes or linking to the vendor’s site with a utm referral tag (so they can check attribution), but other than my usual (automatic) Amazon/AliExpress linking (which I started using for books decades ago and now do for electronics components), there are no other affiliate links on this site to ensure I don’t get any direct revenue from the reviews.
6. When applicable, scripts used for performance measurements and benchmarks will be published here or on GitHub.
7. Benchmarking will be focused on the aspects I value (although I will try to use standard tooling where appropriate).
8. I review what’s “in the box”, not what’s promised for future releases or what might be available in a future version.

I’m also open to reviewing books–I’ve done pre-publishing reviews in the past, and I’m always happy to read and review books on topics I’m interested in.

I have also recently started a YouTube channel called @TheTaoOfTech that I am slowly populating with videos that complement the content on this site. I will try to keep the same review policy there, although I might do some sponsored videos in the future (but I will always disclose that).

So if you have something you’d like me to review, please get in touch and we’ll take it from there.

Many people ask me about page views, statistics, Google rankings, etc. This is what I have to say about it:

• This site does not use Google Analytics for privacy reasons, nor any other mainstream analytics or tracking platform. The flip side of that is that it is (incorrectly) down-ranked in just about every single public site ranking.
• It does, however, use Cloudflare Analytics, which is privacy-preserving and a more accurate than most other tracking sites because it automatically filters out bots, referrer spam and other things that contribute to site traffic inflation. However, it can provide some interesting figures (updated for August 2024):
  • Over 2M monthly pageviews (and steadily rising).
  • Over 110K unique human visitors per month, mostly from the US, UK, Germany, and Singapore (if I add in figures from Japan and Australia, I get almost as much traffic from APAC than from the UK, which has always been interesting to me).

You can check this PDF for a sample Cloudflare traffic report.

This audience reach comes down to four main factors:

• My emphasis on consistently solid technical content–which ensures continued reader interest.
• No fake audience engagement on site (I interact with readers directly via e-mail correspondence)
• Posts are automatically broadcast to X/Twitter, Mastodon and a few sites that consume my RSS feed directly.
• I get a lot of traffic from places like Reddit, Hacker News, etc. (especially when I post something with an unusual technical angle).

All of my posts are automatically broadcast to my X/Twitter and Mastodon accounts, and I also post occasional links to my LinkedIn profile.

I am also (slowly) starting to produce YouTube videos. This will be a slow process, as I am not a professional video editor and I have no intention of becoming one. I will, however, try to produce some videos that complement the content on this site, and am curious to explore the medium a bit more (and not just in Youtube).

Links to all my social and video accounts can be found on the site footer.

This is a non-exhaustive list of things I’ve reviewed in the past:

Date	Category	Link	Notes
2026	E-ink Readers	The Xteink X4	Purchased by me
	NAS	YouYeeToo NestDisk	Supplied by YouYeeToo
	SBCs	Orange Pi 6 Plus	Supplied by Orange Pi
2025	Accessories	The Maclock	Purchased by me (AliExpress)
	E-ink Displays	The TRMNL (DIY Everything Edition)	Purchased by me from Seeed Studio
	Networking	Sodola SL902-SWTGW218AS	Purchased by me
		Cudy AX3000 Wi-Fi 6 System	Purchased by me (multiple units)
	SBCs	ArmSoM AI Module 7	Supplied by ArmSoM
		LattePanda Mu	Supplied by DFRobot
		LattePanda IOTA	Supplied by DFRobot (expansion boards included)
2024	Keyboards	Hexgears Immersion A3	Supplied by Hexgears
	Mini-PCs	GMKtec G2
	NAS	CM3588 NVMe NAS Kit	Supplied by FriendlyELEC
	Networking	SL-SWTG124AS	Supplied by Sodola
		SL-SWTGW218AS
	SBCs	Orange Pi 5+	Supplied by Orange Pi
		YouYeeToo R1	Supplied by YouYeeToo
		Banana Pi M7	Supplied by Banana Pi
		Radxa X4	Supplied by Radxa
		XPI-3566-Zero	Supplied by Geniatech
		Banana Pi M5 Pro	Supplied by Banana Pi
2023	3D Printers	Kingroon KP3S Pro V1	two year review
	Apple	Mac Mini M2 Pro
		iPhone 15 Pro, Watch Series 9
	Keyboards	Bluehand
	Mini-PCs	Beelink U59 Pro
	Monitors	LG 28MQ780-B
	PC Builds	ASRock DeskMeet B660
	SBCs	Radxa Zero
2022	Apple	iPad Pro M1
	Keyboards	Avatto Folding Keyboard
		Dierya 63, Adafruit Macropad
		Logitech Combo Touch
	SBCs	Banana Pi M2 Zero
2021	Monitors	LG 34WK95U-W
	Music	Teenage Engineering OP-1
2020		Yamaha Reface DX, AG06
2019	Apple	iPad Mini 5
		Watch Series 5
	Music	Roli Songmaker Kit, Korg Nanokey Studio
2018	Apple	iPhone XS
2017	3D Printers	BQ Prusa i3 Hephestos	Built from kit
	Mini-PCs	Z83ii
2016	PC Builds	Streacom ST-F1CB WS Black Aluminum Case
2013	Phones	HTC One	Test sample
2009	E-ink Readers	The Sony Reader	Purchased by me
2008	Accessories	DisplayLink DVI	Supplied by DisplayLink

]]> https://taoofmac.com/space/ai/agentic/skills?utm_content=atom 2026-02-21T09:00:00+00:00 2026-04-23T09:11:40+00:00 Rui Carmo https://taoofmac.com Reusable skill modules for agentic systems: prompt packs, tool recipes, and structured workflows that you can load into a running agent, adapt for a project, or keep around as references when shaping instruction sets.

These live here so the main Agentic Systems page can focus on frameworks, platforms, and infrastructure.

Field	Category	Date	Link	Notes
Code Agents	Skills	2026	SwiftUI Expert Skill	SwiftUI expert guidance covering modern APIs, state management, performance, and iOS 26+ Liquid Glass patterns
			threejs-skills	Three.js skill files for Claude Code covering core APIs, geometry, materials, lighting, loaders, shaders, postprocessing, and interaction
			Humanizer	Claude Code skill that rewrites AI-sounding text to read more naturally using Wikipedia-based writing anti-patterns
			visual-explainer	an agent skill that turns complex terminal output into styled self-contained HTML pages with interactive Mermaid diagrams
Prompting			baloney-detection-kit	Drop-in prompt/skill that applies a 6-step critical thinking protocol (Sagan, Karpathy, Lifton, Popper) to counter LLM agreeableness bias

]]> https://taoofmac.com/space/ai/llm?utm_content=atom 2025-05-01T17:30:00+00:00 2026-04-21T08:46:30+00:00 Rui Carmo https://taoofmac.com This page is a collection of notes and links related to large language models (LLMs), their applications, and the underlying technology. It serves as a reference for understanding the current state of LLMs, their capabilities, and their limitations, and is the result my cleaning up the main AI page and splitting it into more manageable sections. It is not exhaustive, but it should provide a good starting point for anyone interested in the topic.

Interesting models i’ve come across, off the mainstream beaten path:

Field	Category	Date	Link	Notes
Large Language Models	Function Calling	2024	functionary	can interpret and execute functions/plugins
			Octopus-v2	a model designed for both function calling and on-device inference
Multi-modal Models	Models	2023	ml-ferret	a multi-modal model from Apple
Small Language Models		2026	z80ai	2-bit quantized micro language model that runs on Z80/CP/M (.COM), trained in Python and exported
		2024	TinyLlama	pretraining of a 1.1B Llama model on 3 trillion tokens.

Tools

Miscellaneous tools and applications that use LLMs, or are related to them in some way:

Field	Category	Date	Link	Notes
Assistants	Code Assistants	2025	aider	a tool that enables pair programming with LLMs to edit code in local git repositories.
			tabby	a self-hosted AI coding assistant
			ollama-copilot	Proxy that allows you to use ollama as a copilot like Github copilot
		2024	gpt-pilot	a prototype development tool that leverages GPT
			llm-vscode	a VSCode extension that uses llm-ls
			emacs-copilot	an Emacs extension for using a local LLM
			privy	An open-source alternative to GitHub copilot that runs locally.
		2023	localpilot	a MITM proxy that lets you use the GitHub Copilot extension with other LLMs
	Computer Use	2026	pi-computer-use	Adds screenshot, mouse and keyboard tools to Pi on macOS via an extension, skill and native helper.
	Desktop Assistants	2023	macOSpilot-ai-assistant	An Electron app for macOS
	Personal Assistants	2026	Parlor	an on-device real-time multimodal AI app for local voice and vision conversations, powered by Gemma 4 E2B and Kokoro.
		2023	khoj	an intriguing personal assistant based on local data
	Terminal Assistant	2025	tmuxai	a terminal assistant that leverages tmux
Development	App Development Platform	2024	dify	an open-source LLM app development platform with a node-based UX
	Code Assistant	2025	opencode	a TUI-based code assistant written in Go.
	Code Generation		spec-kit	a toolkit for spec-driven development
	Flow-based	2023	langflow	a node-based GUI for quick iteration of langchain flows
	JavaScript Framework	2024	genaiscript	a JavaScript environment for prompt development and structured data extraction for LLMs.
	LLM Programming		GPTScript	Natural Language Programming against multiple LLMs
	Language Server		llm-ls	a local language server that leverages LLMs
	Libraries	2025	smartfunc	turn Python functions into LLM-powered endpoints using the OpenAI SDK
	NLP Toolkit	2024	WordLlama	a lightweight NLP toolkit for tasks like fuzzy-deduplication, similarity, and ranking
	Prompt Compression		LLMLingua	a tool for compressing prompts with minimal loss of information
	Workflow Management		burr	a tool for creating and managing LLM workflows
Evaluation	Evaluation Platform	2025	opik	an open-source platform for evaluating, testing, and monitoring LLM applications.
	Model Evaluation	2023	pykoi	a unified interface for data and feedback collection, including model comparisons
			PromptTools	self-hostable toools for evaluating LLMs, vector databases, and prompts
	Prompt Evaluation		ChainForge	a visual programming environment for benchmarking prompts across multiple LLMs
			promptfoo	A tool for testing and evaluating LLM prompt quality.
Infrastructure	API Compatibility		LocalAI	A local, drop-in replacement for the OpenAI API
	API Management		BricksLLM	an OpenAI gateway in Go to create API keys with rate limits, cost limits and TTLs
	Deployment	2026	Turnstone	a multi-node AI orchestration platform for deploying tool-using agents across server clusters, with CLI/browser interfaces, governance, and MCP support.
		2023	dalai	An automated installer for LLaMA
	Distributed Inference	2024	exo	an intriguing P2P clustering solution for running models across several machines
	Edge Inference		nitro	a self-hosted inference engine for edge computing with an OpenAI API
		2023	TinyChatEngine	A local (edge) inference engine in C++ without any dependencies
	GPU Optimization	2024	amd_inference	a tool that enables inference on AMD GPUs
	Hardware Optimization		ipex-llm	a PyTorch extension for Intel hardware
	Inference Engines	2026	Flash-MoE	A pure C/Objective-C+Metal inference engine that runs the 397B MoE model on Apple Silicon laptops using SSD streaming, 2-bit quantization, and custom GPU kernels.
			ik_llama.cpp	A high-performance llama.cpp fork with improved CPU and hybrid GPU/CPU inference plus modern quantization and DeepSeek/BitNet-focused updates.
		2023	a1gpt	A C++ implementation of a GPT-2 inference engine
			llama.cpp	A C++ port of Facebook’s LLaMA model. Still requires roughly 240GB of (unoptimized) weights, but can run on a 64GB Mac.
			minillm	A GPU-focused Python wrapper for LLaMa
			llama-rs	A Rust port of llama.cpp
			wyGPT	another C++ local inference tool
	Model Runner	2025	ramalama	an alternative to Ollama for locally running models
	Model Serving	2024	lorax	a framework that allows users to serve thousands of fine-tuned models on a single GPU
	Performance Optimization		GPTFast	a set of acceleration techniques
	Privacy	2026	rehydra-sdk	TypeScript SDK that detects, replaces, encrypts, and rehydrates PII in LLM prompts, coding agents, and browser workflows.
	Voice Integration		voxtral-tts.c	pure C implementation of Voxtral-4B-TTS for lightweight, dependency-free text-to-speech inference.
Integration	Apple Notes	2024	notesollama	a plugin for Apple Notes that uses the Accessibility APIs
	IRC Bot		ollama-bot	a rudimentary IRC bot that communicates with a local instance of ollama
	Slack Bot		geppetto	a bot for integrating ChatGPT and DALL-E into Slack
	Voice Integration		pico-cookbook	Recipes for on-device voice AI and local LLM
Interfaces	CLI	2023	chatblade	a CLI wrapper for ChatGPT
	CLI Markdown	2024	mark	CLI to interact with LLMs using markdown and images
	Terminal Interface		oterm	a terminal-based interface for LLMs
	Text Generation UI		koboldcpp	an easy-to-use AI text-generation software for GGML and GGUF models based on llama.cpp
	Web Interface		open-webui	a web-based interface for LLMs
		2023	chatbot-ui	a more or less sensibly designed self-hosted ChatGPT UI
			Serve	A containerized solution for using local LLMs via web chat
Knowledge Systems	Data Processing	2024	nlm-ingestor	a set of parsers for common file formats
	Database RAG		korvus	a search SDK that unifies the entire RAG pipeline in a single database query
	Document Processing	2025	yek	a tool for importing and chunking text files for RAG
	Knowledge Graph RAG	2024	GraphRAG	a data pipeline designed to pre-process knowledge graphs and perform RAG on them
	Memory	2026	MemPalace	a local AI memory system that stores full conversation history in a structured searchable corpus with MCP tools and compressed context export.
	Note-Taking RAG	2024	reor	a note taking tool that performs RAG using a local LLM
	Personal Data	2026	msgvault	Offline email archive with local Gmail/IMAP sync, full-text search, DuckDB/Parquet analytics, and an MCP server for AI assistant query access.
	RAG	2023	embedchain	another framework to create bots from existing datasets
			content-chatbot	A way to quickly create custom embeddings off a web site
	RAG Framework	2024	R2R	a framework for or rapid development and deployment of production-ready RAG systems with SQLite support
			llmware	a framework for developing LLM-based applications including Retrieval Augmented Generation
	Research Assistant		storm	a tool that researches a topic and generates a full-length report with citations
	Search Engine		Perplexica	a Perplexity AI search engine clone
	Search Tools		LLocalSearch	a local tool for searching using LLMs
Media Generation	Audio Stories		fably	A device that tells bedtime stories to kids, using chunked TTS
	Data Visualization		lida	automatic generation of visualizations and infographics
	Image Generation		local-image-gen	A GPTScript tool to generate images
Model Management	Format Manipulation		gguf-tools	a set of tools for manipulating GGUF format files
	Layer Visualization		NeuralFlow	a Python script for plotting the intermediate layer outputs of Mistral 7B
	Low-Level Training		llm.c	LLM training in simple, raw C/CUDA
	Model Optimization		hqq	an implementation of Half-Quadratic Quantization (HQQ)
		2023	GPTQ-for-LLaMa	a way to quantize the LLaMA weights to 4-bit precision
	Training		simple-llama-finetuner	A way to do LoRA adaptation of LLaMa
			alpaca-lora	Another way to do LoRA adaptation of LLaMa

Other Resources

Other resources related to LLMs, including articles, papers, and websites:

Field	Category	Date	Link	Notes
Large Language Models	Algorithms	2024	word-embedding	an implementation of word2vec skip-gram for word embedding.
	Applications	2023	Chie	A cross-platform dekstop application with chat history and extension support
	Copilots		Obsidian Copilot	an interesting take on how to use semantic search and OpenSearch’s BM25 implementation
	Demos	2024	WhisperFusion	an ensemble setup with WhisperSpeech, WhisperLive and Phi
	Frameworks	2023	litellm	a simple, lightweight LLM wrapper
			AutoChain	Yet another alternative to langchain
			Tanuki	yet another LLM framework using decorators for data validation
			griptape	a langchain alternative with slighly better internal coding standards
			guidance	Control modern language models more effectively and efficiently than traditional prompting or chaining.
			langchain	a composable approach for building LLM applications
			llama_index	a data framework for LLM applications
			txtai	has spinoffs for chat, workflows for medical/scientific papers, semantic search for developers and semantic search for headlines and story text
			llmflows	Yet another alternative to langchain, but with an interesting approach at defining workflows
			fabric	a componentized approach to building LLM pipelines
	Front-Ends	2024	jan	an open-source ChatGPT alternative that runs 100% offline (uses nitro)
		2023	SecureAI-Tools	a self-hosted local inference front-end for chatting with document collections
			gpt4all	another self-hosted local inference front-end
	Jupyter		LLMBook	A VS Code notebook interface for LLMs
			jupytee	a Jupyter plugin that can handle code generation and image generation, but not switching models (GPT-4)
			genai	a Jupyter plugin that can handle code generation and fixes based on tracebacks
			ipython-gpt	a Jupyter plugin that can handle multiple models
	Libraries	2025	mlx-lm	a Python package for serving large language models on Apple silicon.
			harmony	a library that provides a response format for conversation structures and reasoning output in OpenAI models.
		2024	chonkie	a lightweight library for efficient text chunking in RAG applications.
			databonsai	a Python library that uses LLMs to perform data cleaning
			DataDreamer	library for prompting, synthetic data generation, and training workflows
			radients	a vactorization library that can handle more than just text
			magentic	decorators to create functions that return structured output from an LLM.
		2023	guardrails	a package for validating and correcting the outputs of large language models
			MemGPT	a memory management/summarization technique for unbounded context
			instructor	a clever library that simplifies invoking OpenAI function calls
			simpleaichat	A simple wrapper for the ChatGPT AI
	Reference	2024	sqlite-hybrid-search	an example of how to do hyrid (vector and FTS) search with SQLite for RAG
		2023	Native JSON Output from GPT-4	tips on how to use OpenAI JSON and function calling
			Using LLaMA with M1 Mac	Manual instructions for Apple Silicon
			Prompt Engineering Guide	a set of lecture notes and detailed examples of prompting techniques
			awesome-decentralized-llm	a collection of LLM resources that operate independently
			GPT Prompt Archive	A set of sample base prompts for various LLMs
			promptbase	Another set of prompting techniques and detailed examples
		2022	awesome-chatgpt-prompts	might be a short-lived resource, but an interesting one
	Samples	2025	smolGPT	A minimal PyTorch implementation for training your own small LLM
		2024	SimpleTinyLlama	a simple PyTorch-based implementation
		2023	David Attenborough narrates your life	A pretty hilarious image-to-description example
			LibreChat	A self-hosted ChatGPT alternative
			sharepoint-indexing-azure-cognitive-search	provides an example of how to use Graph navigation and Cognitive Search indexing
			gpt4all	open-source LLM chatbots
			Demystifying Advanced RAG Pipelines	An LLM-powered advanced RAG pipeline built from scratch
			Wanderlust OpenAI example using Solara	A simple interactive web shell with some nice features
			GPT in 60 Lines of NumPy	a tutorial on how to build a GPT model from scratch
			Bash One-Liners for LLMs	a collection of one-liners for various LLMs
	Tools	2025	Anemll	porting of LLMs to tensor processors, starting with the Apple Neural Engine (ANE)
	Vector Databases	2023	chroma	an embedding database
			vectordb	A simple vector database that can run in-process
			marqo	A vector database that performs vector generation internally
			USearch	A Single-File Vector Search Engine
	Workflows		danswer	a pretty complete GPT/search integration solution with GitHub, Slack and Confluence/JIRA connectors
Samples	Large Language Models	2025	tiny-llm	A tutorial on LLM serving using MLX

]]> https://taoofmac.com/space/links/2026/04/21/0730?utm_content=atom 2026-04-21T07:30:00+00:00 2026-04-21T11:52:40+00:00 Rui Carmo https://taoofmac.com

So this is happening. Cook moves to executive chairman, Ternus takes… his turn at the helm.

Cook turned Apple into the most efficient manufacturing and logistics company on the planet–something I’ve been reading about in detail via Patrick McGee’s Apple in China, which makes a painfully convincing case for just how deep that dependency runs. He also built a massive services and content business on top of it.

But despite all of that, the soul of the company has felt increasingly bland, and the accumulating faux pas in software quality–culminating in the Liquid Glass debacle and the general state of macOS and iPadOS–have tested even the most faithful.

Ternus is a hardware guy, and very likely deeply involved in the MacBook Neo. My hope is that he has a better feel for what good product actually looks like, and can drive the kind of change that has been overdue for a while now.

I’d start with fixing macOS and iPadOS, preferably in a way that matches what people actually expect from their devices rather than what a design committee thinks looks modern.

Whether that happens is another question entirely. But at least the new CEO isn’t from the services side.

(It would also be nice if Apple realized that remote work is a thing, but I think that boat has sailed)

Update: Hacker News broadly agrees with my hopes, and many takes are worth reading (with the usual HN sanity disclaimer)

Reusable instruction packs, workflow recipes, and prompt modules live in Agentic Skills.

OpenClaw-specific projects and lightweight variants live in OpenClaw Ecosystem.

Pi.dev is the home of the Pi coding agent and its ecosystem of extensions, adapters, and clients. See the Pi.dev Ecosystem page for the curated project list.

Field	Category	Date	Link	Notes
Agent Frameworks	Frameworks	2026	liteagent	minimal Python async agent loop ported from pi-mono, exposing streaming, steering, follow-ups, and sequential tool execution on top of LiteLLM.
			HVE Core	enterprise prompt engineering framework for GitHub Copilot with constraint-based workflows, validated artifacts, and RPI methodology
		2025	FlashLearn	a simple interface for incorporating Agent LLMs
			agno	a lightweight library for building Multimodal Agents
			crewAI	framework for orchestrating role-playing, autonomous AI agents (multi-agent automation)
			AgentKit	build multi-agent networks in TypeScript with deterministic routing and rich tooling via MCP
			Agent Framework	Microsoft open-source agentic framework
	Samples	2026	Cloudflare Agents Starter	starter template for building AI chat agents on Cloudflare Workers with tools, scheduling, and real-time streaming
	Tools		Agent Lightning	training and optimization toolkit for AI agents across frameworks
Agent Knowledge	Frameworks	2025	firm	an ontology framework for structuring agent knowledge about businesses
Agent Memory	Tools	2026	beads	a distributed, git-backed issue tracker and memory system experiment for AI agents
			claude-mem	a persistent memory compression system for Claude Code with search tools
		2025	AgenticMemory	a tool for creating and managing memory in LLMs
			letta	a tool for creating and managing memory-backed agents
Agent Platforms	Platforms	2026	Rivet	Actor-based agent platform that bundles state, storage, workflows, scheduling, and WebSockets into self-hostable Rust binaries or managed cloud runtimes, letting each agent run as a persistent, stateful primitive with built-in persistence and tooling.
		2025	HelixML	an interesting enterprise-grade agentic platform with tools for integration and observability
			Sim	open-source platform to build and deploy AI agent workflows
	Tools	2026	OpenYak	open-source desktop AI assistant that runs locally with MCP support, for file management, data analysis, and office automation without cloud uploads.
Agent Systems	Frameworks		Squad	AI agent teams for any project, built in TypeScript.
		2025	pixelagent	an agent engineering blueprint
		2024	pipecat	yet another LLM agent framework
	Samples		TinyTroupe	a multiagent persona simulation
	Tools	2026	CallMe	minimal Claude Code plugin that calls your phone/watch via Telnyx or Twilio (plus OpenAI/ngrok) when a task stalls or needs your input
			baudbot	always-on, Slack-connected multi-agent dev assistant that runs tasks end-to-end on Linux
			OneCLI	credential vault and HTTP gateway for AI agents that stores secrets once, injects them transparently into outbound API calls, and keeps raw keys out of agent context.
			Pinchtab	HTTP browser-control bridge that lets any agent drive Chrome via a compact, stealthy API, with snapshot/text modes, token-efficient read flows, and persistent sessions
			rtk	Rust Token Killer CLI proxy that compresses command output before it reaches your Claude Code session, saving ~60‑90% of LLM tokens on git/status/test workflows with ultra-compact summaries and hook-first install.
			gogcli	CLI for Google APIs (Gmail, Calendar, Drive, Docs, Sheets, Chat, etc.) with OAuth credential management, headless flows, and JSON/TSV/compact output modes tailored for agent interactions and automation.
			Argus	VS Code extension that discovers Claude Code sessions, visualizes costs/performance, and surfaces rule-based findings to debug and tune agentic workflows without leaving your editor.
		2025	R2R	production-ready AI retrieval system for agentic RAG via a REST API
		2024	plandex	yet another long-running agent tool for complex coding tasks
		2023	Auto-GPT	an attempt to provide ChatGPT with a degree of autonomy
Code Agents	Samples	2026	TinyProgrammer	A Raspberry Pi device that continuously writes, runs, watches and reflects on small Python programs using an LLM
		2025	amplifier	a technology demonstrater for agentic coding
		2024	devlooper	a program synthesis agent that autonomously fixes its output by running tests
	Tools	2026	kimi-cli	CLI tool for interacting with the Kimi AI assistant
			Godogen	Claude Code pipeline (using two cooperative skills) that converts plain-language game descriptions into complete Godot 4 projects with generated art, code, and visual QA via screenshot analysis.
			ATLAS	A local coding assistant and test-time inference pipeline that wraps frozen Qwen models in self-verified repair and benchmarking infrastructure
			axe	lightweight CLI for defining focused LLM agents in TOML and running them from the terminal, pipes, cron jobs, CI, or git hooks with skills, memory, and sub-agent delegation.
			Sidecar	terminal UI for agentic development workflows with git, task, workspace, and conversation management
			tui-use	A PTY automation tool that lets AI agents drive REPLs, debuggers and full-screen TUI apps from the terminal
			Codex CLI	OpenAI’s lightweight agentic coding CLI for the terminal
		2025	Toad	a unified terminal UI to run coding agents via ACP
			goose	a local AI agent focused on development tasks
			quibbler	a critic for coding agents that can also work as an MCP
			mistral-vibe	Mistral’s agentic coding CLI
Developer Resources	References	2026	Context7	a curated database of context for several development stacks
Personal Assistants	Tools		nanobot	an ultra-lightweight personal AI assistant with multi-provider support
			Sitegeist	browser-sidebar AI assistant for Chrome/Edge that collaborates on web automation, extraction, navigation, form filling, and research using your own model/provider credentials with local-first data handling.
Research Agents	Samples	2025	STORM	LLM-powered knowledge curation system that researches a topic and generates a full-length report with citations
		2023	gpt-researcher	a simple agent that does online research on any given topic
	Tools	2026	autoresearch	Autonomous research harness that lets Claude/Codex agents edit train.py, run 5‑minute training passes, and iterate on models via human-written program.md instructions, logging each experiment the next morning.
Sandboxing Environments			amla-sandbox	A WASM-based sandbox with capability enforcement for running agent-generated code safely. Provides isolation without Docker and reduces tool-call overhead.
			Agent Safehouse	macOS sandbox-exec wrapper that builds deny-first policies for Claude/Codex/AMP workflows so coding agents only touch the files and integrations they need.
			yolobox	a containerized sandbox for running AI coding agents safely
			nah	context-aware safety guard for Claude Code that classifies tool calls, blocks or confirms dangerous actions, inspects reads/writes for secrets and exfiltration, and can optionally consult an LLM for ambiguous cases.
			Capsule	a secure runtime for orchestrating agent tasks in isolated WASM sandboxes
			shuru	local-first microVM sandbox for AI agents on macOS using Apple’s Virtualization.framework
			Cua	A sandboxing toolkit and agentic platform for running agents in isolated environments. Covers Docker, QEMU, and Apple Virtualization for benchmarking, safe code execution, and UI automation.

]]> https://taoofmac.com/space/ai/mcp?utm_content=atom 2025-05-01T17:30:00+00:00 2026-04-20T18:09:38+00:00 Rui Carmo https://taoofmac.com This page is a collection of notes and links related to the Model Context Protocol (MCP), a proposed standard for extending managing context in large language models (LLMs) via external tools.

Field	Category	Date	Link	Notes
Audio Processing	Integration	2026	SAS Audio Processor	Exposes 25 DeclarAgent-based MCP tools for trimming, normalizing, compressing, EQ/reverb/pitch-shift/time-stretch, analysis, and MIDI extraction; accepts WAV inputs and emits structured JSON for Claude/MCP clients.
Automation		2025	macos-automator-mcp	a macOS Node server that exposes AppleScript and JXA to MCP clients
	Server Implementation	2026	playwrightess-mcp	an experimental MCP server that exposes a persistent Playwright JavaScript eval environment via a single playwright_eval tool
		2025	paws-on-mcp	yet another Python MCP server
Context Management	Integration	2026	claude-context-mode	an MCP server that adds context mode support and tooling for Claude workflows
Document Processing		2025	markitdown	a document-to-Markdown conversion tool/library useful for ingestion pipelines
Documentation	Server Implementation		toMCP	turns any website or docs into an MCP server by extracting clean Markdown
Extension Architecture			hyper-mcp	a powerful MCP server that leverages WebAssembly plugins
Graphics			blender-mcp	a server that enables real-time interaction between Large Language Models and Blender using JSON over TCP.
			openscad-mcp	an MCP server for OpenSCAD that enables design automation and AI-assisted 3D modeling
Integration			annas-mcp	an MCP server (and CLI) for searching and downloading documents from Anna’s Archive
			Fabric-Analytics-MCP	an MCP server that integrates with Microsoft Fabric for analytics tasks
LLM Interoperability	Integration		mcp-llm-bridge	a bridge that connects MCP servers to OpenAI-compatible language models through a standardized interface.
Language Bindings	Frameworks	2026	FastMCP	the fast, Pythonic way to build MCP servers and clients.
	Server Implementation		swift-fast-mcp	a Swift builder API for quickly assembling MCP servers
		2025	mcp-golang	a Go-based MCP server implementation
	Tooling	2026	MCPorter	a TypeScript runtime/CLI that discovers MCP servers, calls them directly, and generates typed clients or one-off CLIs
Multi-agent Systems	Frameworks	2025	agent-kit	an MCP framework for building multi-agent networks
RAG	Server Implementation	2026	qmd	local markdown-first knowledge indexing/search engine with hybrid BM25/vector/reranking and MCP transport for Claude-compatible clients, plus context-aware retrieval via CLI.
		2025	haiku.rag	an agentic RAG toolkit that can run as an MCP server (document indexing, search, QA)
Reverse Engineering		2026	ghidra-mcp	an MCP server that integrates with Ghidra for reverse engineering workflows
Tooling	Integration		conformance	A conformance test framework and GitHub Action for validating MCP clients and servers against the specification
			Forgemax	a code-mode MCP gateway that collapses many tool schemas into two tools (search and execute) via a sandboxed V8 JavaScript runner
Visual Programming	Server Implementation	2025	node-red-mcp	a Node-RED MCP server with HomeAssistant understanding
WebMCP	Demo	2026	music-composer-webmcp	a WebMCP demo that lets agents compose music in a browser-based sequencer via WebMCP tools

]]>