Epicenter: Why Developers Are Ditching Cloud-Locked Apps for Local-First

What if your notes disappeared tomorrow? Not because you forgot to pay a subscription, but because a company decided your data wasn't profitable enough to keep around. It's happened before—Google Reader, Parse, Storify, countless others. We've built our digital lives on other people's servers, and we've normalized the quiet anxiety of not truly owning anything we create.

But what if the solution isn't another cloud service with better marketing? What if the answer has been sitting on your hard drive all along?

Enter Epicenter, the open-source local-first app ecosystem that's making developers rethink everything they assumed about data ownership, synchronization, and modern application architecture. This isn't nostalgia for offline software—it's a surgical reimagining of how apps should work in an era of surveillance capitalism and fragile cloud dependencies. With Epicenter, your notes, transcripts, and chat histories live in a single folder of plain text and SQLite on your machine. Grep it. Query it. Host it wherever you want. The cloud becomes optional, not mandatory.

If you're tired of vendor lock-in, privacy theater, and apps that stop working when the Wi-Fi drops, keep reading. Epicenter isn't just another tool—it's a fundamentally different philosophy about who controls your data.

What is Epicenter?

Epicenter is an ecosystem of open-source, local-first applications built around a radical premise: your data should live on your machine first, everywhere else second. Created by Braden Wong and the EpicenterHQ team, it represents a growing movement among developers who've grown disillusioned with the default cloud-first architecture that dominates modern software.

The project's tagline is deceptively simple: "One folder of plain text and SQLite on your machine, synced across all your devices." But beneath that simplicity lies a sophisticated technical architecture that solves one of the hardest problems in distributed systems—conflict-free replicated data types (CRDTs) for seamless multi-device synchronization.

Epicenter is trending now because it arrives at a critical inflection point. Developers are increasingly aware of the costs of cloud dependency: recurring subscription fatigue, privacy erosion, regulatory compliance nightmares, and the existential risk of platform shutdowns. Meanwhile, tools like Obsidian proved there's massive demand for local-first note-taking. Epicenter extends that philosophy across an entire app ecosystem—transcription, browser management, AI chat, and more—with end-to-end encryption and real-time sync built in from day one.

The project is hosted at https://github.com/EpicenterHQ/epicenter and has rapidly gained attention for its clean architecture, pragmatic licensing split, and genuine commitment to developer empowerment over user extraction.

Key Features That Make Epicenter Different

CRDT-Powered Single Source of Truth

At Epicenter's core lies Yjs, a battle-tested CRDT library that handles concurrent edits across devices without conflicts. Unlike traditional databases that require a central server to arbitrate writes, Yjs CRDTs materialize down to SQLite for fast queries and markdown for human-readable files. The server is a dumb relay—it never sees your unencrypted content.

End-to-End Encryption by Design

Encryption happens client-side before any data leaves your device. The spec for encrypted workspace storage specifies XChaCha20-Poly1305 at the CRDT value level. When you self-host, you control the encryption keys and the entire trust boundary. This isn't privacy as a feature—it's privacy as architectural invariant.

Typed Schema System with Automatic Tooling

The @epicenter/workspace package lets you define tables with ArkType schemas that automatically generate CLI flags, API documentation, and MCP-compatible interfaces. Write a schema once, get SQLite tables, Yjs documents, and OpenAPI specs without boilerplate.

Multi-Platform Native Apps

Epicenter ships real desktop applications—not Electron wrappers. Whispering uses Tauri (Rust + WebKit) for native performance. Opensidian runs on SvelteKit. The Tab Manager is a proper browser extension using WXT. Each platform gets appropriate tooling, not lowest-common-denominator abstraction.

Composable, Layered Architecture

The dependency flow is deliberately strict: core packages have zero upward dependencies, middleware only reaches into core, and apps compose both. This means you can use @epicenter/workspace in your own projects without dragging in UI opinions or cloud dependencies.

Self-Hosting as First-Class Citizen

The sync server (apps/api) is open source under AGPL-3.0, with clear separation between the self-hostable sync relay and hosted cloud APIs. Epicenter Cloud will exist for convenience, but self-hosting isn't a second-class afterthought—it's the default assumption.

Real-World Use Cases Where Epicenter Shines

1. Privacy-Critical Note-Taking for Researchers and Journalists

When your sources' lives depend on confidentiality, cloud note-taking is liability theater. Epicenter's Opensidian provides Obsidian-like functionality with genuine end-to-end encryption, local SQLite storage, and optional self-hosted sync. Your research lives in plain text files you can grep, version with Git, or air-gap entirely.

2. Transcription Without Surveillance

Whispering converts speech to text using your own API key or local Whisper C++ inference. Medical professionals, therapists, and legal practitioners can transcribe sensitive conversations without sending audio to Big Tech servers. The shortcut-driven workflow stays fast while the data never leaves your machine unless you explicitly choose otherwise.

3. Cross-Device Browser Workflow Orchestration

The Tab Manager extension demonstrates how workspace sync enables genuinely useful cross-device experiences. Your tabs, sessions, and AI-assisted browsing context synchronize across laptop, desktop, and work machines—without Chrome's profile tracking or Mozilla's server dependency. The AI chat can even call workspace tools with inline approval, creating agentic workflows that respect your boundaries.

4. Building Custom Local-First Applications

For developers, @epicenter/workspace is the killer feature. Building a collaborative task manager? Define your schema, attach sync, and get offline-first, multi-device collaboration without operational complexity. The library handles CRDT merging, IndexedDb persistence, WebSocket reconnection, and materialization to SQLite. You build the UI; Epicenter handles the distributed systems hard parts.

5. Compliance-Friendly Team Collaboration

Organizations subject to GDPR, HIPAA, or ITAR can deploy Epicenter internally with complete data sovereignty. No third-party subprocessors to audit, no unexpected jurisdiction transfers, no vendor security questionnaires. The AGPL server code ensures modified versions stay open, creating transparent trust.

Step-by-Step Installation & Setup Guide

Installing Whispering (End-User Quick Start)

The fastest way to experience Epicenter is through Whispering, the desktop transcription app:

# macOS with Homebrew
brew install --cask whispering

For other platforms, download directly from GitHub Releases:

• macOS: .dmg installer
• Windows: .msi package
• Linux: .AppImage, .deb, or .rpm

Building the Full Ecosystem from Source

For developers wanting to explore or contribute, here's the complete setup:

# Prerequisites: Bun runtime, local PostgreSQL, Infisical for API secrets
# Clone the monorepo
git clone https://github.com/EpicenterHQ/epicenter.git
cd epicenter

# Install all dependencies
bun install

# Start the development environment (API + Tab Manager)
bun dev

The root bun dev command orchestrates multiple processes. For focused development on specific components:

# API server only
bun run dev:api

# Tab Manager extension UI only
bun run dev:tab-manager:ui

# Individual app folders support direct development
cd apps/whispering && bun dev  # Requires Rust for Tauri
cd apps/opensidian && bun dev  # SvelteKit app

Environment Configuration

Before running bun dev, configure your local environment:

1. PostgreSQL: Create a local database for the API server
2. Infisical: Set up secret management (see apps/api/README.md)
3. Rust toolchain: Required only for Tauri-based apps like Whispering

Troubleshooting Common Issues

When dependencies drift or builds break after pulling changes:

# Standard cache clear and reinstall
bun clean    # Clears caches and node_modules
bun install  # Fresh dependency resolution

For catastrophic build corruption (rarely needed):

# Nuclear option: clears everything including ~10GB of Rust artifacts
bun nuke
bun install
# Note: Cargo incremental builds are efficient; prefer bun clean first

REAL Code Examples from the Repository

The Epicenter repository contains substantial working code that demonstrates its architecture. Here are three critical patterns extracted directly from the README and source.

Example 1: Defining a CRDT-Backed Workspace

This is the foundational pattern that powers every Epicenter app. The openBlog function demonstrates schema definition, table attachment, IndexedDb persistence, and WebSocket collaboration in a single composed operation:

import { type } from 'arktype';
import * as Y from 'yjs';
import {
  attachIndexedDb,
  attachTables,
  defineTable,
  openCollaboration,
  websocketUrl,
} from '@epicenter/workspace';

// Define a typed table schema using ArkType
// The _v field enables schema versioning for migrations
const posts = defineTable(
  type({ id: 'string', title: 'string', published: 'boolean', _v: '1' }),
);

function openBlog(id: string, replicaId: string) {
  // Create a Yjs document with stable GUID for cross-device identification
  const ydoc = new Y.Doc({ guid: id });
  
  // Attach typed tables to the Yjs document
  // This creates CRDT-backed data structures that merge automatically
  const tables = attachTables(ydoc, { posts });
  
  // Persist to browser's IndexedDb for offline availability
  // Returns a promise that resolves when local state is loaded
  const idb = attachIndexedDb(ydoc);
  
  // Open WebSocket collaboration with automatic reconnection
  // waitFor ensures sync only starts after local persistence loads
  const collaboration = openCollaboration(ydoc, {
    url: websocketUrl(`http://localhost:3913/rooms/${ydoc.guid}`),
    waitFor: idb.whenLoaded,
    replicaId,  // Unique identifier for this device instance
  });

  // Return disposable resource for proper cleanup
  return {
    id, ydoc, tables, idb, collaboration,
    [Symbol.dispose]() { ydoc.destroy(); },
  };
}

// Usage: create workspace and insert data
const workspace = openBlog('epicenter.blog', 'browser-dev');
workspace.tables.posts.set({ 
  id: '1', 
  title: 'Hello', 
  published: false, 
  _v: 1 
});

What's happening here: The defineTable call creates a schema-validated CRDT table. attachTables wires it into Yjs's conflict-free merge semantics. attachIndexedDb provides local durability without server dependency. openCollaboration adds network sync with sophisticated offline/reconnect handling via the waitFor pattern. The Symbol.dispose implementation enables deterministic cleanup with JavaScript's explicit resource management proposals.

Example 2: Architecture Boundary Definitions

Epicenter's backend separation demonstrates deliberate architectural thinking. This configuration from the README shows how domain, deployable, and composition boundaries align:

# Domain boundaries separate public protocol roles
accounts.epicenter.so
  OAuth issuer, sign-in, consent, token issuance
  served by apps/server

sync.epicenter.so
  workspace identity, workspace sync, document sync
  served by apps/server

api.epicenter.so
  hosted Cloud APIs, billing, storage registry, dashboard
  served by apps/cloud

The route composition follows:

apps/server
  createAccountsRoutes()   # Authentication concerns
  createSyncRoutes()       # CRDT sync relay

apps/cloud
  createCloudResourceRoutes()  # Hosted value-adds
  createDashboardRoutes()      # Management UI

Why this matters: The self-hostable server (apps/server) remains free of Postgres and billing dependencies. If you want sync without cloud lock-in, deploy just that component. The commercial hosted layer (apps/cloud) adds convenience features without compromising the open core. This is the architectural embodiment of the project's sustainability model.

Example 3: Dependency Flow and Package Composition

The architecture diagram's text representation reveals strict dependency discipline:

                              ┌──────────────────────────────────┐
                              │         @epicenter/api           │
                              │   Cloudflare Workers + DO hub    │
                              │   auth · sync relay · AI chat    │
                              └──────────┬───────────────────────┘
                                         │ y-websocket protocol
                    ┌────────────────────┼──────────────────────┐
                    │                    │                      │
               ┌────▼──────┐      ┌─────▼───────┐      ┌──────▼──────┐
               │ Whispering│      │  Opensidian  │      │ Tab Manager │
               │  (Tauri)  │      │ (SvelteKit)  │      │  (WXT ext)  │
               └────┬──────┘      └─────┬────────┘      └──────┬──────┘
                    │                    │                      │
          ┌─────────┴────────────────────┴──────────────────────┘
          │              All apps share these layers:
          │
    ┌─────▼───────────────────────────────────────────────────────────┐
    │                     MIDDLEWARE / ADAPTERS                        │
    │  @epicenter/svelte    : Svelte integration, auth, persistence   │
    │  @epicenter/filesystem : POSIX file layer over Yjs              │
    │  @epicenter/skills    : skill/reference tables                  │
    │  @epicenter/ai        : LLM tool bridging                      │
    └─────────────────────────────┬───────────────────────────────────┘
                                  │
    ┌──────────────────────────────▼───────────────────────────────────┐
    │                           CORE                                   │
    │  @epicenter/workspace : typed schemas, Yjs CRDTs, extensions,   │
    │                         E2E encryption, lifecycle, materializers │
    │  @epicenter/sync      : protocol encoding/decoding, V2 updates  │
    │  @epicenter/constants : app URLs, versions, shared config       │
    │  @epicenter/ui        : shadcn-svelte component library         │
    │  @epicenter/cli       : TypeBox→yargs CLI, auth/session APIs    │
    └─────────────────────────────────────────────────────────────────┘

The critical insight: Core packages have zero upward dependencies. Middleware only reaches into core. Apps compose both. This means @epicenter/workspace—the gravitational center—can be adopted independently without pulling in Svelte opinions, cloud dependencies, or UI frameworks. For developers building local-first apps in React, Vue, or vanilla JS, the core library remains fully usable.

Advanced Usage & Best Practices

Schema Versioning for Zero-Downtime Migrations

The _v field in table definitions isn't decorative—it's Epicenter's migration mechanism. When schemas evolve, old documents remain readable, and materializers can transform data on access. Plan your _v increments carefully; they're your compatibility contract across app versions.

Replica ID Strategy for Multi-Device Debugging

The replicaId parameter in openCollaboration should uniquely identify device instances, not just devices. Use navigator.userAgent plus timestamp for browsers, machine ID plus process PID for desktop. This prevents sync conflicts when reopening apps after crashes.

Selective Materialization for Performance

Not every table needs SQLite materialization. Read-heavy analytics tables benefit; ephemeral UI state doesn't. The attach* pattern lets you compose only the persistence layers each feature requires, minimizing disk I/O and memory pressure.

Self-Hosted Sync with Custom TLS

When deploying apps/server internally, terminate TLS at your reverse proxy but keep WebSocket connections to the sync endpoint unmodified. The y-websocket protocol expects Upgrade headers intact—intermediate proxies that buffer WebSocket handshakes will break real-time collaboration.

Git Integration for Content Workflows

Because materialized markdown lives in plain text, you can initialize Git repositories in your Epicenter workspace folder. This enables branch-based drafting, pull request review workflows for documentation, and complete audit trails for compliance requirements.

Comparison with Alternatives

The Verdict: Obsidian owns the note-taking niche but lacks native sync encryption and broader app ecosystem ambitions. Notion and Linear optimize for team collaboration at the cost of data ownership. Supabase provides excellent backend infrastructure but requires you to build local-first patterns yourself. Epicenter uniquely combines genuine local-first architecture, cryptographic privacy, open-source extensibility, and multi-app ecosystem coherence in a single project.

Frequently Asked Questions

Is Epicenter production-ready for daily use?

Whispering and Opensidian are actively developed with regular releases. The core @epicenter/workspace library has stabilized its API. As with any open-source ecosystem, evaluate specific apps against your risk tolerance—check release notes and GitHub issues for current status.

How does Epicenter sync differ from Git-based workflows?

Git requires explicit commits, handles binary data poorly, and conflicts require manual resolution. Yjs CRDTs merge automatically in real-time, work with any data structure, and operate continuously without user intervention. Use Git for version history; use Epicenter sync for live collaboration.

Can I use Epicenter packages in my existing React/Vue project?

Absolutely. @epicenter/workspace and @epicenter/sync have zero framework dependencies. The Svelte-specific packages (@epicenter/svelte, @epicenter/ui) are optional convenience layers. Core CRDT functionality works in any JavaScript environment.

What happens if EpicenterHQ shuts down?

Your data remains fully functional locally. The sync server is open source under AGPL; community forks or self-hosted instances continue operating. Unlike proprietary services, there's no single point of corporate failure that can strand your information.

How does the AGPL licensing affect commercial use?

The sync server and protocol (apps/api, packages/sync) are AGPL-3.0, requiring source sharing for hosted modifications. All apps and most packages are MIT—use them freely in proprietary products. This split follows proven models from Yjs, Liveblocks, and Bitwarden.

Does Epicenter work without any internet connection?

Yes—this is the local-first promise. All apps function completely offline with full read/write capability. Sync activates opportunistically when connectivity returns. IndexedDb persistence ensures your data survives browser restarts and app crashes.

How do I contribute to Epicenter development?

Start with the Contributing Guide and join the Discord community. The team particularly welcomes Svelte/TypeScript developers, Rust enthusiasts for Tauri apps, and distributed systems engineers interested in CRDT optimization.

Conclusion

Epicenter represents something rare in modern software: a project that aligns technical architecture with ethical principles. By building local-first, encrypting by default, and open-sourcing everything, it challenges the assumption that convenience requires surrendering control.

The ecosystem is still growing—new apps are in active development, the workspace library is maturing, and the community is expanding. But even now, it offers a credible alternative to cloud-locked tools for developers who refuse to accept surveillance as the price of functionality.

If you've ever felt uneasy about where your notes live, who can read your transcripts, or whether your tools will exist next year, Epicenter deserves your attention. Clone the repo, try Whispering, explore @epicenter/workspace, and decide for yourself whether local-first is a constraint or a liberation.

The future of your data doesn't have to live on someone else's server. Start building with Epicenter today: https://github.com/EpicenterHQ/epicenter