This was not on my bingo card for 2026.

The Wii is, indeed, a PowerPC machine, but getting Mac OS X to boot on it still requires a fair amount of kernel hacking—never mind the real life altitude it was actually written at, although it does confirm that flight time can, indeed, be used productively.

In order to run NodeJS sanely on macOS and WSL, I’ve taken to setting up an unprivileged package install folder like so:

mkdir "${HOME}/.npm-packages"

# Add a new dotfile, without expanding $HOME
cat << 'EOF' >> ~/.npmrc
prefix=${HOME}/.npm-packages
EOF

# Add the following five lines to .bashrc, without expanding variables:

cat << 'EOF' >> ~/.bashrc 
NPM_PACKAGES="${HOME}/.npm-packages"
PATH="$NPM_PACKAGES/bin:$PATH"
# Unset manpath so we can inherit from /etc/manpath via the `manpath` command
unset MANPATH # delete if you already modified MANPATH elsewhere in your config
export MANPATH="$NPM_PACKAGES/share/man:$(manpath)"
EOF

I’ve taken to looking for alternative ways to develop in JavaScript that don’t require me to put up with its syntax and overall insanity. Here’s a few I like (mostly compilers, since that’s what makes the most sense for me):

Category	Date	Link	Notes
Compilers	2021	Imba	another Elm-like language that compiles ro Javascript
	2019	Reason	an OCaml-like language and compiler
	2018	Elm	A functional language that compiles to JavaScript
		wisp	A homoiconic LISP dialect with Clojure syntax and macros
		pythonium	A Python3 to JavaScript translator
	2017	Opal	A Ruby transpiler

Resources

Most of these are library-independent. Check my jQuery page for more, since there’s an entire sub-culture that believes it to be JavaScript programming in and by its own…

Category	Date	Link	Notes
AI	2019	nlp.js	a natural language processing library for bots
Animation	2018	Pts	A Processing-like library
	2023	anime	an impressive lightweight JavaScript animation library
	2025	vfx-js	a library for creating visual effects
		defuddle	an implementation of the readability algorithm
Audio	2020	Wave.js	a themable audio visualizer
Automation	2018	n8n	a Zapier alternative that is Open Core, but requires licensing for most uses
	2023	activepieces	another self-hostable Zapier alternative (MIT Licensed)
CAD	2025	BREP	a feature-based modeling playground with BREP-style workflows on triangle meshes
Charting	2010	Highcharts	A very comprehensive charting library
	2013	GoJS	A commercial charting and diagramming library
	2018	F2	an elegant charting library for mobile
	2023	Graphic Walker	An embeddable Tableau-like dashboard UI, also available for Jupyter
		tremor	a React library for creating semi-interactive dashboards.
		Observable Plot	A nice D3 wrapper that makes a lot of it much more intuitive
	2025	simplegantt	a simple Gantt chart library for restricted environments
Data Structures	2017	seamless-immutable	Immutable data structures a la Mori
	2018	knockout.sync.js	A nice nockout extension that allows you to sync data among clients and backends
	2022	automerge	a library of data structures for building collaborative applications in JavaScript, using CRDTs
Frameworks	2025	mastro	a very simple framework on performance and simplicity
Games	2010	Akibahara	A wonderful set of small libraries to clone 8-bit era arcade games
Graphics	2008	JS Infoviz Toolkit	A pretty comprehensive set of resources
	2009	Parcycle	A particle system for Canvas
	2010	Raphael	A vector graphics library
	2011	paper.js	open source vector graphics scripting framework that runs on top of Canvas
	2012	Ejecta	A fast GL-backed canvas library for iOS
	2013	Two.js	An intriguing API that supports a number of back-ends (svg, canvas and WebGL)
		svgjs	A lightweight library for SVG handling
	2014	glsl-transition	A library that uses GL shaders for transitions
	2015	smartcrop.js	Content-aware image cropping
	2019	Fabric.js	supports various kinds of canvas manipulation, including image filters
		Planetary.js	Another globe visualization library
		uPlot	extremely fast timeseries plotting
		Gio.JS	Globe visualization library
		chart.xkcd	various XKCD-styled chart types
		globe.gl	Very nice globe visualization component, with animated overlays, arcs, etc.
	2020	Textures	a lovely way to do SVG-based hatch fills for charts
	2021	midori	a library for animating image backgrounds with cinematic effects
Libraries	2019	cote	a zero-configuration microservices framework
		moveable	GUI library for drawing editors
		htm	a JSX-like library
		flexsearch	a full-text indexer for browser and server-side
		osmosis	an HTML parsing library with Xpath support
		azure-sync	syncs from local filesystem to blob storage
	2021	microdiff	a fast object diff library
		piscina	a cleverly named task pool
		htmx	a nice, compact, Ajax library
	2024	main-thread-scheduling	a library for scheduling tasks on the main thread
	2026	muJS	A lightweight AJAX navigation library — 5KB alternative to Turbo and htmx
		docx-preview	browser renderer for .docx files using HTML/CSS output
		pptxviewjs	lightweight web component/renderer for PPTX file previews
		xlsx	spreadsheet parsing/export library used for rendering Excel workbooks in browsers
		htmx SSE	Server-Sent Events extension for htmx
Markup	2007	Diff Algorithm	Text diffing
	2013	Rainbow	A nice syntax highlighter
		Codeblock.js	A nice way to provide code samples.
Mobile	2019	Expo	Good React Native wrapper/accelerator
		NativeScript	Native mobile development with nice Vue support. Probably my favorite so far
		Ionic	Good Angular, Vue and React Native wrapper/accelerator
Runtimes		QuickJS	supports compilation to standalone binaries
	2022	rampart	A minimal footprint runtime/stack with full text search, sql, lmdb, redis, https, websockets, curl, crypt and more
		Bun	an all-in-one runtime and NPM client written in Zig
	2023	kaluma	tiny and efficient JavaScript runtime for RP2040 (Raspberry Pi Pico)
		otto	a JavaScript interpreter written in Go
	2024	quickjs-ng	a fork of QuickJS
	2025	MicroQuickJS	a minimal port of QuickJS for microcontrollers
Tools	2011	PhantomJS	A complete WebKit renderer, since obsoleted.
	2012	javascript.tmbundle	An indispensable “TextMate”:apps/TextMate add-on (the autocompletion features alone are priceless)
	2016	nodeenv	A sane way to install multiple versions of Node in segregated environments. Downloads prebuilt binaries on macOS, Linux and Windows.
		create-react-app	A bootstrap tool for React apps.
	2017	pkg	Package Node projects into an executable
	2022	pkg	Package Node apps into standalone binaries
	2023	xstate	JavaScript and TypeScript finite state machines and statecharts.
	2024	Hexo	a static site generator
	2026	portless	Node-based CLI that runs your dev server through a local proxy so every service gets a stable .localhost URL (with HTTPS/2, host sync, and auto-managed ports for subdomains/worktrees).
UI	2007	Timeline	a draggable timeline widget
	2011	Color Wheel	A color picker component
		Timeframe	Amazing calendar widget with support for date range selection.
	2012	Mousetrap	a very nice way to handle keyboard shortcuts
		jsPlumb	A Yahoo pipes-like library
	2013	rainbow.js	A slim progress bar
		Odometer	A library for counters with smooth transitions
		nprogress	Another slim progress bar
		Kalendae	a very impressive, framework-agnostic date picker
		date	A date parser that can take pseudo-natural language strings
	2014	Framerjs	For designing interactive prototypes
	2015	lazysizes	For lazy image loading
		dragula	a cute drag and drop library
	2018	zircleUI	a Vue-based framework for developing zoomable UIs (especially nice for touchscreen displays)
	2019	Flowy	a library for implementing flowchart editors with drag and drop
		tiptap	a nicely featured editor component for Vue.js
	2020	arwes	a React-based framework with a futuristic look and feel
		neutralino	a lightweight alternative to Electron
		plyr	a customizable HTML5 video player component
	2023	Yue	a cross-platform C++ library for writing desktop apps
	2024	mizu	a lightweight HTML templating library for any-side rendering with support for custom elements
		shadcn-ui	a nice-looking React component library
	2026	Zumly	a JavaScript library for hierarchical zoom navigation and structured zoomable user interfaces with pluggable transition drivers.
Web Frameworks	2024	Hono	another lightweight web framework, focusing on edge platforms

]]> https://taoofmac.com/space/dev/golang?utm_content=atom 2013-06-28T10:12:00+00:00 2026-04-08T07:07:58+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
AI	2025	go-attention	A full attention mechanism and transformer in pure go (uses FP64, and is slow)
	2023	agency	an LLM library for Go
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
Deep Learning	2018	go-neural
		gonn
		neurgo
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	2025	script	a library for building script alternatives
		event	simple internal event bus for Go applications
		mcp-golang	a Go implementation of the MCP protocol
	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
Machine Learning	2018	goml	stream oriented ML library
		word2vec	word2vec model support
		golearn	A very nice machine learning library
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/apps/code?utm_content=atom 2016-12-20T18:30:00+00:00 2026-04-08T07:07:58+00:00 Rui Carmo https://taoofmac.com Visual Studio Code became my de facto default editor (well, other than vim back in 2016 (years before I joined Microsoft) simply because it was inhumanly fast for an Electron application and completely usable on Mac and Linux from day one.

Throughout the years, its Monaco editor, support for every single programming language I wanted to use and explosive extension ecosystem just made it better and more “sticky”, and I use it daily on almost every single device I own (including the iPad, via Blink).

Category	Date	Link	Notes
Data Science	2025	positron	a fork designed to be used as a one-stop data science IDE
Debugging	2022	debug-visualizer
Diagramming		draw.io
Notetaking	2024	Foam	way better than Obsidian for my use case
	2023	VS Code Wiki	mostly compatible with vimwiki
	2022	Markdown+Math
Productivity	2026	Agent Kanban	VS Code extension that wires a drag-and-drop Kanban board to GitHub Copilot Chat, storing each task as a markdown file with YAML metadata so you can plan/todo/implement with @kanban commands while keeping a version-controlled chat history.

]]> https://taoofmac.com/space/ai/speech?utm_content=atom 2025-05-01T18:15:00+00:00 2026-04-06T21:57:15+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	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
	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 tookit for doing speech processing and voice cloning
				a tool 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/typescript?utm_content=atom 2024-06-10T10:00:00+00:00 2026-04-06T08:38:36+00:00 Rui Carmo https://taoofmac.com TypeScript is a superset of JavaScript that adds static typing, decorators, enums and enough opinions to keep larger teams from spiraling into duck-typed chaos.

It was originally developed and is still largely maintained by Microsoft, but its reach extends well beyond the browser: tooling maturity, strong editor support and incremental adoption make it a safe upgrade path for existing JavaScript codebases.

TypeScript’s success is also due to runtimes that take it seriously. Deno treats it as a first-class citizen, and newer entrants like Bun ship integrated transpilation plus batteries such as SQLite bindings, test runners and bundlers. Even if you dislike the syntax (I mostly do), you can still benefit from the type checker while targeting plain JavaScript for deployment.

When I dabble in TypeScript it is usually to build tooling or utility scripts where strong typing keeps refactors honest. The language is still verbose compared to more expressive options, but I can live with that.

Category	Date	Link	Notes
Backend	2025	SyncKit	a local Firebase-like service that operates offline and synchronizes data via CRDTs
CLI	2026	rx	TypeScript library and CLI for encoding/decoding JSON and binary data with random-access file features and streaming-friendly primitives.
		gloomberb	an extensible TypeScript financial terminal for the terminal
		giggles	TypeScript/React toolkit (Ink-powered) for building playful terminal experiences, with terminal UI primitives, Markdown terminals, and recorded demos you can watch via vhs.
Desktop		appbun	CLI that turns any webpage into an Electrobun desktop wrapper, pulling icons and metadata automatically and scaffolding editable macOS, Windows, and Linux app projects with packaging helpers.
		Electrobun	complete solution for building, updating, and shipping cross-platform desktop apps in TypeScript using Bun and native Zig bindings

]]> https://taoofmac.com/space/apps/screencasting?utm_content=atom 2007-11-06T21:43:01+00:00 2026-04-06T10:12:16+00:00 Rui Carmo https://taoofmac.com I find myself both in occasional need for doing screencasts or screen sharing sessions and constantly looking for screen mirroring solutions, and this table tries to summarize both under the same generic label of “screen casting”:

Category	Date	Link	System	Notes
Keystroke Overlays	2019	QiPress	Windows	Free version available, also displays mouse clicks
		Carnac
		keycastr	macOS	Open Source
		KeyPress OSD	Windows	also highlights mouse position
		Keystroke Pro	macOS	Sadly, not available in the App Store
		screenkey	Linux	PyGTK, old-ish
Mouse Overlays		Cursor Pro	macOS
	2018	Mouseposé		also displays keyboard presses. Great for presentations, too
Plugins	2019	shortcut_VUr		a Blender plugin to overlay mouse and keyboard commands
Screen Mirroring	2022	UxPlay		Generic GStreamer-based solution for AirPlay functionality
	2020	RPiPlay		Working AirPlay mirroring for iOS and macOS. Does not (yet) support casting videos.
		miraclecast		Miracast-based. Still not quite all there, but has a Raspberry Pi 3 build. Supports essentially Android clients
		lazycast		supports Miracast (and MICE) on the Pi
		Promys		Requires own application. Runs on a Pi, supports Mac/Windows/Linux clients.
Screencasting	2026	OpenScreen		an open-source demo and screencast creation app positioned as an alternative to Screen Studio.
	2019	Captura	Windows	All-in-one solution (includes overlays), can be installed via Chocolatey
	2007	Screenflick	macOS	A full-fledged screencasting app that also records mouse clicks and keypresses separately

]]> https://taoofmac.com/space/ai/llm?utm_content=atom 2025-05-01T17:30:00+00:00 2026-04-07T07:13:11+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
	Desktop Assistants		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/notes/2026/04/05/1700?utm_content=atom 2026-04-05T17:00:00+00:00 2026-04-05T17:27:00+00:00 Rui Carmo https://taoofmac.com This was a shorter work week partly due to the Easter weekend and partly because I book-ended it with a couple of days off in an attempt to restore personal sanity–only to catch a cold and remain stuck at home.

In practice that meant I spent most of it hacking on things I’ve been putting off for weeks, and after we finally made it to the countryside, the weather was nice enough to spend most of my time lounging about with nothing but my phone and the Xteink X4–which is about as close to a holiday as I’m going to get this quarter.

I’m also partway through Patrick McGee’s Apple in China, which is one of those books that makes you want to check the news every few pages to see if anything has changed since the last chapter. The thesis–that Apple’s dependence on Chinese manufacturing is a strategic vulnerability that could be exploited overnight–has already become obvious thanks to last year’s geopolitical upheaval, but McGee’s sourcing and detail make it feel much more concrete than the usual hand-wringing.

Very nice reading, especially if you had anything to do with Nokia and phone logistics.

I wrote this up separately, but the short version: it’s an absurdly small e-ink reader that costs almost nothing, feels better made than it has any right to, and reminds me of reading e-books on a Palm PDA. No front light, which limits it to daylight and decently lit rooms, but for the price and the form factor I’m not complaining. I’ve been carrying it around all weekend and it’s a genuinely pleasant little device.

I had a slight whoopsie in my Proxmox cluster (lite LVM doesn’t fully isolate volumes, so one of my new machines corrupted another two…), and Piclaw helped me fix everything and restore from backups with nothing but raw API calls to the cluster. That was enough motivation to make things official and add SSH, Proxmox and Portainer tooling, all lazy-loaded to save LLM context.

I now have a fourth instance running on my network that can discover, inspect and manage VMs and containers across the cluster without helper scripts, which is pretty neat. I’ll be rebuilding my GPU sandbox with it in a couple of days, and have it update my Obsidian notes directly.

I spent a good chunk of this weekend working on finishing that review I’ve been going on about for weeks. Since I have a Piclaw instance on it, I asked it to update benchmark data, charts and diagrams remotely, and revise my notes on the entire thing (GRUB, resize-filesystem bugs, three rounds of reboot-fallback patches).

But last week I was using it to work on an AArch64 JIT for BasiliskII, and it’s tantalisingly close to done. The bringup consumed most of my evenings, ranging from byte-order bugs–graphics corruption, palette rendering, JIT dispatch–to a steady stream of fixes to the original JIT source, with every emulated instruction block exposing a new flag-handling bug.

This is the sort of work I would never have been able to do without AI. I do have a background in 68k assembly (and a shelf of ancient books), but things like register mapping and memory alignment fixes would have gone right past me. And yet, neither Codex nor Claude were able to see the big picture–like realising that IRQs were messing with JIT state and needed proper handling:

The X flag (extend/carry) was the recurring villain–the models found bugs in how it was copied, masked and converted between the interpreter’s format and the JIT’s native representation. A wrong bit position in DUPLICATE_CARRY, COPY_CARRY not masking to the carry bit, LSL missing from legacy_copy_carry_to_flagx, and a countdown variable type mismatch that broke tick synchronisation. All individually plausible, collectively maddening until you realise it was polluted by both IRQ handling and state tracking whenever you jumped out of the JIT.

Another great thing about AI is effortless documentation: a comprehensive bringup document now lives in the repo tracking the bugs found so far, and it’s easy to trim out the fluff and keep things factual.

Right now the JIT boots to a Mac OS desktop with basic optimisations, but full JIT is still a work in progress. However, even the partial speedups are already a bit beyond what Classic benchmarking tools can handle, which is rather fun:

With any luck, I should get this working reproducibly in another week or so.

Disclaimer: Even though I paid for the device with my own money, this can be considered a review, so I’m linking to my review policy for consistency.

I had been tracking the hype around the X4 for quite a few months, and part of the appeal here is obvious: it is cheap, tiny, and simple in a way that most e-readers stopped being years ago. But one of the interesting parts for me is that it uses an ESP32-C3 and has already attracted a small but very active firmware community, which means that unlike most budget reading devices, this one has a decent chance of getting better after you buy it.

And yeah, I’m a sucker for a new gadget, and this was both cheap and moddable enough to be a no-brainer purchase.

The hardware is exactly the sort of compromise I expected, but with a few pleasant surprises. The body is light, pocketable and thin enough that it feels more like a phone accessory than a “real” reader, and the physical buttons are, at least initially, better than I feared.

The screen is small enough that I don’t think of it as a Kindle replacement–not in the way I thought of the Supernote Nomad as an iPad substitute for a very narrow set of tasks–but more as a sort of digital paperback fragment, something meant for short stretches of reading or carrying around just in case.

There is already an even smaller device, but Xteink decided to remove the USB-C port in favor of a pogo pin connector, and that was more than enough reason for me to pass on it.

That said, the lack of a front light is immediately noticeable, and not in an abstract “spec sheet” way. It changes where and when I can use it, and means I am already mentally classifying it as a daylight or well-lit-room device. That is fine for a toy, or for commuting, but it can be a meaningful constraint if you read in bed or on planes (so far I haven’t really had any issues with it and my bedside table lamp, but this isn’t a deep night reading gadget).

The other immediate hardware tell is that everything about it has been budgeted very carefully–screen size, battery, controls, CPU, software assumptions–and that is both the problem and the charm.

The absence of a touchscreen is, I think, the defining choice here.

On the one hand, I can see the appeal: fewer layers of UI indirection, fewer opportunities for sluggish touch handling, and a somewhat more deliberate feel when all you want to do is page forwards and backwards. On the other hand, every task that is not pure reading becomes a little awkward, and that awkwardness adds up very quickly once you get to Wi-Fi setup, library navigation or anything involving text entry.

This feels a bit like old Palm and iPod territory–perfectly usable once muscle memory kicks in, mildly exasperating until you get used to it.

I have not had it long enough to make sweeping claims, but one thing is already clear: the X4’s real value is not the stock firmware, and the very first thing I did after getting it was flashing CrossPoint Reader on it (and I just updated it to 1.2.0 before posting this).

And yes, the reason this device exists in my head at all is the CrossPoint ecosystem, and the fact that there are already multiple forks with visibly different goals–plain upstream CrossPoint, CJK-focused builds, reading-centric mods, and at least one gloriously odd fork that adds a virtual chicken to the whole thing.

That changes the equation quite a bit. Without that community, the X4 would just be an interestingly cheap, slightly awkward e-reader. With it, the hardware becomes a small platform–limited, yes, but still a platform, and something that I can fool around with myself.

And that matters, because the ESP32-C3 underpinnings imply a level of hackability that most mainstream readers don’t even pretend to offer.

This is the part I still need more time with, but which has been a resounding success over the past three days (although that is certainly due to my long history with tiny screens). With CrossPoint, page turns are snappy, chapter navigation a matter of 2-3 clicks, and the default Bookerly font is pretty much perfect.

Although it feels a bit weird to have gotten another, pocketable screen when I effectively work from home and thus have little need for a “snackable” reading device that is always on my person, I find it more appealing (and purposeful) than digging out the Kindle app on my phone.

My instinct is that the X4 will be best for the sort of fragmented reading I typically do when traveling or in short breaks throughout the day–in the Instapaper days, I would take my iPod and read articles converted and pushed over in batches–rather than long, immersive reading sessions. The size almost guarantees that. It is not trying to disappear the way a larger reader does; it is trying to always be there.

Whether that is enough depends entirely on friction, and with fast page turns, Wi-Fi support and an OPDS client in CrossPoint, that seems quite well in hand.

The missing piece of the puzzle was getting books on it, and even though CrossPoint provides a nice on-device web server to manually upload files to it (which is pretty amazing for an ESP32), I decided to flip the issue around and hack together a very quick Bun OPDS server that works beautifully with my Calibre setup and the X4, letting me browse all my libraries and download books to it without any manual file management at all.

That was a fun little project, and it is already making the X4 feel much more like a “real” reader, to the point where I’ve already started modernizing my ancient Instapaper pipeline in favor of something “better”.

In fact, this might be the push I needed to move away completely from the Kindle ecosystem–I have long preferred to get DRM-free EPUBs, and I can get my Nomad to use OPDS via KOReader…

I keep thinking back to the Nomad, partly because both devices are trying to sell focus through constraints, but they go about it in very different ways.

The Nomad tries to be a deliberate, paper-adjacent environment for writing and reading–and often succeeds, even if syncing and workflow integration kept getting in the way (at least until I found the right combination of SyncThing and Obsidian plugins). The X4 feels less ambitious and, paradoxically, more interesting because of that. It is not trying to be a notebook, or a paper surrogate, or a productivity system. It is just a tiny e-reader with enough open firmware momentum to become something slightly stranger.

I think that honesty may end up working in its favour.

Since this is meant to be pocketable and I always end up stuffing my jacket pockets, I printed a hard case for it to protect the screen and buttons, and am quite happy with the results.

What I want to do next is fairly straightforward:

• Spend a few more days on CrossPoint 1.2.0 and hack away at a moderately sane content pipeline that forces me to read interesting articles on it rather than bookmarking them into a black hole of oblivion.
• Compare that against either the Enhanced Reading Mod or CrossPet–the former because it sounds sensible, the latter because it sounds gloriously unserious.
• Hack away a bit more at that OPDS server to see what I can do about syncing reading progress (I’m the kind of person who never used bookmarks because I had zero issues memorizing page numbers, but I do like the convenience of Kindle’s Whispersync).
• Figure out over a month or so whether this thing fits my actual reading habits, or merely appeals to my taste in tiny hackable hardware.
• And, if all else fails, turn it into a mini TRMNL–the software for that already exists…

Right now, I think the Xteink X4 is more interesting gadget than a fully fleshed out product–but that is not necessarily a criticism. Some of the best gadgets I’ve owned started out exactly that way.

I did manage to get my AI minions to do a proper refactor of the piclaw codebase (which was desperately needed), spent a bit of time cursing at the SK1 (and concluding that I need a new 3D printer), and that’s about it. Meetings, deadlines, the usual corporate grind.

This was the week of the great piclaw codebase reckoning–299 commits, all of them aimed at breaking apart the monolithic mess it was becoming before it got completely out of hand.

Agentic development works, but, again, you need to have taste and force a feedback loop to get good results. But you can automate away the boring parts, mostly.

The whole thing was driven by an autoresearch-style loop–I basically adapted Karpathy’s approach of having an LLM do research on a codebase, generate a plan, execute it, and then verify the results, except in my case the “research” phase also involves running the test suite and feeding failures back as context. It works very well for mechanical refactoring like this, where the risk of hallucination is low and the reward for not doing it by hand is immense:

Everything Else

I still haven’t written up those SBC benchmarks I keep promising, but I have been using the SBC extensively–in fact, I dusted off my macemu fork (BasiliskII/SheepShaver with Raspberry Pi-optimized SDL2 builds, Docker images, and .deb packages) and got that running on it.

It’s been sitting at v1.0.5-patch-3 since February, but Marchintosh guilt finally got me to fire it up and poke at it. No new Mac Classic replica yet, but at least the emulator is working, and I am back trying to get an ARM64 JIT working in it, which is a fun challenge:

I expect to have something to show on that front… this year?

Update: An hour later… Works, but still needs a fair amount of clean up, and it’s actually slower than the interpreter for now, which is a bit embarrassing:

]]> https://taoofmac.com/space/links/2026/03/27/2120?utm_content=atom 2026-03-27T21:20:00+00:00 2026-03-27T21:27:24+00:00 Rui Carmo https://taoofmac.com

This is absolutely hilarious. The infuriating window corner roundness in Tahoe has been bugging me too–and this is a brilliant take on the problem.

Instead of disabling SIP and patching system apps to remove the rounded corners (which is the usual approach), this simply forces a consistent corner radius across all third-party apps via a DYLD-injected dynamic library.

It’s a small thing, but inconsistency in UI chrome is the kind of detail that, once you notice it, you can never un-notice. The fact that Safari has different corner radii from other apps is inexcusable–and that’s before the Liquid Glass disaster made everything look like a Fisher-Price toy dipped in vaseline. I appreciate the “if you can’t beat them, at least make them all equally ugly” philosophy here.

The implementation is old-timey, straightforward Objective-C method swizzling on NSThemeFrame–nothing exotic, but the approach of skipping com.apple.* bundles and only touching third-party apps means you don’t need to mess with SIP at all. That alone makes it worth bookmarking.

The fact that ARM, whose entire business model revolved around licensing CPU designs, has decided to actually go and build their own chips is remarkable by itself, but the design specs (and power envelope) are very interesting.

I have been keeping tabs on the dedicated inference hardware space ever since I got wind of Cerebras, and I like the idea of special purpose/optimized CPU designs that would remove (or at least lessen) our dependency on NVIDIA (and GPUs in general) to run AI models, because that is the way to make it cheaper, less power hungry and, eventually, desktop-sized.

I do find it stupid to refer to this as an AGI CPU, though.

There will be a smattering of Wiki updates on the RSS feed as well, since I realized I had a bunch of updates pages sitting uncommitted in the queue that I hadn’t gotten around to pushing yet, but the only relevant updates I have right now are that piclaw got a major package layout overhaul and a new live widget system, while vibes got some shared UI improvements and a new agent avatar caching system.

And, most importantly, I have shifted from building the tooling to using the tooling, which is long overdue.

Here’s a good example of that:

Yes, that is a Linux agent and a Windows agent setting up Bluetooth passthrough on a VM. And yes, “Smith” manages my Proxmox cluster, as well as many other things now.

And yes, piclaw sort of runs on Windows now (in bare/non-sandboxed/YOLO mode), thanks to Bun’s incredibly good cross-platform support. I gave it a VM to break and a PowerShell extension to play with, and although I’m still deeply sorry I did it, it works well enough that I don’t need to care about the OS.

I now have four or five semi-permanent installs running on various machines (and a couple of Azure and Oracle VMs), and having them all accessible from my phone has completely changed how I deal with remote management–I can check on agents, trigger actions, and do light debugging from anywhere, which beats the old “SSH in and hope for the best” approach by a wide margin.

And soon, they will talk to each other. And who knows, I might do a desktop app at some point, but for now the web interface is doing just fine.

I never did get around to writing up those SBC benchmarks I mentioned last week. The hardware is sitting on my desk, the notes are in my Obsidian vault and I have a piclaw instance that is happy as a clam trying to get various local models running on it, but, again, work was just too much this week and I plan to spend the afternoon watching a movie and doing some light reading instead.

Date	Link	Notes
2026	Flash-MoE	Objective-C/Metal inference engine that runs Qwen3.5-397B MoE locally on Apple Silicon with SSD streaming, dequantization, and custom GPU kernels.
2010	ThoMoNetworking	A very interesting network-oriented framework that makes it easy to pass data between all sorts of devices automagically.
2009	Learn Objective-C	What the cool kids were reading in 2009.

]]> https://taoofmac.com/space/dev/rust?utm_content=atom 2020-09-01T10:41:00+00:00 2026-03-22T12:53:22+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	kay	an actor system for Rust
		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.
Machine Learning		gte-pure-C	Pure C implementation of the GTE-small text embedding model (dependency-free, 384-dim embeddings). Focused on semantic similarity, search, and clustering.
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/cli/ffmpeg?utm_content=atom 2009-10-03T08:23:00+00:00 2026-03-22T12:53:22+00:00 Rui Carmo https://taoofmac.com This page holds my notes on using ffmpeg for typical (and atypical) conversions, largely thanks to the mess that the consumer electronics industry has made of standards (see also MKV, which is the format I favored for ripping my kids’ DVDs to avoid them chewing the discs to pieces until I switched to an Apple TV and decided to just go with multi-track MP4).

• FFmpeg cheatsheet for video automation - a categorized collection of FFmpeg commands and explanations for automation pipelines.
• lazycut - a terminal-based video trimmer for marking in/out points and exporting clips with an ffmpeg-backed workflow.

This can be done on an ARM machine with remarkably little CPU power, since you’ll simply be copying video across without touching it:

ffmpeg -i file_with_aac_surround_.mp4 -vcodec copy -acodec ac3 -ac 6 -ar 48000 -ab 448k file_with_ac3.mp4

# fixed bitrate
find . -name "*.flac" -exec ffmpeg -i {} -ab 320k -map_metadata 0 -id3v2_version 3 {}.mp3 \;
# high quality VBR
find . -name "*.flac" -exec ffmpeg -i {} -codec:a libmp3lame -q:a 0 -map_metadata 0 -id3v2_version 3 {}.mp3 \;

The typical use case is to generate a poster image:

ffmpeg -i input.mp4 -vf "scale=iw*sar:ih,setsar=1" -vframes 1 poster.png

I was once asked to make it easier to navigate a set of videos on a WDTV media player and, after looking around for alternatives, eventually came up with the following Python snippet, which is designed to be dropped into an Automator workflow.

import sys, os, re

# Handle only these file extensions
pattern = re.compile("^(.+)\.(divx|mov|avi|3gp|wmv|mp4|mkv)$", re.IGNORECASE)

for f in sys.stdin:
  f = f.strip()
  matches = pattern.match(f)
  if matches:
    base = matches.group(1)
    thumb = "%s.jpg" % base
    if os.path.exists(thumb) and os.path.getsize(thumb):
      continue # skip existing non-null files
    os.system("/usr/local/bin/ffmpeg -i '%s' -deinterlace -an -ss 30 -t 00:00:01 -r 1 -y -vcodec mjpeg -f mjpeg '%s' 2>&1" % (f, thumb))
    if os.path.exists(thumb):
      # tweaked rendering to attempt a vertical thumbnail with a center crop
      os.system("/usr/bin/sips '%s' --resampleHeight 160 --cropToHeightWidth 160 120 --out '%s'" % (thumb, thumb))

It takes a list of files on standard input and then invokes ffmpeg to extract a thumbnail 30s into the video. sips is then used to resample that image to a smaller size, preserving the aspect ratio.

There’s also a Windows one-liner I was sent that may help:

for %i in (*.avi) do ffmpeg -i "%i" -f mjpeg -t 0.001 -ss 30 -y "%~ni.jpg"

See this blog post.

João Neves sent over this one-liner for transcoding to Android or iOS devices. The bitrate (-b) can vary from 600k to 1000k for the latter, and 600k reportedly works well for the HTC Magic:

ffmpeg -i input.avi -acodec libfaac -ab 128k -vcodec mpeg4 -b 600k -mbd 2 -cmp 2 -subcmp 2 -s 320x180 output.mp4

But there was a lot of ground to cover, and it’s turned into a sort of “agentic IDE” thing at this point, terminal and all:

piclaw

Most of the week went into reliability work. I spent a day or so doing a full refactor, and then got three different LLMs to do a comprehensive full-stack audit of the turn/queue/steering system–which turned up a bunch of race conditions in message submission that I’d been chasing for weeks (plus proper queue deduplication and retry caps, which I should have added from the start). The deferred followup system I was using for steering was also broken in subtle ways–turns were inheriting stale thread roots, which caused all sorts of weirdness. The fun bits were the visual polish and theme support, but those came after the plumbing was solid.

On the UX side, I added Adaptive Cards rendering to the chat timeline (with validation and lifecycle flows)–the idea being that agents can now push structured forms, tables, and interactive elements into the conversation instead of just Markdown. The workspace editor got markdown attachment previews and a Ghostty-based terminal lifted directly from webterm, plus a bunch of pipework for future multi-chat support (which is going to be a whole thing).

All of it involved, as you would expect, a lot of agent herding, and I had plenty of time to come up with stuff like this:

And I cleaned up all the JS vendoring, since like pi itself, piclaw is now an extension host, so most of the new features are actually implemented as extensions.

python-office-mcp-server

I dusted off a Python-based Office document MCP server I’d been building alongside go-ooxml and carved it into its own repository. It’s a pretty comprehensive set of tools for reading, editing, and generating Word/Excel/PowerPoint documents via MCP–unified interface, template support, auditing, the works. It’s stable enough that I decided to publish it as-is, with zero ongoing support commitment. Sometimes the best thing you can do for a side project is to ship it and walk away.

As to this site, I did another big batch of old page conversions–around 200 wiki pages from the hardware and apps sections got modernized from Textile to Markdown with proper frontmatter, descriptive image filenames, and cleaned-up links. Some of these pages date back to 2002, which is always a weird trip.

What I should be doing, though, is celebrating Marchintosh and building a new Mac Classic replica–but all I’ve done hardware-wise has been benchmarking SBCs for a potential new project. I hope to clean up my notes and post something about that next week.

The display is… fine? With their strategic placement away from the other laptops on display, side-by-side comparison was impossible, but I didn’t find it bad or dim. The keyboard also felt OK, although I am wary of white keyboards, as they tend to get dirty and look bad over time. The trackpad was… also fine. I don’t press to click, so comparing the physical click with the taptic engine doesn’t make sense to me.

However, the bezels were a bit thicker than I am used to (hence noticeable) and I do think that the overall size could be smaller (even if that would be clearly against mainstream taste). It’s not something I would choose for a cheap travel laptop (especially considering I have the Minibook X), but volume-wise, and in “backpack scale”, it’s not that far off from the 13” MacBook Air if you squint.

Of course it was Tahoe, with Liquid Glass. The less said about that horrid mess the better.

To my surprise, it ran this site’s 3D visualization quite snappily, which is no small feat (most PC laptops struggle with it, regardless of what browser and GPU they have). And although I didn’t have the chance to run any benchmarks, RAM usage in Activity Monitor was pretty much OK after launching a gaggle of Apple apps, which wasn’t surprising (their software load doesn’t include any of the Electron bloat everyone has to deal with to some degree).

In general, I think it makes a killer Chromebook/PC laptop replacement for school, and although I expect the A18 to not be a powerhouse, it felt quite snappy, even with multiple apps open. And I’m sure Apple went to some pains to position it where it wouldn’t threaten either the Air or the iPad Pro.

I’d buy one in a flash if it was smaller (well, if I had money to spare), but at least the A18 performance makes me optimistic for whatever they decide to put into the next iPad mini, since my 5th generation one is in desperate need of an upgrade.