Build absurdly fast web applications with Zero

Instant Queries by Default

Gigabugs – Our 1.2 million row bug tracker.

Sync engines enable instant UI by downloading data to the client ahead of time. Reads and writes happen locally, and changes are synced in the background.

It's a beautiful idea, and one that has been used by some of the world's best software: Linear, Figma, Superhuman, and Dropbox were all built this way.

But there's a catch. And this catch is the reason why sync-based apps are still rare.

Apps usually have far too much data to download up-front. They also have complex permissions. Incrementally syncing a static block of data is easy; syncing just the slice the user wants and has access to is much more difficult.

We created Zero to solve these problems in a general way, and to bring the performance of sync to the entire web.

Try it out right now.

Our Gigabugs demo has 1.2 million rows, instant interactions, and loads in less than 2 seconds.

How it Works

Zero has two parts: zero-client and zero-cache.

Zero-cache runs in the cloud and maintains a read-only replica of your Postgres database. Zero-client gets linked into your app and maintains a client-side store of recently used rows.

Queries run against the client first, returning matching results instantly. In parallel, queries are sent to the server, which returns authoritative results asynchronously.

Server results are automatically stored client-side, so that future queries can be answered instantly.

import {queries} from 'queries.ts'
import {mutators} from 'mutators.ts'
 
function Playlist({id}: {id: string}) {
  // This usually resolves *instantly*, and updates reactively
  // as server data changes. Just wire it directly to your UI –
  // no HTTP APIs, no state management, no realtime goop.
  const [playlist] = useQuery(
    queries.playlist.byID({id})
  )
 
  const onStar = (id: string, starred: boolean) => {
    mutators.playlist.star({id, starred})
  }
 
  // render playlist...
}

Efficient incremental execution of complex queries is made possible by ZQL, a new streaming query engine we built specifically for Zero.

This architecture lets you sync exactly the data you need, when you need it — enabling instant UI without preloading the universe.

Features

Instant Reads

Queries are always client-first, returning matching local data immediately – literally in the next frame.

Instant Writes

Mutations are always client-first, updating all open queries instantly. Edge-cases like reverts are handled automatically.

Automatic Reactivity

All queries are reactive. When data changes on the server – even from non-Zero clients – affected queries are automatically updated.

Fast Startup

Query-driven sync provides precise control over when data is synced, enabling fast startup without sacrificing instant interactions.

Server Authority

All reads and writes flow through your code on your server, giving you complete control over permissions and business logic.

Easy Integration

Zero works with normal Postgres databases, using normal Postgres schemas, with normal APIs and libraries.

From Our Users

Zero is a game changer. You will be shocked at how fast it is.

Scott Tolinski

Co-host of Syntax.fm

Have been building with Zero for months. It's making me hate my older codebases.

Dax Raad

OpenCode, SST.dev

We rebuilt Productlane from the ground up to make the fastest customer support tool out there. Huge shoutout to Zero for making this possible!

Raphael Fleckenstein

CEO, Productlane.com

One of my favorite features is custom mutators. I can run validation logic instantly on the client for fast UX, and optionally do additional validation on the server for security or performance.