TinyBase is a reactive data store and sync engine for local-first apps that fits in 6.2 kB and ships with native CRDTs, schemas, indexes and ready-made React and Svelte components. We rate it 87/100 — if you are building an offline-first or local-first JavaScript app and don't want to bolt together SQLite, a sync layer and a state library yourself, TinyBase is the most batteries-included option in the entire local-first ecosystem.

What is TinyBase?

TinyBase is an open-source JavaScript library, MIT-licensed, written by James Pearce (formerly of Meta and Facebook) under the tinyplex organisation. The first commit landed on December 31, 2021, and the project just shipped version 8.2 on May 6, 2026 — "the one with Svelte components." It now sits at over 5,000 stars on GitHub with the test suite at 100% coverage, which is unusual for a library this ambitious.

Where competing local-first stacks make you assemble pieces — a database, a reactive query layer, a CRDT engine, a sync server, UI bindings — TinyBase ships all of that as one library. You start with a 6.2 kB key-value store, layer on tabular data when you need it, snap on schemas, indexes, relationships, an undo stack, and finally turn the whole thing into a CRDT-backed multi-device sync engine without touching another package.

TinyBase pre-built React DOM components rendering a tabular store — TinyBase ships pre-built React DOM components so a fully editable, reactive table is roughly six lines of JSX.

Key Features of TinyBase

Reactive data model: A typed key-value Store or a tabular Tables model with row/column-level listeners — only the components touching changed cells re-render.
Native CRDT sync (v5+): The MergeableStore type is a built-in CRDT. Merge clients deterministically over WebSockets, the browser BroadcastChannel, or a custom transport — no Yjs or Automerge required, but you can plug them in if you prefer.
Persistence everywhere: Out-of-the-box persisters for IndexedDB, localStorage, SQLite (browser and server), PGLite, PostgreSQL, Expo SQLite, Cloudflare Durable Objects, PartyKit, Electric, Turso, PowerSync and the filesystem.
UI bindings: First-class tinybase/ui-react hooks plus ui-react-dom drop-in components (table viewers, inspectors), and as of v8.2 a full Svelte components package.
Schemas, indexes, relationships, metrics: Add type-safe schemas, secondary indexes for fast lookups, foreign-key style relationships, and aggregation modules — each one a separately tree-shakable submodule so you only ship what you use.
Undo/redo built in: The Checkpoints module turns any store into an undoable timeline with one line of setup.
Tiny by design: The core is 6.2 kB minified-and-gzipped; the maximalist build with every module is 13.2 kB. No runtime dependencies.

TinyBase Inspector showing live store contents in a side panel — The TinyBase Inspector mounts as a React component and shows every cell, value and listener in real time — useful for debugging reactive flows.

What Users Say About TinyBase

Sentiment on Hacker News across the v2, v5 and v8 release threads is consistently positive but with one recurring caveat. The most-upvoted comments call out two things: that TinyBase is one of the few local-first libraries with proper relational semantics (schemas, indexes, foreign keys) instead of the schemaless key-value approach taken by Yjs and Automerge, and that the bundle-size discipline is unusual — people repeatedly note the whole library is smaller than a single Lottie animation. The recurring complaint is that the surface area is now genuinely large: between Stores, MergeableStores, dozens of persisters, multiple UI binding packages and the new Synclets project, the docs are deep enough that newcomers say it took "a weekend" to internalise the mental model. A second, smaller complaint is that the API uses positional get(tableId, rowId, cellId) calls rather than chainable accessors — readable but verbose.

On the Local-First Landscape directory and in James Pearce's own talks, TinyBase is now treated as one of the canonical references in the space alongside ElectricSQL and Replicache. Adopters listed publicly include Expo, Primodium and Learn Anything.

TinyBase Pricing

TinyBase is fully free and open source under the MIT license. There is no hosted product, no paid tier, no telemetry and no sign-up. You install it from npm and you own everything — including the storage and sync infrastructure you point it at.

Plan	Price	What's Included
Open Source (MIT)	$0	Every module: Store, MergeableStore, persisters, UI bindings, Inspector, schemas, indexes, metrics, queries, checkpoints, sync.

Who Should Use TinyBase?

Best for: JavaScript and TypeScript developers building local-first apps — offline-capable note-takers, drawing tools, todo apps, side-project games, Expo and React Native apps that need a real database with sync. Solo devs and small teams will get the most leverage because TinyBase replaces three or four packages with one.

Not ideal for: Backends that need a server-side relational database with concurrent writes from many tenants — pick PostgreSQL or ClickHouse for that. Also overkill for trivial UI state where tRPC + Zustand or Jotai already do the job.

Pros and Cons

Pros:

Genuinely tiny (6.2 kB core) with zero runtime dependencies.
Native CRDT sync without forcing you onto Yjs or Automerge.
Relational features (schemas, indexes, relationships) that other CRDT libraries lack.
Persisters for nearly every realistic backend — IndexedDB through PostgreSQL.
One author, one repo, MIT license — no SaaS lock-in.

Cons:

Steep concept ramp: Store vs MergeableStore vs Indexes vs Metrics vs Queries is a lot of vocabulary.
Verbose positional API (setCell('pets', 'fido', 'species', 'dog')) reads cleanly but takes effort to type.
Bus-factor concern: while contributions are growing, the core is still mostly James Pearce.

Alternatives to TinyBase

The closest alternatives are Yjs (mature CRDT but schemaless, requires you to build the data model yourself), Automerge (similar trade-off, document-oriented), Replicache (commercial, server-required), and ElectricSQL (Postgres-backed sync, heavier to deploy). TinyBase is the only one that gives you a relational data model, a CRDT, persistence, and React/Svelte components in a single MIT package.

Verdict: Is TinyBase Worth It?

If you are shipping a local-first app in 2026 and you have ever found yourself stitching Dexie + Yjs + a custom sync server + a state library together, TinyBase deletes most of that diagram. It earns 87/100 because the engineering quality is exceptional — full type safety, 100% test coverage, 6.2 kB, MIT — but the learning curve and verbose API keep it from a higher score. For solo developers and small teams building offline-capable apps, it is the most pragmatic choice in the local-first landscape today.

Frequently Asked Questions

Is TinyBase free?: Yes. TinyBase is 100% free and open source under the MIT license. There is no paid tier and no hosted service — you install it from npm and run it yourself.
What platforms does TinyBase support?: Anywhere JavaScript runs: web browsers, Node.js, Bun, Deno, React Native, Expo, Cloudflare Workers and Durable Objects. Persisters cover IndexedDB, SQLite, PGLite, PostgreSQL, Turso, PowerSync, PartyKit, Electric, Yjs and Automerge.
How does TinyBase compare to Yjs and Automerge?: Yjs and Automerge are pure CRDT libraries with no opinion on schemas, indexes or queries. TinyBase ships its own CRDT (MergeableStore) plus a relational data model, indexes, metrics, UI bindings and persisters. You can also use Yjs or Automerge as a persister inside TinyBase if you want both worlds.
Is TinyBase open source?: Yes — MIT-licensed on GitHub at tinyplex/tinybase. The full source, tests, docs and demos are public.
How big is TinyBase?: The minimum bundle (key-value Store only) is 6.2 kB minified and gzipped. Including every module — tabular store, indexes, metrics, queries, checkpoints, persisters, UI bindings — the maximum is 13.2 kB.

#crdt

TinyBase