Toolkit for backendless apps

Whip up an app

Jazz gives you data without needing a database — plus auth, permissions, files and multiplayer without needing a backend.

Do everything right from the frontend and ship better apps, faster.

Open source. Self-host or use Jazz Cloud for zero-config magic.

Instant updates

Real-time sync

Multiplayer

File uploads

Social features

Permissions

E2E encryption

Authentication

Get a Jazz app running in minutes.

npx create-jazz-app@latest

> Framework: react
> Auth: passkey
> Project name: _

How it works

Build entire apps using only client-side code

Step1

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

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

class Chat extends CoList.Of(co.ref(Message)) {}

Step2

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

main.tsx
<JazzProvider
  sync={{ peer: "wss://cloud.jazz.tools/?key=you@example.com" }}
>
    {children}
</JazzProvider>

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
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

Powered by the first “flat stack”

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. Or, you haven't even tried because "you're not full-stack".

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 completely app-independent infra, you get to focus on building the app your users want. You'll notice that 90% of the work is now the UI.

The best of all worlds

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.addMember("everyone", "reader");

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

Jazz works with your favorite stack

Browser (vanilla JS)
React
React Native
Vue
Svelte
Node.js

Coming soon

Swift
Rust
Kotlin

More features coming soon

Cursors & carets

Ready-made spatial presence.

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

Two-way sync to your DB

Add Jazz to an existing app.

  • Prisma
  • Drizzle
  • PostgreSQL introspection

Video presence & calls

Stream and record audio & video.

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

CoPlainText & CoRichText

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

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