Language Support
What each language does in a Jazz app, and what it doesn't support yet, compared with TypeScript.Every language works from your app's TypeScript schema and permissions: npx jazz-tools generate
writes each language's typed bindings from them. Your app's main backend runs in TypeScript
(Vercel or your own server).
Rust, Swift, Kotlin and Go are experimental: they are clients of that TypeScript backend. All four can be apps, signed in as one of your users; Rust and Go also run as backend clients, services that act with a machine credential. None of them runs a main backend yet. Each tab lists what that language supports and what it doesn't yet, compared with TypeScript.
Experimental. Rust is a client of your TypeScript main backend's /jazz, in two roles: an
app signed in as one of your users (Config::user, with device accounts or bearer sign-in, and
JazzSession), or a backend client, a service with a machine credential, trusted or scoped, with
for_user on a trusted client. It has queries with includes, select, hops, gathers and unions,
history reads and subscriptions, partial reads (Query::part), branches and drafts, streaming
uploads, mergeable text, permission advice, guests (device accounts), positions in subscription
deltas, and close(timeout). See Rust and
Backend Client.
It doesn't support yet:
- running your app's main backend (serving its
/jazzand publishing its permissions): run it in TypeScript withcreateJazz; - a built-in secure store (keychain) for device keys: the app keeps the key itself;
- cookie sessions renewed in place: a Rust client signs in with a bearer and reconnects with a fresh one;
- the browser-only parts of TypeScript's session: focus and visibility re-checks, cross-tab
sign-out,
clearOnSignOutand the thin-client upgrade.
Experimental. Swift is for macOS and iOS apps: a client of your app, signed in as one of its
users through your TypeScript main backend's /jazz. It has queries with includes, hops, unions
and history reads, writes and uploads, mergeable and serializable transactions, subscriptions
(subscribe and watch), mergeable text (JazzText, with String.Index or NSRange
positions), permission advice (canInsert…), device accounts and bearer sign-in, sessions that
follow who is signed in (JazzApp.session), sync status, disconnect/reconnect,
deleteClientStorage and refused-write reports (mutationErrors). In SwiftUI, JazzRoot is
TypeScript's <JazzProvider>, @JazzAll is useAll, and @Environment(\.jazz) and
@Environment(\.jazzSession) are useDb and useJazzSession. It installs as one package,
garden-co/jazz-swift, with the core prebuilt for macOS and iOS; each release's package is
tested on macOS and an iPhone simulator, with a SwiftUI app UI-tested there. See
Swift.
It doesn't support yet:
- running a backend in Swift (publishing permissions, acting for users) or serving the app's Jazz endpoint: run your backend in TypeScript;
- watchOS, tvOS and visionOS;
- Linux: there's no prebuilt core. Ask on Discord if you need it;
- a SwiftUI
BindingforJazzText; - Keychain (or file) storage for device keys;
- anonymous (guest) users;
- subscribing to history queries;
- parts of large values inside includes,
offsetin an include, andrequiredon reverse relations or optional references; - payload enums, nested rows and other column types the bindings can't type;
- non-finite floats (
NaN, infinities), which read back asnull; - positions in subscription deltas.
Experimental. Kotlin is for apps, on Android and the JVM: a client of your app, signed in as
one of its users through your TypeScript main backend's /jazz. See Kotlin.
It doesn't support yet:
- running a backend in Kotlin: run your backend in TypeScript;
- reading part of a large value inside an include (root queries only);
- guest (anonymous) users;
- nested rows, catalogue enums and transaction-id columns in bindings;
- Kotlin Multiplatform targets other than the JVM and Android;
- non-finite doubles (
NaN, infinities); limitandoffsetwithwatch: use them withall.
Experimental. Go is for apps, and runs as a backend client: a Go program can be a client of
your app, signed in as one of its users, or a service that reads and writes through your
TypeScript main backend's /jazz with a machine credential. See Go and
Backend Client.
It doesn't support yet:
- running your main backend in Go (publishing permissions, serving
/jazz): run it in TypeScript withcreateJazz; - guest (anonymous) users;
- nested rows, catalogue enums and transaction-id columns: Go bindings are refused for apps that declare them;
- non-finite doubles (
NaN,±Inf): Jazz carries them asnull, so a nullablefloatcolumn reads them asnil, and reading a non-nullable one fails with a*jazz.Errorthat names the column.