Local-first development toolkit

Ship top-tier apps at high tempo.

Jazz is a framework for building local-first apps — an architecture that lets companies like Figma and Linear play in a league of their own.

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

Hard things are easy now.

The sad truth is...

Every stack reinvents how users and machines share state.

For each new app you tackle a mess of moving parts, tech choices & deployment woes. Your code? All over the place.

It’s holding you back from shipping what your app could be.

The good news is...

There’s a single new abstraction that does the whole job.

Jazz gives you mutable local state that’s instantly synced. Including binary blobs. With users & permissions built-in.

All that’s left is building the UX that makes your app special.

Collaborative Values

Build entire apps using only client-side code

Step1

Define your schema using Collaborative Values — your new building blocks.

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

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

Step2

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

main.tsx
const Jazz = createJazzReactApp();

<Jazz.Provider
  peer="wss://cloud.jazz.tools/?key=you@example.com"
>
    {children}
</Jazz.Provider>

Step3

Create a Collaborative Value, and it will be synced and persisted automatically.

sendMessage.ts
const message = Message.create({
  text: “Hello world!”
}, { owner: ... })

chat.push(message)

Step4

Read your data like simple local state. Get instant sync and UI updates 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

Why local-first?

With local-first, your data is stored locally, then synced to the server.
This comes with the following benefits.

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 piece of data is assigned a role-based permission on creation — reader, writer, or admin. These permissions are defined in an Account or Group.

Private

Create a CoValue visible only to you by assigning your Account as an owner.

const { me } = useAccount();

Message.create(
  { text: ... },
  { owner: me }
);

Public

Start collaborating by giving write access to everyone.

const group = Group.create({
  owner: me
});

group.addMember("everyone", "writer");

Chat.create([], { owner: group })

Invite-only

Generate an invite link, and share only with people you want to collaborate with.

createInviteLink(
  chatId,
  "writer", // or reader or admin
);

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
Node.js

Coming soon

Svelte
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