Scribe is the demonstration: one app, an ecosystem of shards

Last week we shipped Scribe: a free, fully native, notarized macOS dictation app written in Crystal. Press a hotkey, speak, and your words are transcribed entirely on-device and pasted where your cursor is. No cloud, no accounts, no audio leaving your machine.

But Scribe isn't really the product here. It's the demonstration. Our whole thesis is that experiencing beats believing, and Scribe is intended to be a public working demonstration of how powerful the individual libraries we've been building can be: a real, tangible, easy-to-use product that shows just how far you can get with them. The app itself is about 7,600 lines of Crystal. Everything hard lives in shards you can pull into your own projects today.

The ecosystem tour

crystal-audio is the recording layer: microphone, system audio (no virtual audio driver on macOS 14.2+), or both simultaneously into separate files. That separation is what powers meeting transcription with your voice and the call kept apart. On-device transcription is built in, with whisper.cpp bindings in batch and streaming modes, and it has grown multi-track playback, lock-screen media controls, and iOS/Android build targets.

llamero is the AI layer. One track speaks to cloud providers (OpenAI, Anthropic, Groq, OpenRouter) with structured output parsed into Crystal objects. The other track is native Apple: an MLX runtime that keeps a model resident on Apple Silicon, streams chat, hot-swaps LoRA adapters, and can train a QLoRA adapter on-device from Crystal with no Python involved. The Parakeet speech-to-text runtime Scribe uses lives here too, running on the Apple Neural Engine at roughly 30x real-time.

asset_pipeline carries the native UI: AppKit and UIKit renderers driven from Crystal (windows, SwiftUI-hosted forms, native components), validated against an auditable Apple HIG ledger. Every window in Scribe is built with it.

Amber V2 and Grant give the app its shape: config, models, an ORM over SQLite. It is the full framework pattern with no HTTP server at all.

The compiler keeps its promise

Underneath all of it sits crystal-alpha, our fork of the Crystal compiler with incremental compilation: a no-change rebuild skips semantic analysis, codegen, and linking entirely. In this release's verification that meant 0.26s instead of 2.2s on a Kemal test app, and our earlier semantic-only benchmarks measured 3.2–5.2x warm speedups on larger codebases (Lucky, Athena, Amber). The fork comes with a promise: it tracks what's publicly available. Crystal 1.21.0 was released upstream on July 16; v1.21.0-incremental-1 merges it, so everything in current public Crystal is in the fork, plus the incremental machinery and the iOS, Android, and watchOS target work. Release notes and source are on the releases page.

Keeping that promise had a side benefit this time: while verifying the merge we found, and fixed, a stale-binary bug in the incremental cache that had shipped in the previous release. The release notes document exactly what it was and how to clear it. That's what the promise is for: syncing against upstream regularly forces the whole surface through verification, and bugs get caught by us instead of by you.

Designed for the way we actually build now

The last piece is the one we think matters most: this ecosystem is specifically designed for use with AI coding assistants, so the learning curve of the engineer or architect is reduced. Each library ships its own agent context: CLAUDE.md, skills, workflows. shards-alpha (our fork of the Crystal dependency manager) is the delivery mechanism: on install, the AI docs from your dependencies land in your project's .claude/ directory, namespaced per shard and version-tracked so your own customizations survive updates. It also distributes MCP servers and handles supply-chain compliance: OSV vulnerability audits, license checks, SBOM generation.

brew install crimson-knight/tap/shards-alpha

Point your assistant at a fresh project and it already knows how to drive these libraries. That's the point of the whole exercise: not one impressive app, but a toolchain where the next app, yours, starts from everything this one learned.

If you build something with any of these pieces, or something doesn't hold up, open an issue on the repo in question. Doing this in public is the point. For the deeper background on the process itself, start with Agent-Enhanced Development.