Epicenter

Epicenter is a Y Combinator-backed (S2025) monorepo of local-first apps built around one idea: your data should live on your machine as plain Markdown and SQLite, not locked inside a vendor’s database. Every app in the repo — transcripts, notes, chat histories, todos — writes to files you can grep, version with Git, and open directly in tools like Obsidian, so an app that stops mattering doesn’t take your data with it.

The flagship, installable product is Whispering, a desktop speech-to-text app for macOS, Windows, and Linux. Press a global keyboard shortcut, speak, and the transcript is pasted wherever you were typing — no account required. Transcription can run entirely offline through a bundled Whisper C++ model, or through a cloud provider (Groq, OpenAI, ElevenLabs, Deepgram, Mistral) using your own API key, with an optional AI transformation step to clean up or reformat the text before it lands in your document.

Underneath the apps sits @epicenter/workspace, an MIT-licensed developer toolkit that tackles the actual hard problem in local-first software: keeping multiple devices in sync without a central server owning the truth. It makes a Yjs CRDT document the single source of truth, then projects that state outward into a read-only SQLite mirror for fast queries and a Markdown export for humans and Git. About a dozen other apps in the repo — Matter (a typed grid over Markdown folders), Honeycrisp (notes), Wiki, Todos, a browser tab manager, and more — are built on the same toolkit, shipping as products or living as public research prototypes.

What You Get

• Whispering, an installable desktop speech-to-text app for macOS, Windows, and Linux with global-shortcut dictation.
• @epicenter/workspace, an MIT-licensed toolkit for building your own local-first, CRDT-synced apps from scratch.
• A dozen-plus bundled apps and prototypes on the same toolkit: Matter, Honeycrisp, Wiki, Todos, Vocab, a browser tab manager, and more.
• The epicenter CLI for running workspace actions and connecting to a local daemon or a hosted/self-hosted API.
• Two server deployables: a hosted Cloudflare Worker (apps/api) and a self-host reference Worker (apps/self-host) with no billing surface.
• Automatic Markdown and SQLite projections of every workspace table, so your data stays grep-able, git-friendly, and portable.

Common Use Cases

• Hands-free note capture and writing via voice dictation, with audio staying fully on-device when using the local Whisper C++ model.
• Building a custom local-first app (notes, PKM, an internal tool) on the MIT toolkit instead of writing your own CRDT sync protocol.
• Self-hosting your own sync and transcription backend instead of depending on a vendor’s hosted service.
• Maintaining a personal Markdown knowledge base that stays queryable through a disposable SQLite mirror (Matter).
• Wiring an LLM agent to schema-validated local data through typed workspace actions rather than letting it hand-edit generated files.

Under The Hood

Architecture Epicenter runs a strict layered composition: a core (@epicenter/workspace, @epicenter/sync, @epicenter/constants, @epicenter/ui) at the bottom, a middleware layer (@epicenter/svelte-utils, @epicenter/filesystem, @epicenter/skills, workspace/ai) that adapts the core into app-shaped tools, and thin apps on top that mostly wire runtime concerns together. The lifecycle inside the core is explicitly staged: defineTable/defineWorkspace are pure declarations with no I/O, createWorkspace turns those declarations into a live model, and runtime-specific openers (openBrowser/openDaemon/openTauri) attach storage, sync transport, and materializers only at the edge. Whispering carries this same separation into its own tree through platform-conditional import maps (a browser implementation and a Tauri implementation selected via package.json “imports” conditions), so one codebase serves both a web build and a native desktop shell without branching logic at each call site. The single load-bearing guarantee is that Yjs is the only mutable source of truth while SQLite and Markdown are read-only projections; if a materializer or the CLI ever wrote back into those projections directly, the entire “files you own, safely regenerable” premise the project is built on would collapse.

Tech Stack The repo is a Bun-managed monorepo (bun.lock, Bun workspaces) spanning around nineteen apps and twenty packages, pinned through a shared dependency catalog (Svelte 5, SvelteKit, Vite, Tailwind CSS v4, Tauri 2). Sync state runs on Yjs with y-indexeddb and y-protocols; validation runs through arktype and typebox; the server layer is Hono with better-auth for sessions and Drizzle ORM against Postgres for the hosted API, deployed to Cloudflare Workers via Wrangler for both the hosted (apps/api) and self-hosted (apps/self-host) deployables. Desktop distribution is Tauri 2 (Rust plus the system WebView) for Whispering, which also owns a native Whisper C++ inference path for fully offline transcription. Tooling is Biome (extended with a project-authored Grit plugin) for lint and format, TypeScript in strict mode, Changesets for versioned releases, and jsrepo for distributing shareable code blocks to other projects.

Code Quality Tests are colocated beside the implementation files they cover across a large number of test files, run with the Bun test runner, and reach into CRDT edge cases such as storage eviction, corrupted local-storage recovery, and presence protocol behavior, not just CLI or route happy paths. TypeScript runs in strict mode with noUncheckedIndexedAccess and noImplicitOverride enabled repo-wide, and verbatimModuleSyntax keeps the codebase safe to bundle without a separate transpile step. Error handling favors typed, explicit result objects over ad hoc thrown exceptions in service code. CI is split into dedicated workflows for formatting, autofixing, and a runtime-parity check that appears to guard the browser/Tauri platform-file split against drifting apart, and the repo enforces its own architectural invariants in CI beyond standard linting: a license-graph script blocks MIT packages from ever importing AGPL ones, and doc-path/doc-hygiene scripts validate the large documentation tree.

What Makes It Unique The genuinely distinctive technical choice is treating Yjs as the single mutable source of truth while demoting SQLite and Markdown to read-only materialized projections, rather than picking one persistence model and bolting sync on afterward the way most local-first tools do. The license-graph CI gate mechanically enforces the open-core boundary between the MIT toolkit and the AGPL apps, turning what is usually just a policy statement into a build-breaking assertion. The extensive, dated architecture-decision specs kept alongside the code read like an unusually disciplined applied history of the system’s evolution rather than typical after-the-fact documentation. None of the individual pieces (Yjs, SQLite, Markdown) is novel on its own, but the composition, and the tooling built to keep that composition honest over time, sit above standard practice.

Self-Hosting

Licensing Model Epicenter uses a two-tier open-core split. The developer toolkit (@epicenter/workspace, @epicenter/ui, @epicenter/filesystem, @epicenter/sync, and internal contracts like @epicenter/field and @epicenter/identity) is MIT: any developer can embed it in a closed-source product with no obligation back. Every shipped app — including Whispering — plus the CLI and shared server library are AGPL-3.0-or-later: self-hosting and modifying them is always free, but distributing a modified binary requires sharing the changes back, and running a modified version of the hosted server components (apps/api, apps/self-host) as a network service also triggers AGPL §13.

Self-Hosting Restrictions

• None found. Whispering’s own FAQ states the app is “free and open source forever” with no license key, and self-hosted deployables (apps/self-host) carry no billing surface at all.
• Cloud transcription providers (Groq, OpenAI, ElevenLabs, Deepgram, Mistral) require the user’s own API key, but that is a third-party cost, not an Epicenter paywall — a fully local Whisper C++ model is available with no key and no network call.

Enterprise Features No distinct “Enterprise” tier is documented in the repo. apps/api (the hosted Cloudflare Worker) contains hosted-only billing and dashboard code for metering AI transcription credits on Epicenter’s own cloud, which is a consumer-hosted-sync product rather than a seat-based enterprise plan. FINANCIAL_SUSTAINABILITY.md says the maintainers intend to offer support contracts to organizations that self-host, but describes this as a future plan, not something currently sold.

Cloud vs Self-Hosted The hosted Epicenter Cloud (apps/api) adds a signed-in account, a sync relay for multi-device Yjs updates, and metered AI transcription credits, so you don’t have to run your own server. Self-hosting (apps/self-host) runs the identical @epicenter/server library behind a single operator bearer token with no Postgres, no Better Auth, and no billing — inference against your own provider keys is unmetered. No shipped app requires the hosted account to function.

License Key Required No. Nothing in the self-hosted path requires a license key or activation; the AGPL-3.0-or-later terms apply automatically at the source level, and the MIT toolkit packages carry no restrictions at all.