Build your next app
with sync

Jazz is an open-source framework for building local-first apps, removing 90% of the backend and infrastructure complexity.

Local-first

Multiplayer

File uploads

Social features

Permissions

Sync

E2EE

Instant updates

Step 1schema.ts
export class Message extends CoMap {
  text = co.string;
}

export class Chat extends CoList.Of(
  co.ref(Message)
) {}
Step 2sendMessage.ts
const message = Message.create({
  text: “Hello world!”
}, { owner: ... })

chat.push(message)
Step 3ChatScreen.tsx
const ChatScreen = (id) => {
  const chat = useCoState(Chat, id)

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

Instant sync & UI updates
across devices and users! 🎉

Hard things are easy now.

Ever notice how every stack just reinvents shared state between users and machines?

And far from the simple client-server model, you routinely tackle a mess of moving parts, tech choices and deployment questions.

And your app’s code is all over the place.

Jazz provides a single new abstraction to do the whole job.

It turns the data flow around and gives you mutable local state, solving sync, concurrent editing and permissions under the hood.

All that’s left? What makes your app your app.

Everything you need to ship top-tier apps quickly.

Features that used to take months to build now work out-of-the-box.

Local-first

All data you load or create is persisted locally, so your users can work offline.

When you’re back online, your local changes are synced to the server.

Multiplayer

Share state with other users and get automatic real-time multiplayer.

Use the same primitives to quickly build user presence UI, like cursors.

File uploads

Create & handle structured data and binary streams/blobs the same way.

Jazz Cloud or your own server become both cloud database and blob storage.

Social features

Groups of accounts are first class entities that you can create anywhere.

Building multi-user apps becomes as easy as building the UI for them.

Permissions

Control access to data with role-based permissions, easily defined locally.

Reference data across permission scopes for granular access control.

Sync

Build your app around mutable local state attached to an account.

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

E2EE

All data is end-to-end encrypted and cryptographically signed by default.

So it can't be tampered with and Jazz Cloud only sees encrypted data.

Instant updates

Get instant updates throughout your UI every time you locally mutate data.

Remote changes are synced and applied with minimal latency.

First impressions...

A chat app in 174 lines of code.

tsx
import { StrictMode } from "react";
import { createRoot } from "react-dom/client";
import { createJazzReactApp, DemoAuthBasicUI, useDemoAuth } from "jazz-react";
import { App } from "./app.tsx";
 
const Jazz = createJazzReactApp();
export const { useAccount, useCoState } = Jazz;
 
function JazzAndAuth({ children }: { children: React.ReactNode }) {
  const [auth, state] = useDemoAuth();
 
  return (
    <>
      <Jazz.Provider
        auth={auth}
        peer="wss://cloud.jazz.tools/?key=chat-example-jazz@gcmp.io"
      >
        {children}
      </Jazz.Provider>
      {
        state.state !== "signedIn"
        && <DemoAuthBasicUI appName="Jazz Chat" state={state} />
      }
    </>
  );
}
 
createRoot(document.getElementById("root")!).render(
  <StrictMode>
    <JazzAndAuth>
      <App />
    </JazzAndAuth>
  </StrictMode>
);

result

Jazz Cloud

Serverless sync & storage for Jazz apps

To give you sync and secure collaborative data instantly on a global scale, we're running Jazz Cloud. It works with any Jazz-based app, requires no setup and has straightforward, scale-to-zero pricing.

Jazz Cloud is currently free — and it's set up as the default sync & storage peer in Jazz, letting you start building multi-user apps with persistence right away, no backend needed.

Learn more about Jazz Cloud ->

Collaborative Values

Your new building blocks.

Based on CRDTs and public-key cryptography, CoValues...

  • Can be read & edited like simple local JSON state
  • Can be created anywhere, are automatically synced & persisted
  • Always keep full edit history & author metadata
  • Automatically resolve most conflicts

Bread-and-butter datastructures

CoMap

  • Collaborative key-value map
  • Possible values:
    • Immutable JSON & other CoValues

CoList

  • Collaborative ordered list
  • Possible items:
    • Immutable JSON & other CoValues

CoPlainText & CoRichText Coming soon

  • Collaborative plain-text & rich-text
  • Gracefully prevents most editing conflicts
  • Rendered as markdown, HTML, JSX, etc.

CoStream

  • Collection of independent per-user items streams:
    • Immutable JSON & other CoValues
  • Great for presence, reactions, polls, replies etc.

First-class files & binary data

BinaryCoStream

  • Represents a file or live binary stream
  • Can be referenced and synced like any other CoValue
  • Can easily be converted from/to browser Blobs
  • <input type="file"/> -> BinaryCoStream -> Blob -> BlobURL

ImageDefinition

  • Represents multiple resolutions of the same image
  • Can be progressively loaded, including super fast blur preview & image size info

Secure permissions, authorship & teams

Group

  • A scope where specified accounts have roles (reader/writer/admin).
  • A Group owns CoValues, with access right determined by group roles.
  • Accounts can be added to groups directly or using shareable invite secrets.

Account

  • Represents a single user and their signing/encryption keys.
  • Has a private account root and a public profile
    • Can contain arbitrary app-specific data

Jazz works with your favorite stack

Browser (vanilla JS)
React
React Native
Node.js

Coming soon

Vue
Svelte
Swift
Rust
Kotlin

Auto-sub

Let your UI drive data-syncing.

  • Load and auto-subscribe to deeply nested CoValues with a reactive hook (or callback).
  • Access properties & metadata as plain JSON.
  • Make granular changes with simple mutators.
  • No queries needed, everything loads on-demand:
    profile?.tweets?.map(tweet => tweet?.text)

Cursors & carets

Ready-made spatial presence.

  • 2D canvas cursors Coming soon
  • Text carets Coming soon
  • Element-based focus-presence Coming soon
  • Scroll-based / out-of-bounds helpers Coming soon

Auth Providers

Plug and play different kinds of auth.

  • DemoAuth (for quick multi-user demos)
  • WebAuthN (TouchID/FaceID)
  • Auth0, Clerk & Okta Coming soon
  • NextAuth Coming soon

Two-way sync to your DB

Add Jazz to an existing app.

  • Prisma Coming soon
  • Drizzle Coming soon
  • PostgreSQL introspection Coming soon

File upload & download

Just use <input type='file'/>.

  • Easily convert from and to Browser Blobs
  • Super simple progressive image loading

Video presence & calls

Stream and record audio & video.

  • Automatic WebRTC connections between Group members Coming soon
  • Audio/video recording into BinaryCoStreams Coming soon

Become an early adopter

We'll help you build your next app with Jazz

It's early days, but we work hard every day to make Jazz a great tool for our users.

We want to hear about what you're building, so we can help you every step of the way. We'll prioritize features that you need to succeed.

Let's talk on DiscordRead docs