Comparison to Alternatives

How Gluonic compares to other sync engines and data solutions.

Quick Comparison

Detailed Comparisons

vs InstantDB

InstantDB Strengths:

• ✅ Simpler setup (~10 lines)
• ✅ Cloud-hosted (zero infrastructure)
• ✅ Beautiful dev experience

Gluonic Advantages:

• ✅ Self-hosted (full control)
• ✅ Database-agnostic (use any database)
• ✅ React Native support (InstantDB is web-only)
• ✅ Advanced production features (worker coordination, backpressure)

Best For:

• InstantDB: Web apps, rapid prototyping, don’t want to manage infrastructure
• Gluonic: Mobile apps, self-hosted requirements, existing database

vs Convex

Convex Strengths:

• ✅ Extremely simple (~15 lines)
• ✅ Built-in backend functions
• ✅ Reactive queries
• ✅ Cloud-hosted

Gluonic Advantages:

• ✅ Self-hosted (Convex is cloud-only)
• ✅ Database-agnostic (Convex uses proprietary DB)
• ✅ Use existing backend (Convex replaces it)
• ✅ More control over infrastructure

Best For:

• Convex: Greenfield projects, want managed infrastructure, full-stack in one
• Gluonic: Existing backend, self-hosted requirements, database flexibility

vs Replicache

Replicache Strengths:

• ✅ Mature and battle-tested
• ✅ Flexible architecture
• ✅ Self-hosted
• ✅ Database-agnostic

Gluonic Advantages:

• ✅ Much easier setup (35 lines vs 100+)
• ✅ Batteries-included mutations (Replicache needs manual implementation)
• ✅ React Native first-class (Replicache is web-focused)
• ✅ Better documentation
• ✅ Advanced features built-in (worker coordination, streaming bootstrap)

Best For:

• Replicache: Web apps, need maximum control, willing to write more code
• Gluonic: Mobile apps, want simplicity + control, comprehensive solution

vs PowerSync

PowerSync Strengths:

• ✅ Built for mobile (React Native, Flutter)
• ✅ Good Postgres integration
• ✅ Commercial support

Gluonic Advantages:

• ✅ Fully self-hosted (PowerSync requires their cloud for some features)
• ✅ Database-agnostic (PowerSync tied to Postgres/SQLite)
• ✅ Universal client (Web + RN from same code)
• ✅ Simpler setup
• ✅ Open source with no cloud dependency

Best For:

• PowerSync: PostgreSQL-based mobile apps, want commercial support
• Gluonic: Any database, full self-hosting, universal React

vs WatermelonDB

WatermelonDB Strengths:

• ✅ Optimized for React Native
• ✅ Good SQLite performance
• ✅ Mature

Gluonic Advantages:

• ✅ Universal (WatermelonDB is RN-only)
• ✅ Type-safe decorators (WatermelonDB has partial typing)
• ✅ Built-in sync (WatermelonDB sync is manual)
• ✅ Reactive by default (WatermelonDB needs withObservables HOC)
• ✅ Better DX (cleaner API)

Best For:

• WatermelonDB: React Native only, maximum SQLite performance
• Gluonic: Universal React, better DX, built-in sync

Feature Comparison

Setup Complexity

// Gluonic (35 lines)
const adapter = PrismaAdapter({ prisma, autoDiscover: { enabled: true } })
await registerSyncRoutes(app, { adapter, auth })
const { store } = SyncClient({ server, storage, auth, models })
 
// InstantDB (10 lines)
const db = init({ appId: 'xxx', apiUrl: 'xxx' })
const { data } = db.useQuery({ posts: {} })
 
// Convex (15 lines)
const convex = new ConvexReactClient(process.env.CONVEX_URL)
const posts = useQuery(api.posts.list)
 
// Replicache (100 lines)
// - Implement mutators (30 lines)
// - Implement puller (40 lines)
// - Implement pusher (30 lines)
// - Wire up auth, storage, etc.

Architecture Control

Real-World Performance

Tested with 10,000 records:

Unique Gluonic Features

Features no other sync engine has:

1. Universal Client

Only sync engine with single codebase for React Native + Web:

// Same code works everywhere
const { store, GraphProvider } = SyncClient({ ... })
 
// React Native (iOS/Android) ✓
// Web (Vite/Webpack) ✓
// Electron ✓
// Any React environment ✓

Competitors:

• InstantDB: Web only
• Convex: Separate mobile implementation
• Replicache: Web only
• PowerSync: Mobile only

2. Worker Coordination

Multi-pod snapshot generation with consistent hashing:

// Multiple server pods collaborate on snapshot generation
// No duplicate work, auto-rebalancing
// No other sync engine has this!

3. Streaming Bootstrap

Memory-safe handling of massive datasets:

// Stream bootstrap without materializing in memory
bootstrapStream: async function* (orgId) {
  for await (const row of streamFromDB(orgId)) {
    yield row  // Stream directly to client
  }
}
 
// Handles 1M+ records without OOM

4. Deferred Persistence

Clean separation of optimistic vs confirmed data:

• Pool: Current state (optimistic + confirmed)
• Queue: Pending changes
• Storage: Confirmed only

Benefit: Simple rollback, clean state, queue replay works perfectly.

Migration Guide

From Apollo Client

// Before (Apollo)
const { data, loading } = useQuery(GET_POSTS)
const [updatePost] = useMutation(UPDATE_POST)
 
// After (Gluonic)
const posts = useCollectionModels<Post>('post')
await store.save('post', id, { title: 'New' })
 
// Benefits:
// - Offline support ✓
// - Optimistic updates built-in ✓
// - Simpler API ✓

From Redux + RTK Query

// Before (Redux)
const posts = useSelector(selectPosts)
const dispatch = useDispatch()
dispatch(updatePost({ id, title }))
 
// After (Gluonic)
const posts = useCollectionModels<Post>('post')
await store.save('post', id, { title })
 
// Benefits:
// - No reducers, actions, selectors ✓
// - Offline support ✓
// - Real-time sync ✓

From WatermelonDB

// Before (WatermelonDB)
const posts = useDatabase().collections.get('posts').query().observe()
 
// After (Gluonic)
const posts = useCollectionModels<Post>('post')
 
// Benefits:
// - Type-safe ✓
// - Universal (Web + RN) ✓
// - Simpler API ✓

Pricing Comparison

When to Choose Gluonic

✅ Choose Gluonic If:

• Building mobile app (React Native)
• Need offline support
• Want self-hosted infrastructure
• Have existing database
• Need database flexibility
• Want universal React support (RN + Web)
• Need advanced production features
• Open source is important

⚠️ Consider Alternatives If:

• Web-only app with no offline needs → Use Apollo/React Query
• Want zero infrastructure → Use InstantDB/Convex
• Need managed hosting → Use Convex/PowerSync
• Maximum simplicity over control → Use InstantDB
• Want backend functions included → Use Convex

Next Steps

• Quick Start - Try Gluonic in 5 minutes
• Learn Concepts - Understand core ideas
• See Examples - Working code samples