The database that syncs.

Things are easy when data syncs anywhere, instantly.

Jazz is a distributed database that runs across your frontend, containers, functions, and our global auto-scaling storage cloud.

Efficiently sync data, files and LLM streams. Use them like reactive local JSON state.

npx create-jazz-app@latest

Open source (MIT) and self-hostable.

setup.tsx
import { co, z } from "jazz-tools";
import { JazzReactProvider }
  from "jazz-tools/react";

// Describe your app with cloud-synced CoValues ("collaborative values")
const Message = co.map({
  text: z.string(),
});

const Chat = co.list(Message);

// Use our global auto-scaling
// Jazz Cloud or self-host
const peer =
  "wss://cloud.jazz.tools/?key=...";

function App() {
  return (
    <JazzReactProvider sync={{ peer }}>
      ...
    </JazzReactProvider>
  );
}
Components.tsx
import { useCoState }
  from "jazz-tools/react";

function MessageList({ id }) {
  // Load & sync CoValues
  // Rerenders on local & remote edits!
  const chat = useCoState(Chat, id, {
    // Granular load of nested CoValues
    resolve: { $each: true }
  });

  return chat.$isLoaded ? <div>
    {chat.map(msg => (   // Looks like
      <p>{msg.text}</p>  // plain JSON
    ))}
    <TextInput onSubmit={(text) => {
      // Create and edit data anywhere!
      // Locally stored & synced
      chat.$jazz.push(Message.create(
        { text }, chat.$jazz.owner
      ));
    }} />
  </div> : <div>Loading...</div>;
}
14:51
14:51

Add your device to the live demo. Messages update everywhere instantly.

A database that does what's actually needed

A perspective shift worth 10,000 hours

Every stack is a re-invention of shared state.

For each new app you tackle a mess of moving parts and infra worries. Your backend is responsible for shuffling data around in a myriad of ways.

Want to build a modern app with multiplayer or offline-support? Figma, Notion and Linear all had to spend years on completely custom stacks.

What if we started from shared state?

Jazz gives you local state that’s instantly synced and stored in the cloud. Including images and files. With users & permissions built-in.

With a DB and infra made for modern apps you get to focus on building the app your users want. You'll notice that 90% of the work is now the UI.

Offline-first

Your app works seamlessly offline or on sketchy connections. When you're back online, your data is synced.

Instant updates

Since you're working with local state, your UI updates instantly. Just mutate data. No API calls and spinners.

Real-Time Sync & Multiplayer

All devices and users stay perfectly in sync. Share data to enable live collaboration and presence UI like cursors.

Private by Design

Encrypted and signed on your device. Invisible to servers, verifiable by anyone.

Everything else you need to ship quickly

We take care of the groundwork that every app needs, so you can focus on building the cool stuff that makes your app unique.

co.fileStream().createFromBlob(file);
file.pdf

File uploads

Just use <input type="file"/>, and easily convert from and to Browser Blobs using a FileStream CoValue.