Reactive, distributed, secure

Smooth database.

Jazz is a new kind of database that's distributed across your frontend, containers, serverless functions and its own storage cloud.

It syncs structured data, files and LLM streams instantly.
It looks like local reactive JSON state.

And you get auth, orgs & teams, real-time multiplayer, edit histories, permissions, E2E encryption and offline-support out of the box.

This lets you get rid of 90% of the traditional backend, and most of your frontend state juggling. You'll ship better apps, faster.

Self-host or use Jazz Cloud for a zero-deploy globally-scaled DB.
Open source (MIT)

npx create-jazz-app@latest

Build apps with

JavaScript React React Native Expo Svelte

Optionally add server workers

Node.js

Bun

Vercel

CF Workers

How it works

Build entire apps with collaborative state

Step1

Describe your app’s state with CoValues ("collaborative values"), your new cloud-synced building blocks.

schema.ts

import { co, z } from "jazz-tools";

const Message = co.map({
  text: z.string(),
});

const Chat = co.list(Message);

Step2

Connect to sync and storage infrastructure — Jazz Cloud or self-hosted.

main.tsx

<JazzReactProvider
  sync={{ peer: "wss://cloud.jazz.tools" }}
>
  {children}
</JazzReactProvider>

Step3

Create and edit CoValues, and they will be synced and persisted automatically.

sendMessage.ts

const message = Message.create({
  text: “Hello world!”
}, chat._owner);

chat.push(message);

Step4

Use CoValues like reactive local state. Get instant UI updates on every edit — across all devices and users. 🎉

ChatScreen.tsx

import { useCoState } from "jazz-tools/react";

const ChatScreen = ({ id }) => {
  const chat = useCoState(Chat, id);

  return chat.messages.map(msg => (
    <p>{msg.text}</p>
  ));
}

You don't have to think about deploying a database, SQL schemas, relations, and writing queries… Basically, if you know TypeScript, you know Jazz, and you can ship an app. It's just so nice!

Spreadsheet app (stealth)

CTO

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.

Local-first state with global sync

With cloud-synced local state, your data is kept on-device, and synced whenever possible.

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

Every device with the same account will always have everything in sync.

Multiplayer

Adding multiplayer is as easy as sharing synced data with other users. Quickly build user presence UI, like cursors.

Role-based permissions

Making secure collaboration the default

Every CoValue belongs to a Group, where you can assign roles to users to control access — all from the client.

Private

By default, CoValues are visible only to you.

Message.create({
  text: "Private message to myself."
});

Shared

Use Groups for precise access control.

const group = Group.create();
group.addMember(Alice, "writer");
group.makePublic();

Message.create({ text: "..." }, group);

By Invitation

Create links that allow anyone to join.

// links to message, Group is inferred
createInviteLink(
  messageId,
  "writer", // role that recipient gets
);

End-to-end encrypted and tamper-proof

The syncing server never sees your data in plaintext. Instead of trusting centralised authorisation, Jazz uses public-key cryptography. Your edits are encrypted and signed on-device, verifiable by everyone and readable only by those given access.

We just wanted to build a single-player experience first, planning to add team and org features much later. But because of Jazz, we had that from day one. All we needed to add was an invite button.

Invoice Radar

Technical Founder

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.

BinaryCoStream.createFromBlob(file);

file.pdf

File uploads

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

400x300

Progressive image loading

Using Jazz's ImageDefinition component, you get progressive image up & downloading, super fast blur preview, and image size info.

Server workers

Expose an HTTP API that mutates Jazz state. Or subscribe to Jazz state and update existing databases or third-party APIs.

Authentication

Plug and play different kinds of auth like Passkeys (Touch ID, Face ID), and Clerk. Auth0, Okta, NextAuth coming soon.

Jazz Cloud

Jazz Cloud is real-time sync and storage infrastructure that scales your Jazz app up to millions of users. Instant setup, no config.

View free tier & pricing

or self-host.

Data & blob storage
Global sync
No limits for public alpha

Get started

Let's build your next app together

Whether you're building something big with Jazz or just trying things out, we've got a team of developers who have seen and built everything.

We're happy to help you hands-on with your app, and ready to tailor Jazz features to your needs.

Read docs Join Discord