I Shipped...

I fixed a crash in the Jazz MCP server that happened on Node.js versions older than 22. The crash was caused by the text-search fallback accidentally importing node:sqlite — a database built-in that doesn’t exist in older Node versions — before it even had a chance to activate. I extracted the SQLite-free parsing helpers into a new standalone file so the fallback module’s dependency chain never touches the database code.

When you install Jazz using pnpm, it creates a symlink (a shortcut) pointing to the actual CLI program. The CLI checks whether it’s the entry point by comparing file paths, but the symlinked path and the real path are different strings, so it thought it wasn’t the entry point and quietly exited without doing anything — making schema pushes and migrations appear to succeed while actually no-oping. I fixed it by resolving both paths to their real locations before comparing them, so the CLI now dispatches correctly whether called directly or through pnpm’s symlinks.

I added a new example app showing how to build a local-first todo list using Vue 3 and Jazz. It mirrors the existing React, Svelte, and TypeScript examples, so Vue developers now have a reference starting point too. The example also includes browser-based integration tests using Vitest.

Node.js 20 reached end-of-life, meaning it no longer receives security updates. I bumped the minimum required Node.js version to 22.12 and took the opportunity to clean up backwards-compatibility workarounds scattered across 19 files that only existed to support older Node versions.

The Jazz starter templates had a lot of repetitive boilerplate for setting up authentication. I updated the SvelteKit, React, and Next.js starters to use the new LocalFirstAuth reactive class and framework-specific hooks, which means cleaner code and auth state that automatically rebuilds when something changes — no manual page reload needed.

Jazz already had a React hook for LocalFirstAuth — a way to handle user login in local-first apps (apps that work offline and sync data in the background). I added matching reactive integrations for Svelte and Vue, so developers using those frameworks can use LocalFirstAuth without having to wire up their own reactivity. I also fixed a crash that occurred when the module was imported on the server side, and made sign-out properly propagate across all open tabs.

I added a link to the Jazz Dashboard in the top navigation bar of the docs site, alongside the existing Blog and Docs links. It opens in a new tab and makes it easier for users to jump between the documentation and the dashboard without having to hunt for the URL.

I replaced a static diagram on the “how sync works” docs page with an animated SVG that shows how writes flow between global sync servers, edge servers, and local clients in real time. To keep things readable, I made each writer get a randomly generated color that’s always different enough from its previous color. I also refactored the diagram building blocks into a shared module so future diagrams can reuse the same code.

When you use hopTo() to jump from one table to a related table in a Jazz query, TypeScript was wrongly inferring that the result still had the type of the original table instead of the destination. I fixed this by properly threading the destination table’s type information through the hopTo method, so now TypeScript correctly knows the shape of the data you’re working with after the hop. The runtime behaviour was already correct — this was a purely type-level fix.

Several Jazz example apps had accumulated inconsistencies: some still used Playwright for testing while others had moved to Vitest browser mode, and their docs and feature sets had drifted out of sync. I migrated the remaining auth examples to Vitest browser mode and fixed the various inconsistencies to bring the examples back to parity.

When you subscribed to Jazz data with deeply nested relationships — like posts that include authors that include teams — changes more than one level deep wouldn’t trigger a UI update. The subscription system only registered top-level tables as dependencies and missed the deeper ones. I fixed the graph compilation step to walk all nesting levels and register every nested table, so deep mutations correctly invalidate subscriptions.

Two separate regressions had quietly broken the browser benchmark tests so they weren’t running in CI at all. A recent refactor changed how database insert results are structured, breaking the seed step, and a separate issue prevented the test files from being discovered. I fixed both problems so the benchmark suite runs correctly again.

The world-tour example app used a third-party map library to display a globe, which was a heavy external dependency. I replaced it with a hand-rolled canvas-based dot globe made from 50,000 Fibonacci sphere points, dropped the dependency entirely, added the example to the monorepo workspace, and included Jazz+Vue integration tests alongside it.

Adding the Jazz SvelteKit plugin to vite.config.ts with TypeScript strict mode enabled would fail to compile because the plugin’s ssr.external option was typed as string[], but Vite’s actual type is true | string[]. I widened the type to match what Vite expects, so it compiles cleanly under strict mode.

The Jazz docs blog didn’t have an RSS feed, so there was no easy way for people to subscribe and be notified of new posts. I added an RSS 2.0 feed at /rss.xml built from all blog posts sorted newest-first, and registered it in the site layout so browsers and feed readers can auto-discover it.

AI coding assistants work better with plain text than with HTML. I added a proxy to the Jazz docs site that serves any page as clean markdown when a request includes an Accept: text/markdown header or a .md suffix in the URL, making it easy for AI agents to read the docs directly.

Jazz’s starter templates were all React-based, making it hard to see how Jazz works without a UI framework in the way. I added three new TypeScript-only starters (ts-localfirst, ts-hybrid, and ts-betterauth) that use plain DOM manipulation inside Jazz subscription callbacks, so the core API is front and centre.

The Jazz Expo integration included three polyfills (bits of code that patch in missing browser features) for standard web networking types — but these were actually harmful. If they ran before React Native had set up its own network globals, they’d overwrite those globals with undefined, breaking third-party libraries like Clerk. I removed the three useless polyfills while keeping the two that do real work.

Jazz uses “lenses” to handle schema migrations — they define how old data gets transformed when you change your data model. I added an animated, interactive diagram to the documentation that visualises how data moves through the lens chain, making the concept much easier to grasp than text alone.

The Expo (React Native) integration for Jazz included a custom fetch polyfill that swapped out the built-in network library for one from expo/fetch. It was originally added to support reading response bodies as streams, but Jazz never actually does that — all fetch calls just grab the whole response at once with .json() or .text(), and real-time sync runs over WebSockets anyway. I removed the polyfill entirely, simplifying the code and preventing potential conflicts with third-party libraries that also try to override the global fetch.

The jazz-rn library was running database queries by blocking the JavaScript thread, which froze the UI during any database access and could also cause deadlocks when the server needed to respond before a query could complete. I converted the query function to be async, so it runs off the JavaScript thread and returns a Promise, keeping the app responsive while waiting for data.

During Jazz development, whenever you pushed a new schema, you had to manually refresh the browser to pick up the changes. I added a mechanism where the Jazz Webpack/Turbopack plugin writes a small “schema hash” file to a cache directory on every schema push, and the React provider imports this file during development — so the bundler notices the change and automatically reloads the page for you.

The create-jazz tool, which scaffolds new Jazz projects, had a hardcoded reference to the old repo name garden-co/jazz2. After the repo was renamed back to garden-co/jazz, I updated that one-line constant so the scaffolding tool points to the right place.

The chat-react example app had two separate test setups running in parallel — one using Playwright and one using vitest browser mode. I consolidated them by moving the Playwright end-to-end test into the main vitest browser test suite and deleting the now-redundant Playwright config. I also cleaned up some leftover React act() wrapper calls that were printing noisy warnings without actually doing anything useful.

Jazz lets users start as anonymous “local-first” users and later upgrade to a full account. On React Native, this upgrade was broken with the error “Sign up requires an active Jazz session” because the identity proof method was trying to use a WebAssembly module — which React Native doesn’t support. I overrode the method in the React Native implementation to use the native mintLocalFirstToken function from jazz-rn instead, making the upgrade flow work on iOS and Android.

The docs for setting up a Jazz client had Vue and Svelte code examples missing await before createJazzClient, which returns a Promise — so copying the example would store a pending Promise instead of the actual client. I fixed those snippets and added a new section explaining how browsers can silently delete locally-stored data (called “storage eviction”) and how to call navigator.storage.persist() to ask the browser to keep your data safe.

When you change your database schema (a “migration”), existing data should stay visible under the new schema. There was a bug where rows that existed before a migration would silently disappear — the resolved table name wasn’t being carried through to the query engine, causing a “table not found” error that just dropped the rows silently. I fixed this by making sure the resolved table name is passed all the way through the schema-aware query path.

On Expo (React Native), Jazz uses a custom fetch wrapper that bridges web-style network calls to the native layer. The web fetch standard allows passing a URL or Request object as input, but the native bridge only accepts plain strings — so libraries like better-auth that use this pattern were crashing. I fixed it by normalising those inputs to a plain string URL plus options before passing them to the native bridge.

When developing with Jazz in watch mode, editing schema.ts now automatically reloads the browser to pick up your changes. Previously you had to manually refresh the page after pushing a schema update to see it take effect. I added a callback that fires after a successful schema push and tells the Vite or SvelteKit dev server to send a full-reload signal to the browser.

The create-jazz setup tool got two improvements. The spinner now advances to “Provisioning Jazz Cloud app” before making the network request, so it no longer looks frozen on the previous step. I also added support for loading .env files so CLI commands like deploy can pick up secrets like JAZZ_ADMIN_SECRET from a .env file instead of requiring them to be set as shell environment variables.

I added content-based deduplication to the permissions bundle publishing step. When you deploy without changing your schema’s access rules, the system now detects that the new bundle is identical to the current one and skips creating a new version — preventing unnecessary version bumps.

I fixed broken configuration and authentication in several of Jazz’s example applications. The affected apps — including WorkOS auth, Better Auth, Next.js CSR/SSR, Cloudflare Workers, and managed runtime — had issues that stopped developers from using them as working references.

I fixed a bug where Jazz’s SvelteKit plugin didn’t apply its configuration correctly the very first time you started the dev server. The plugin now restarts Vite once after allocating the app ID, so SvelteKit’s server hooks pick up the config properly.

I fixed a race condition in the React chat example where the message input would become usable before the server had confirmed the user was a member of the chat room. I added a readiness check to prevent this, and wrote a Playwright end-to-end test to guard against it happening again.

I reorganised Jazz’s “recipes” (short how-to guides) into clearer sub-folders — access control, auth, and data patterns — so they’re easier to find. I also added a new recipe showing how to configure group-level permissions for shared data.

I extended our automated tests to cover three starter templates that previously had no test coverage. The tests check that the scaffolding tool creates the right files and structure, so we can catch regressions before they reach developers.

I updated the Jazz command-line tool to recognise environment variables with framework-specific prefixes — like VITE_, NEXT_PUBLIC_, PUBLIC_, and EXPO_PUBLIC_. Previously, if you set your app ID using your framework’s conventional prefix, the CLI wouldn’t find it; now it checks all common prefixes automatically.

I updated Jazz’s Svelte query API to accept getter functions — functions that return a query — in addition to plain query objects. This means reactive query updates now flow through automatically, matching what was already possible in the Vue integration.

I restructured the auth documentation to be organized around mental models with framework-specific tabs. I also moved the more technical theory into a new internals reference page covering things like Ed25519 key derivation, JWT structure, and how provider upgrades are verified.

I removed leftover jazz_principal_id JWT claims from the starter templates. Jazz only reads the sub claim to identify users, so this extra claim wasn’t doing anything — it was just confusing people who were reading the starter code and thinking it was important.

I fixed a bug where JazzProvider in React would tear down and recreate the Jazz client unnecessarily. The issue was that a config object in the useEffect dependency array was triggering cleanup on every render. I switched it to use a stable string key instead, which prevents the cycle.

I added jazz-wasm as a direct dependency to six Vite-based starter templates. When using pnpm, packages only get hoisted to the top level if they’re listed as direct dependencies, so without this change the starters would fail to resolve jazz-wasm at runtime.

I updated the create-jazz CLI spinner to show progress counts while it fetches GitHub dependencies, so you can see how far along it is instead of staring at a static spinner. I also cleaned up some console warnings that were corrupting the output.

I replaced the temporary jazz2-docs.vercel.app URLs with the permanent jazz.tools domain across all starter AGENTS.md files.

I added a jazz-tools schema hash command that prints the short hash of your current schema.ts file locally, without hitting the server or writing a snapshot. Handy for checking if your local schema matches what’s deployed.

I added an AGENTS.md file to all nine starter templates, directing AI coding agents to fetch live Jazz documentation rather than relying on their training data. This helps agents give more accurate and up-to-date advice when working in Jazz projects.

I migrated several example apps (chat-react, moon-lander-react, wequencer) to use the new jazzPlugin() from jazz-tools/dev, switched wequencer to local-first auth, fixed a WebSocket proxy issue, and cleaned up permission configurations.

I replaced two placeholder texts in the “What is Jazz?” blog post with proper markdown links — one pointing to the Discord community and one to the booking calendar.

I added instructions to the project’s CLAUDE.md telling AI coding agents to investigate unexpected test failures rather than assuming they’re pre-existing, and to never rewrite tests without asking the developer first.

I updated the Jazz Vite plugins to automatically inject worker.format: "es" and optimizeDeps.exclude: ["jazz-wasm"] via a config hook. This removes the need for developers to add these settings manually to their Vite config.

I added an interactive widget to the quickstart docs that generates an app ID, admin secret, and backend secret from the hosted Jazz Cloud service. It automatically substitutes the generated values into the code examples on the page.

I added schema validation warnings to jazz-tools deploy that flag tables without explicit permission policies. The warnings are informational only and don’t block the deploy, but they help catch accidental permission gaps before they reach production.

I added a fallback so Jazz apps work in Firefox private browsing mode. When the browser blocks access to the Origin Private File System (OPFS) with a SecurityError, the app now transparently falls back to in-memory storage instead of crashing.

I added three plain-Vite React starters alongside the existing Next.js/SvelteKit ones, and moved the Jazz Cloud provisioning step into the create-jazz CLI itself with a --hosting flag so you can set up hosting during scaffolding.

I added an AuthBackup component to four local-first starter templates with recovery phrase and passkey backup/restore support. This gives users a way to recover their account if they lose their device.

I built an interactive CLI scaffolder so you can run npm create jazz to bootstrap a new project. It prompts for your framework choice and auth mode, then fetches the right starter template, resolves dependencies, and initialises git.

I updated the alphaTab music notation library to its latest version and added a Vite-based sample project. alphaTab is a library for rendering and playing guitar tablature and sheet music in the browser.

I added an optional feature that fixes a tricky timing problem. When a user’s device clock is slightly wrong (drifting), it can cause data to be timestamped incorrectly. This feature uses the existing ping messages between the client and server to estimate how far off the clock is, and quietly corrects timestamps so they’re accurate.

I switched from dynamic runtime URL resolution to a static new URL(...) pattern for the web worker bootstrap. This lets bundlers like Vite, webpack, and Next.js/Turbopack detect and co-bundle the worker and WASM files correctly.

I added "type": "module" to the jazz-wasm package.json. Without it, running the CLI via npx or bunx would fail with an ERR_REQUIRE_CYCLE_MODULE error because Node.js was treating the ES module output as CommonJS.

I deleted 6 test files (about 2,450 lines) from the moon-lander-react example that weren’t actually exercising Jazz’s sync capabilities. I kept the 4 genuine cross-client sync tests that test what the example is really about.

I built a new Vite plugin for SvelteKit projects that manages the Jazz dev-server lifecycle automatically. It supports embedded server mode, connecting to an external URL, or reading the config from environment variables.

I promoted read durability from a footnote to its own top-level section on the reading/queries page, with tier definitions, per-tier guidance, and reference material so developers can choose the right durability level for their use case.

When signing in with Better Auth, a slow /get-session request could arrive after the user had already successfully signed in via a different flow. Because the slow response said “no session”, it would log the user straight back out again. I added a little counter that increments each time the user authenticates, and we attach it as a header to session requests — if a stale response comes back with an old counter value, we now know to ignore it.

If your app’s migration tried to load a piece of data whose shape didn’t match any of the allowed schema variants, Jazz would silently get stuck forever instead of telling you what had gone wrong. The error was being thrown inside an internal loop that swallowed it, so the underlying promise never settled. I added a dedicated error type for this case and caught it in the right place, so loads now fail cleanly as “unavailable” rather than hanging your app.

I added changeset entries to document two bug fixes — one for a hang when loading data with mismatched schemas during migrations, and one for a race condition in Better Auth that was logging users out. Changesets are how Jazz tracks what changed between versions, so these make sure the fixes get properly noted in the changelog.

I updated allowedTo so you can write allowedTo.read("project") instead of having to specify the full “projectId” suffix. It tries an exact match first, then falls back to adding “Id” or “_id” for backwards compatibility.

I built a multiplayer moon lander game as an example app for Jazz using React and Phaser. It demonstrates real-time multiplayer sync — multiple players can fly their landers at the same time and see each other’s movements.

I added From<T> implementations on the Value type for common Rust types and introduced a row_input! macro for building HashMaps more ergonomically. This deleted about 250 lines of boilerplate across the codebase.

I migrated the three remaining hand-rolled HashMap call sites in the examples to use the new row_input! macro, and enabled SQLite for persistent storage in the todo-server tests.

I added Rust code tabs (create, load, delete) to the files-and-blobs documentation page, matching the TypeScript/Rust tab pattern used across the rest of the docs.

I wrote a new Advanced Internals page covering the Jazz data model, browser architecture, query engine, sync protocol, schema evolution, and durability signals. I also fixed several documentation gaps along the way.

I moved prop reads in JazzSvelteProvider and SyntheticUserSwitcher into reactive contexts so the Svelte 5 compiler no longer emits state_referenced_locally warnings. I also improved lifecycle handling in both components.

I standardised snake_case field naming across all todo and file-upload examples to match the docs convention, added missing permissions.ts files, fixed a bug in wequencer’s instrument seeding, and cleaned up undocumented config.

Our createInviteLink function had two different shapes depending on whether you imported it from the core library or from the browser/React Native wrappers. That was confusing for users and, in particular, was causing AI coding assistants to generate broken code because they’d mix up the two forms. I added an options-object overload to the core version so it matches the browser version, and cleaned up some duplicate implementations along the way. The old positional form still works, but it’s now deprecated.

I built a complete Vue 3 example app demonstrating Jazz as a local-first relational database. It covers schema definitions, permissions, and file handling — everything you need to see how Jazz works with Vue.

I migrated the Wequencer example app from storing sound data as inline bytes to using Jazz’s proper file/blob storage pattern with createFileFromBlob. This is the recommended way to handle binary data in Jazz.

I updated the developer documentation to reflect the current build-less status quo, adding sections on the project layout (schema.ts, permissions.ts, migrations), the defineApp pattern, and type helpers.

We had been pulling in wasm-pack as an npm package, which dragged in axios and another helper library as transitive dependencies — more things to trust from the npm ecosystem. Since anyone building our Rust/WASM crate already has a full Rust toolchain installed anyway, I switched us to installing wasm-pack directly via cargo install. One less set of supply-chain risks to worry about.

When two writers were updating the same piece of data at the same time, Jazz would sometimes throw an InvalidSignature error on load. The cause was a classic off-by-one: our code was using a count where it needed an index, so it was fetching one more transaction than the stored signature actually covered. I changed that one number and the storage layer now copes with concurrent writes properly.

I removed the npm wasm-pack package and switched to installing it via cargo instead. This eliminates the axios transitive dependency, reducing the risk of supply chain vulnerabilities.

I fixed an issue where per-subscription claims sent by the client weren’t being merged into the server session. This meant policies that depended on ephemeral claims couldn’t evaluate correctly.

I added a reconcileArray utility that diffs keyed arrays in place and wired it into the Svelte and Vue onDelta callbacks. This means only the items that actually changed get re-rendered, instead of the whole list.

I replaced the mock-based Svelte tests with .svelte.test.ts files that run through the Svelte compiler. This means the tests exercise real Svelte 5 runes instead of mocking them, so they catch actual bugs in reactive behaviour.

I built a complete React chat example app for Jazz featuring messaging, reactions, a canvas, file uploads, and row-level permissions with an invite flow. It shows how to build a real collaborative app with proper access control.

I added JWKS (JSON Web Key Set) rotation support for self-hosted Jazz servers with a TTL-based cache, on-demand refresh, and a stale-if-error fallback. This means the server can automatically pick up new signing keys without needing a restart.

Jazz stores some authentication secrets behind the scenes, and our set function was telling everyone “the new value is ready!” before it had actually finished writing to storage. That tiny window was enough to cause spurious logouts when another part of the app asked for the session at the wrong moment. I added a missing await so the write finishes before anyone else is notified.

I brought the Vue and Svelte bindings up to feature parity with React. Vue’s useAll now accepts QueryOptions, and the Svelte bindings got a proper SubscriptionsOrchestrator, so all three frameworks have a consistent API.

I fixed a bug where the TypeScript schema build step was being skipped after the first run. The CLI was checking if the output file already existed and bailing out, which meant schema changes weren’t being picked up on subsequent builds.

I implemented batching for the sync protocol’s wire format. Instead of sending one payload per HTTP request, the client now accumulates payloads and flushes them as a single batched POST. This reduces the number of network round-trips and improves sync performance.

The Svelte quickstart example was importing SyncConfig as a regular value import, but it’s only ever used as a TypeScript type annotation. I changed it to import type, which is the correct approach for type-only imports and avoids any unnecessary runtime overhead.

When you create a new Jazz app with create-jazz-app, it now includes an AGENTS.md file and a .skills/ directory out of the box. These files give AI coding assistants like Claude a head start by pointing them to Jazz’s documentation and APIs, so they can help you build without hallucinating outdated patterns.

I built a Model Context Protocol (MCP) server for Jazz that exposes the documentation as searchable tools. AI assistants like Claude can now call search_docs, get_doc, and list_pages to look up accurate, up-to-date Jazz documentation rather than relying on their training data. It uses SQLite full-text search when available, with a keyword search fallback for older environments.

The Jazz server-side documentation was mixing two different concerns: how to set up your server code, and how to deploy it to different environments. I split these into separate pages — the setup guide now focuses on the runtime basics, and a new deployment page covers topics like WASM edge runtimes and multi-region patterns.

Small but satisfying: I spotted a one-character typo in the Svelte installation instructions on the Tiptap docs site and sent in a fix.

The better-auth library released v1.5.3, which moved where certain functions live inside the package. Jazz was importing createAuthMiddleware from better-auth/plugins, but that location was removed in the newer version. I updated the import to use better-auth/api instead, which works across versions and keeps the integration working.

I added a new guides section to the Jazz docs with quickstart guides for Vue and TypeScript, framework patterns with React/Vue/Svelte tabs, binary data handling, and a WHERE operator reference.

I updated the Svelte QuerySubscription to accept an options object as its second argument instead of just a bare string. This brings it in line with the React API and makes it easier to pass configuration like the durability tier setting.

I built an MCP server into jazz-tools that exposes Jazz documentation as searchable tools for AI assistants. You can run it with npx jazz-tools mcp and it gives AI coding assistants direct access to the Jazz docs.

I fixed a race condition where the subscription callback could fire before the internal tracking map was ready. The synchronous immediate_tick() call was triggering the callback before the sender could be inserted into the shared subscription map.

I fixed a bug where demo and anonymous clients always got empty query results. They were sending no session in their subscription payloads, and a previous change had made the server require a session for policy evaluation. Now the server falls back to the session it established during the connection handshake.

I fixed incorrect docstrings in the database module that described insert, update, and deleteFrom as synchronous when they’re actually async. Small fix, but wrong docs can mislead developers.

I added support for EXISTS (SELECT FROM ...) subqueries in the SQL policy expression parser, and fixed a bug where the outer row’s ID wasn’t being resolved correctly in policy conditions. This lets you write more expressive permission rules.

When running commands like git fetch inside the sandbox, they couldn’t talk to my running SSH agent because the relevant environment variables were being stripped out. That meant SSH would pop up and ask for my passphrase on the terminal, which garbled the Claude Code session I was working in. I added SSH_AUTH_SOCK and SSH_AGENT_PID to the list of variables that get passed through, so SSH “just works” inside the sandbox.

I fixed a bug where using .include() caused base columns to get corrupted when a subscription fired a second time. The reevaluation function was being passed the output tuple (which included extra joined columns) instead of the original base columns, causing data to shift around.

I fixed a bug where running a migration on multiple tables at once only generated the DROP COLUMN SQL for the first table, silently skipping the rest.

I replaced a hand-rolled binary spawn in the Svelte end-to-end test setup with the official startLocalJazzServer helper, giving each test run its own port. This made the tests more reliable and less prone to port conflicts.

I built Wequencer — a collaborative real-time music sequencer — as a new example app for Jazz. It’s built with Svelte 5 and Tone.js, and lets multiple users compose music together in real time.

I fixed an issue where query() and subscribe() weren’t applying permission policies because the session wasn’t being passed through. Now the client defaults to the JWT session resolved at construction time, so policies are always enforced.

The Jazz website has a showcase page listing apps built with Jazz. I added two new projects — Alkalye and Hifz Garden — and redesigned the layout from a vertical list to a 3-column card grid with randomised ordering on each load. I also added a “Submit your app” button so other developers can easily get their projects listed.

I added Svelte 5 bindings for jazz-tools, including a reactive QuerySubscription class, context helpers, a user-switcher component, and a hook for linking external identities. This lets Svelte developers use Jazz with idiomatic Svelte 5 rune-based reactivity.

I added support for floating-point columns in the database. The TypeScript side already allowed col.float() and generated the right SQL, but the Rust SQL parser was rejecting it with an “UnsupportedType” error.

I fixed a bug where using .include() on message queries caused the message text to come out garbled. The root cause was that an internal descriptor wasn’t being updated after array subqueries were compiled, so the data was being read from the wrong columns.

I replaced a hand-rolled singularize function with the pluralize-esm library. The old function only handled a few suffix patterns and got common English plurals wrong — for example, it was turning “canvases” into “Canvase” instead of “Canvas”.

I went back to my old Chicken Dinner Timer app and fixed a handful of small bugs I’d been meaning to sort out. I corrected an invalid input type, zero-padded the start time so the browser’s time picker would actually bind to it, made the timeline entries sort by number instead of alphabetically, and fixed an addTime function that was ignoring the value it was given in favour of a stale closure variable.

When you changed data in a Jazz app and then navigated to a server-rendered page, the server could show stale information because the changes hadn’t finished syncing yet. I added an optional navigation prop to the Svelte provider that automatically waits for pending syncs to complete before letting the page transition happen, so the server always has the latest data.

When a user logged out of a Jazz React Native app, their session ID was accidentally left behind in secure storage even though the rest of their credentials were removed. I fixed the logout function to also clean up the session ID, so there’s no leftover authentication data after signing out.

I wrote a quickstart guide for React developers getting started with Jazz. It consolidates the main topics into a single reference so new users can get up and running quickly.

When a Jazz CoValue failed to load, you’d just get a vague “unavailable” error with no clue why. I added smarter error messages that tell you the actual reason — for example, if your sync setting is set to “never” or “signedUp”, the error now says so instead of leaving you guessing.

If you tried to create content in a Jazz group where you only had read access, it would silently succeed locally but then all the data would quietly fail to sync. I made it throw a clear error right away instead, so you know immediately that you don’t have permission rather than scratching your head over why your data isn’t showing up.

Jazz is a framework for building collaborative apps. One of the example projects in the Jazz repo needed a secret key stored in a config file, but that file isn’t checked into source control for security reasons. This meant the project would fail to build for anyone cloning the repo fresh. I added a script that automatically generates the missing config file so builds just work out of the box.

I fixed some code examples in the Jazz documentation that incorrectly used await when creating data objects. Creating these objects is actually instant (not asynchronous), so the examples were misleading developers about how the API works.

Jazz uses a rich text editor library called ProseMirror for collaborative editing. One of the packages it depended on had known security vulnerabilities and was no longer maintained. I replaced it with a much simpler, locally-written version that does just what Jazz actually needs, removing the security risk and the unnecessary bloat.

AGENTS.md is a file that helps AI coding assistants understand a project. I added a comprehensive index of Jazz’s documentation to this file, so that AI tools like Claude and Cursor can more easily find and reference the right docs when helping developers. I also wrote a script that automatically regenerates this index whenever the docs are built, so it stays up to date.

Jazz uses special data structures called CoRecords to store collaborative data. When you tried to convert a nested CoRecord to JSON (a common data format), the result was wrong because an internal mechanism was intercepting the conversion. I fixed the serialization logic so nested data structures convert to JSON correctly, and added tests to prevent this from breaking again.

Jazz is a framework for building collaborative apps. I added a set of “skills” — reference documents that AI coding assistants like Claude and Cursor can use to write better Jazz code. These cover topics like performance optimization, permissions, UI integration, and testing, so that when you ask an AI to help you build a Jazz app, it has detailed, accurate guidance to draw on.

Jazz is a framework for building collaborative apps. The docs site has a minimal to-do list example on its landing page, but the icon was an external image that couldn’t adapt to dark mode. I inlined the SVG so it can be styled with CSS, meaning it now automatically adjusts its colours when someone has dark mode enabled on their device.

An example app which shows how to use Svelte with Clerk as an auth provider.

It’s challenging sometimes to approach Jazz when coming from a background of other, more traditional DBMSs. I wrote a guide for folks to be able to more effectively plan their apps’ data requirements.

Our docs had some outdated links. I added a script to validate the links in our docs whenever the homepage is built, and fixed all the broken links.

A vulnerability was discovered in Svelte. I upgraded our versions to ensure we were not exposed to risks.

Spicy Golf is an online golf game built with Jazz. I updated the AI assistant instructions (used by Claude for code generation) to match Jazz’s latest patterns and best practices, so that AI-generated code suggestions for the project stay accurate and up to date.

Jazz is a framework for building collaborative apps. When you upload an image, Jazz automatically creates smaller versions of it so they load faster. The existing sizes jumped from 256px straight to 1024px, which meant medium-sized images (like in a sidebar or card) had to either load a tiny version or wait for a much larger one. I added a 512px in-between size so images load more smoothly in those situations.

Jazz apps can show low-quality placeholder images while the full-resolution version loads. On Expo (a React Native framework for mobile apps), uploaded images had broken placeholders because the image data was missing a required prefix. I added the missing data: prefix so placeholder images display correctly on mobile.

Jazz is a framework for building collaborative apps. I wrote a new API reference page for the docs site that gives developers a clear, concise overview of the most important functions they need to work with Jazz’s core data structures, without overwhelming them with every possible option.

Jazz is a framework for building collaborative apps. When something goes wrong while loading data, apps need a way to gracefully show an error message instead of crashing. I added documentation explaining how to use React’s Suspense and Error Boundary features with Jazz, so developers know how to handle loading states and errors properly.

Jazz is a framework for building collaborative apps. When your data models reference each other in circles (like a project that has a manager who has projects), things can get confusing. I added documentation explaining how to handle these circular references cleanly, so developers don’t get stuck in an infinite loop of loading nested data.

Jazz uses secret keys for user authentication, but these keys were being incorrectly converted when sent between the server and browser — they were being turned into an object format instead of a simple list of numbers. I fixed the conversion so the keys are sent in the right format and can be properly used on the client side for login features like passphrases and passkeys.

I built a Better Auth provider for Svelte, with example project and documentation.

As well as the main frameworks (React, Svelte, React Native, React Native with Expo), we now have code snippets and guides for using Jazz with vanilla JavaScript.

We have the hooks useSuspenseCoState and useSuspenseAccount which integrate with React’s Suspense API to suspend component rendering until all data is successfully loaded.

This PR documents how to use them.

We allow users to do stuff when a subscription throws an error, but this wasn’t documented. I added documentation.

We were previously warning users to avoid using never and signedUp on iOS, as this could result in credentials being cached to the keychain, which would not be deleted when deleting the app. In this case, if the user re-installed the app, their client could crash, as the account for which the credentials were created no longer existed. We now recommend that users who want to keep completely local data without syncing use a randomised prefix for their credentials, and store this in the Settings (which is deleted on app uninstallation).

The Jazz homepage has a QR code and a link for quickly getting started, but they were broken because the URL was missing a hash fragment. I added the missing hash so both the QR code and the link work correctly.

The Jazz docs site has an interactive chat demo embedded in an iframe. It wasn’t working because the page was listening for the wrong event from the iframe. I fixed it to listen to the correct event so the demo works properly again.

Safari’s Web Locks API doesn’t release immediately on navigation, which was causing the browser to effectively hang when viewing our docs landing page. This PR moved the co-ordination of the routes to a parent component.

There was a security issue in Next due to an issue in React. I bumped our Next versions.

Our docs previously had a page showing how to use Jazz’s version control functionality with React. I updated our docs to show how it can be done across all our supported frameworks.

I’m quite proud of this one: I build a minimal Jazz example (a working to-do list with sync in less than 100 lines of code), and published it on our docs landing page.

Jazz is a framework for building real-time collaborative apps. I fixed a small documentation issue where the example invite URL wasn’t formatted correctly — it now uses a hash fragment, which is the proper way to structure these links so that sensitive information isn’t sent to the server.

Our nav was behaving strangely following an update designed to ensure the correct segments were always open. I fixed it.

The Jazz website has a showcase page that highlights apps built with the framework. On mobile phones, the images and text were spilling out of their containers and looking messy. I fixed the layout so everything stays neatly within bounds on smaller screens.

Jazz is a framework for building collaborative apps. The React Native setup guide said to “install” some compatibility patches, but you don’t actually install them as separate packages — you apply them in your code. I updated the wording to be more accurate and less confusing for developers following the guide.

In our React Native and Expo documentation, we had some references to outdated practices and unnecessary modules. I refactored the docs to remove these, and I also consolidated the polyfills into a single module which can be imported directly from Jazz.

In Jazz, you can use ‘selectors’ to avoid React re-rendering on every state update. However, the selector function itself still runs. Added tips on avoiding heavy computation inside selector functions, and how to extract that into a useMemo call outside the selector to take advantage of batching.

I proposed and launched an ‘Advent of Jazz’ initiative on our Discord. This PR adds a prominent link through a banner for December.

The Jazz website had a promotional banner for “Advent of Jazz” that was supposed to stay visible on top of all other content as you scroll. But some elements further down the page were appearing over the banner, hiding it. I increased the banner’s stacking priority so it always stays on top.

Normally, Jazz will throw if it cannot complete a resolve query as requested by the user (for example because the user doesn’t have access to the data or it doesn’t actually exist). Users can override this by specifying $onError: 'catch', which will instead return the rest of the query completed correctly with only the CoValue in question missing.

There was a bug in how this was implemented which I fixed.

Previously, our analytics only captured successful search. This improvement allows us to track unsuccessful searches.

In our docs, we have a hook which fetches the current framework, however, there were other bits of code around the codebase which do similar things, and the hook was becoming unwieldy and difficult to follow.

I refactored the useFramework hook to make it easier to use, and improve the separation of concerns on the homepage docs.

We had some small issues with the new vanilla docs because the snippets were created before the big refactoring of code snippets was merged. This PR brought them in line with the framework specific snippets.

Expo and React Native do not ship a TextDecoder implementation. This docs update explains how to polyfill for (huge) performance improvements in native apps.

When a Jazz app is uninstalled, all data is deleted except the login credentials on iOS which are persisted to the keychain. This can cause issues if the account is not synced and the user reinstalls the app.

The Jazz docs have code examples that hide certain lines to keep things simple. In the Svelte permissions guide, a “hide this line” marker was only hiding the first line of a multi-line block of code, leaving extra lines visible that shouldn’t have been shown. I fixed the formatting so the right lines are hidden.

Jazz’s documentation had a missing asterisk in a role permissions table, which meant a footnote reference wasn’t displaying correctly. I added the missing character to fix the formatting.

We have an example chat app for all our supported frameworks. For our browser-based frameworks, this chat allows also uploading images to the chat, but our mobile apps did not.

I added the image upload functionality to the mobile framework examples.

Users can create lists using Jazz, but there’s no protection to stop users from inserting the same item multiple times into a CoList. For users wanting lists of unique items, I proposed and wrote up a pattern for using a CoRecord keyed on the CoValue ID.

Vercel’s Workflow SDK helps you build long-running background tasks. SvelteKit (a web framework) generates a build folder called .svelte-kit that should be ignored by tools watching for file changes. I added it to the ignore list so the workflow SDK doesn’t unnecessarily process those generated files.

The Jazz homepage stopped building after a recent change added a new dependency that made a previously-needed TypeScript workaround invalid. I removed the outdated workaround and added a proper type check, which got the homepage building and deploying again.

This was a huge piece of work ahead of SyncConf 2025. I built a Jazz-based step sequencer in SvelteKit. Users can collaborate on an 8 beat grid to trigger various one-shot samples in a musical sequence.

The demo is aimed at iPad screen size, and includes primitive sync logic to make sure that devices sound in sync when played simultaneously. This was particularly challenging, and I eventually did it based on calculating clock skew roughly based on a heartbeat from the Jazz mesh. I would like to explore using Jazz as a WebRTC signalling channel.

The source for this is currently closed, but the demo can be accessed at https://jazz-groove.vercel.app/

Jazz is a framework for building collaborative apps. “Workflow World” is a Jazz feature that lets you run backend tasks and workflows. I wrote the documentation for it, covering how to get started, how to set up webhooks, and how to self-host it.

At some point, I introduced a regression that was causing our homepage docs to enter into a recursive navigation loop calling useEffect multiple times. This quick PR fixed it.

I was quite pleased with the PR title on this one: “…infinite recursion: a fix to prevent…”

Twoslash is a code-highlighting and type-checking plugin which helps to make sure all our code samples are kept up to date. Unfortunately though, it causes our build times to be very slow.

I extracted all of our code samples into separate files, and developed a new way of integrating them into our docs. This led to huge speed wins, bringing our build times down by around 5 minutes per build (on Vercel), roughly 14 hours of compute per month.

It also brought even more significant savings in terms of development. Where previously, it took me (M4 Macbook Pro) 110s to compile the docs in dev mode, now it takes 7s, a speed increase of 15×, making it much easier to develop our homepage and our docs overall.

Currently, Jazz stores secrets in localStorage. This is accessible by client-side JavaScript, and so any untrusted code running in a developers’ app could allow the secret to be extracted. Although this is a required trade-off in order to avoid re-authenticating every single session, users are now warned about the risk of cross-site scripting, and advised to take steps to prevent it.

The Jazz documentation had a page about codecs (tools for converting data between formats) that had become unlinked and unreachable from the navigation menu. I moved it under the “Schemas” section where it logically belongs and re-added the link so people can find it again.

Jazz intelligently de-duplicates loads, meaning that each part of an application can load exactly what data it needs without worrying about what is loaded elsewhere in the app. The user will not pay a performance hit because only the extra data which is not already loaded will be fetched, and the existing loaded data will not be reloaded.

Jazz is a framework for building collaborative apps. It has various data types that developers use to build features, but one of them — SingleCoFeedEntry — wasn’t being made available for outside use even though similar types were. I exported it so developers can actually use it in their own code.

I was getting annoyed with Zed not showing any feedback when I tried to commit changes using Cmd+Enter. I made the button appear greyed out when there’s a commit operation pending.

Zed is a high-performance code editor. When you made a Git commit from within Zed’s built-in Git panel, there was no visual indication that anything was happening if it took a moment. Users would sometimes click the button repeatedly, thinking it hadn’t worked. I changed the button text to appear dimmed while a commit is in progress, so you can tell it’s working.

I added some detail to our existing docs showing how users who are not using a framework (‘vanilla’ users) can get started with Jazz.

In our Performance Tips section, I added a section telling users that if they’re adding a lot of values, they can improve performance by inserting them simultaneously in a single call, rather than iterating and inserting each one separately.

In Jazz, we use three main cryptographic algorithms: XSalsa20 for encrypting data, BLAKE3, for calculating a rolling hash of appended operations, and Ed25519 for signing the hashes. These are all published and available for anyone to use.

When uploading an app to the Apple App Store, users have to make declarations about whether their app uses standard encryption or not as part of legal requirements around ‘exporting’ cryptography in the US. This section is intended to provide information for Jazz’s users to make informed decisions when responding to these questions.

I identified a bug where TypeScript incorrectly required specific options to load a CoFeed. However, the underlying code functionality did not depend on these options. I modified the system to remove this unnecessary requirement, improving its usability.

I wrote a new section for our docs explaining how to test Jazz apps using a variety of different helpers.

A number of the packages we depend on have become outdated and have security vulnerabilities. I took care of updating these packages to their latest versions and fixed the issues caused by API changes (particularly for Better Auth).

Jazz is a framework for building collaborative apps. After a recent update, images in Jazz apps would briefly flash their alt text while loading instead of showing a placeholder, which looked jarring. I added the ability for developers to specify their own custom placeholder image (like a company logo or branded loading graphic) so their apps look polished while images load in.

Jazz is a framework for building collaborative apps, and its docs site lets you switch between different platforms. I greyed out the quickstart guides in the navigation menu when viewing React Native or Expo, since those quickstarts haven’t been written yet. This way, users aren’t misled into clicking links that lead nowhere.

Our previous ImageDefinition docs were spread over four files, representing a nightmare for maintainability. I consolidated them into a single file, merging all the content and code samples together to make it easier to avoid mistakes and reduce repetition.

After the Jazz docs site got a new navigation menu, the actual documentation pages were no longer in the right places. I reorganized all the docs to match the new menu structure, updated all the internal links, and set up redirects so that anyone with an old bookmarked URL gets sent to the right page automatically.

Our previous ‘not found’ page was not particularly useful or professional. The new ‘not found’ page includes a search widget to allow users to find whatever content it was they were looking for when they landed on the ‘not found’ page.

Currently, the create-jazz-app CLI tool fetches an llms-full.txt file which contains a summary of all the content contained in the docs, regardless of framework.

However, since my previous PR got merged, we’re generating framework-specific llms-full.txt files, which will be a) smaller and b) less confusing for LLMs, so now, only the appropriate llms-full.txt gets pulled.

Currently, the create-jazz-app CLI tool fetches an llms-full.txt file which contains a summary of all the content contained in the docs, regardless of framework.

However, since my previous PR got merged, we’re generating framework-specific llms-full.txt files, which will be a) smaller and b) less confusing for LLMs, so now, only the appropriate llms-full.txt gets pulled.

I continued developing our llms.txt files. There are three main components to this PR:\

1. Now, if a user wants to access a markdown version of a particular docs page, they can simply append `.md` to the URL, and it will be served as markdown (this is in line with https://llmstxt.org/#proposal)
2. Further, the content is now accessible on a framework-by-framework basis. This means that each page does not include irrelevant information relating to other frameworks.
3. Finally, there are now framework specific llms-full.txt

Jazz’s documentation site had a navigation link to the BetterAuth Database Adapter page that had accidentally been removed at some point. I added the link back so people can find that page from the sidebar again.

I created a new section in our docs which covers advanced performance tips for the 20% of users who need to push harder on performance than the majority.

Jazz supports multiple web frameworks like React, Svelte, and Vue. The docs used to show code examples for all frameworks at once, which was confusing. I updated the documentation build system so that when you select a framework, you only see code snippets relevant to that framework, keeping things clean and focused.

Our CLI tool allows you to get started quickly building with Jazz by running npx create-jazz-app. This update gives some more starter options to users running the CLI tool.

So far, our users have been able to create invite links which target specific CoValues. But there’s no way to easily get the inviteSecret_ for processing however the user likes.

I created a couple of methods (Group.createInvite(groupId, role) and group.$jazz.createInvite(role) which allow you to manually get the secret, and process it how you like using Account.acceptInvite(). I also improved the API for acceptInvite so that if the invite is not specified, it’s assumed to be a group invitation.

Previously, our LLMs text file was done simply by searching and replacing naively.

I introduced a step where our docs are rendered out as pure markdown before they are exported. This allows us to mock specific components so we can do things like render the tabbed code group component sensibly.

There was a PR which introduced a bug where buttons all had additional absolutely positioned content after them, which resulted in every section containing a button to horizontally overflow its container, resulting in unsightly scrollbars popping up all over the website. I fixed it.

We have a tool which allows you to run create-jazz-app with some options to get a new Jazz app set up. This tool was cloning a specific part of our monorepo where a static build of our docs had been copied. However, this had fallen out of date, and so we were wasting our users’ time, bandwidth, and worse, seeding their AI agents with incorrect, outdated data.

I introduced functionality to fetch the latest docs from our website to save for AIs to refer to.

I fixed a CSS bug on the Jazz homepage where unwanted scrollbars were appearing all over the page. A recently added style on buttons was causing content to overflow its containers, so I removed the problematic rule.

macOS defaults to using a weird overlay scroll bar when you’re using a trackpad, which meant that the scrollbars were rendering over content, which looked ugly and unprofessional. I fixed it.

We were starting to outgrow our existing nav structure for docs, with tens of articles and only two hierarchical levels. I extended the hierarchy to allow a third level of nesting, as well as collapsible subheadings in the nav menu.

The Jazz docs site had a build issue where two pages were trying to use the same URL path, causing conflicts. I resolved the conflicting routes so the site could build and deploy successfully again.

Jazz allows you to authenticate in many different ways. One way is using passkeys, and this was covered in the authentication quickstart guide I published last week. This adds an additional authentication method, passphrases, and shows how to use the two different authentication methods in conjunction to create an effective ‘recovery key’ option.

We have some automated tests that run when we add new code to our repositories. For a while now, the end-to-end tests have been failing. I spent some time digging into the reasons for this, and fixed the tests so that they no longer fail when newer versions of Node are used to run the tests.

Jazz is a framework for building collaborative apps, and its docs site had a quickstart guide for authentication. I extended this guide to show how to add passkey login (the kind where you use your fingerprint or face to sign in) alongside other auth methods, so developers can see how to offer multiple ways for users to log in.

Our existing SSR agent was recommended for use to allow Server-Side Rendering in Next.js apps. However, I realised that the module itself is written in pure TypeScript, and there’s no good reason for it to be React-only. I modified the Svelte provider, changed the export, and updated the docs, as well as creating a small example app demonstrating how the SSR agent can be used to perform Server-Side Rendering in SvelteKit too.

Most of our users need basic features like authentication and collaboration in their apps, but the guides we have are currently very reference-y and not so much practical implementation guides.

I wrote one guide that covers permissions in Jazz using groups, and how to share data and collaborate on it, and a second which shows how to add passkey authentication into your app using the basic passkey UI.

This should make it easier for users to build an app with the kind of features a real-world app needs.

I created a GetAPIKey snippet which can be re-used all over the docs to have a single, consistent message regarding API keys, and allow us to simplify updating and maintaining all these references.

The snippet can also optionally display how the API key can be used.

We have a CodeGroup component which allows us to display some code with a copy button. This CodeGroup allows us to write special comments like // [!code --:1] to mark a line as ‘removed’. However, these were still being copied, resulting in inaccurate code snippets being copied when users clicked the button.

This PR removes those lines from the copied text.

In principle, according to the WebAuthn spec, cryptographic challenges should be at least 16 bytes long, however in our existing implementation, we had 3 bytes. Although this is technically within spec, it was causing issues for some users using third party passkey managers such as KeePassXC.

This PR builds on previous work and extends the challenge length to 20 bytes.

Due to various challenges with TypeScript generics, we can’t make the $jazz.ensureLoaded, $jazz.set and $jazz.subscribe methods typesafe on discriminated unions. This was causing warnings for one of our adopters in their project.

Although this was previously covered in the docs, it was hidden towards the bottom of the page.

This PR makes it clearer and more prominent.

By default, all credentials are stored under jazz but this makes it impossible to avoid namespace clashes (for example, if you have multiple apps running on the same domain, or in case you want to do local development of more than one Jazz app at a time.

This PR extends on work that was already done to add an option to the Svelte provider, allowing users to specify the prefix under which their credentials will be stored.

Jazz is a framework for building collaborative apps. Based on feedback from the community on Discord, I updated the docs to better explain when and why you’d use a particular data-loading function called ensureLoaded, making it clearer for developers who were confused about its purpose.

When users try to build their applications, TypeScript will compile Jazz as part of their dependencies. However, there are a couple of options that Jazz doesn’t currently work well with. This PR makes it clear to users what options need to be set for compilation to work properly.

Our documentation on how to subscribe to CoValues and load them deeply was complex and difficult to reason about. I simplified, consolidated the examples, and created new illustrative content to make it clearer and easier to understand for users of varying knowledge levels.

We launched our cloud dashboard recently, allowing users to sign up for API keys rather than using their email address. However, across all of our docs, we had verbiage that users should use their email as a temporary API key.

This PR addresses that by changing the wording to drive traffic to our dashboard instead of recommending email addresses.

We have a component in React, React Native and Svelte which can be used to display images with progressive sizes. Although we have an option to show a placeholder, and loading this is normally fast, in case there is a slower load (e.g. network issue, etc.), then there is a flash where the browser’s default placeholder will be displayed (normally just the alt text of the image).

This PR fixes that by instead setting the image to a transparent single pixel (which gets stretched as needed to fit the image based on the size needed by the user). Instead of getting a flash of alt text, nothing will display instead, until the Image Definition is loaded, at which point the default behaviour (show the placeholder or the alt text) will kick in.

Previously, users who wanted to get started with Jazz could either use the command line tool to scaffold a project, or they could work through an installation tutorial which covers the practical side of getting Jazz added to an app, but doesn’t guide folks to an ‘ah ha!’ moment.

I wrote a quickstart guide which works for both React and Svelte, and added a follow up which shows how to use Jazz on the server with a worker. These guides will help users understand the core concepts of Jazz.

Jazz is a framework for building collaborative apps. The docs site had a big, attention-grabbing warning box telling people they needed Node.js version 20 or higher. I toned it down to a simple note underneath the setup instructions, since it was more prominent than it needed to be.

Jazz’s documentation site lets you switch between different frameworks (like React and Svelte) to see relevant code examples. I fixed a bug where some parts of the page wouldn’t update when you switched frameworks — they’d stay stuck showing the one you first loaded. Now the whole page updates consistently when you pick a different framework.

Our existing docs explained how to use getters to recursively reference schemas, but weren’t very clear about how to avoid ReferenceErrors caused by schemas creating circular references which resulted in references being evaluated while they were still in the temporal dead zone.

I added some additional keywords and explanation to help folks find these docs more easily when they’re searching, as well as explaining the use cases in a bit more detail.

Web pages often have ‘links’ that can change part of the page without reloading the whole thing. These changes sometimes show different content depending on the link. In Jazz, we can invite people to collaborate on data using links, and we need to notice when someone follows a link.

Previously, the code that checks the URL for invitations only checked once — when the component first appeared on the page. That worked if the person opened the page fresh, but it wouldn’t notice if the URL changed later (for example, if someone clicked a link that added extra info to the URL, called a ‘hash’).

What I did was adjust the code so it also watches for changes to that part of the URL — the hash — so it reacts immediately whenever someone follows a link, not just on page load. That way, no invitation is missed, no matter how the user navigates.

Jazz is a framework for building real-time collaborative apps. I updated all the example projects so they load the API key from a configuration file instead of having it hard-coded in the source code. This makes it easier for the Jazz team to track how their examples are being used and is a better practice for managing secrets.

Jazz is a framework for building real-time collaborative apps. After a previous change required all example apps to use an API key from a configuration file, the Svelte starter template would crash if that file was missing. I fixed it so the app loads the key dynamically instead, meaning new developers can get started without hitting an error on their first run.

Jazz’s docs site has a confirmation dialog that pops up when you want to delete your local data. The code for this dialog was written inline and couldn’t be reused elsewhere. I extracted it into its own standalone component so it can be shared across different parts of the site.

Jazz is a framework for building collaborative apps that store data locally on your device. I added a button to Jazz’s built-in developer tools that lets you clear all your local data, which is useful for testing and debugging. It comes with a clear warning so you don’t accidentally delete things, and I also built a reusable confirmation dialog to go with it.

Jazz has a status page that shows whether its services are running. During an outage, the “status” indicator correctly showed things were down, but the latency chart right next to it was still bright green, which was confusing and misleading. I made the latency bar turn red whenever there’s an active outage, so the visual indicators are consistent.

Jazz is a framework for building real-time collaborative apps. I fixed the Vue.js chat example app so it properly uses Jazz’s built-in helpers for sending messages and handling image uploads, instead of the outdated approach that had stopped working.

Jazz is a framework for building collaborative apps. I made a batch of small fixes across the docs — updating React Native setup instructions, standardising how user profiles are defined in examples, adding missing options to the React setup guide, and cleaning up a few other rough edges.

Jazz is a framework for building real-time collaborative apps. There was a typo in the package configuration that meant Svelte developers couldn’t import Jazz’s testing utilities. I corrected the file path so that the testing tools can be found and imported properly.

My drinks tracking app was showing all entries in one big list, which got unwieldy. I added pagination with Previous/Next buttons so you can browse through entries page by page. I also fixed a layout bug where long drink names would stretch the table and break the page, and corrected how alcohol percentages are displayed so they don’t show excessive decimal places.

Jazz is a framework for building collaborative apps. I expanded the documentation on optional references — explaining when to use Jazz’s own “optional” versus the standard one from the validation library. This helps developers avoid a confusing gotcha when defining their data models, and I also fixed a couple of broken code examples along the way.

A link in the Jazz documentation was broken because it had an extra .mdx file extension on the end of the URL. I removed the stray extension so the link goes to the right page again.

After Jazz released version 0.15, I cleaned up a few things in the documentation. I removed outdated references to the old version, added a clearer warning about a common setup mistake that was tripping people up (including me), and made sure all the installation guides mention the required Node.js version.

Jazz is a framework for building real-time collaborative apps. I cleaned up how environment files (which store secret settings like API keys) are handled across all the example projects. Previously some examples accidentally included real configuration files in the public repository. I made sure only template files are shared, with clear instructions for developers to create their own private copies.

Jazz’s documentation site had a bug where the search bar was causing horizontal scrolling on the page, especially on small screens. I fixed it by making the search container take the full width of its parent, which stops it from overflowing.

Jazz is a framework for building real-time collaborative apps that sync data between users. I updated the setup instructions across all the example projects to reflect a new way of connecting to a local sync server, so developers following along wouldn’t get tripped up by outdated documentation.

I removed a leftover debugging statement from the Jazz codebase. Developers sometimes add temporary log messages while building features and forget to clean them up — this was one of those.

Jazz is a framework for building collaborative apps, and it supports several UI frameworks including Svelte. The docs page for Svelte’s “provider” setup (how you connect your Svelte app to Jazz) was incomplete. I filled in the missing documentation so Svelte developers can properly set up Jazz in their apps.

The Jazz docs had a code example for Svelte passkey authentication where a template literal was missing a $ sign. Without it, the variable inside the string wouldn’t actually get replaced with its value. I added the missing $ so the code example works correctly.

Someone built a minimal example app to demonstrate a bug with Jazz and Svelte, but the example itself had issues. I fixed the reactivity (making the UI update properly when data changes) by using Svelte’s built-in $derived feature, and also added graceful handling for missing images instead of crashing. I also added the Jazz Inspector debugging tool to help with further troubleshooting.

I rebuilt the UI of my personal drinks tracking app using shadcn, a modern component library that provides clean, accessible interface elements. I also switched the project to use Bun as the package manager and tidied up some styling issues along the way.

The Svelte Society website maintains a directory of community-built components for the Svelte JavaScript framework. I added my own image component library to their registry so other Svelte developers could discover and use it.

I added a new metric to my personal drinks tracking app that shows how many days you went over the recommended alcohol intake limits. I also fixed some type-related bugs along the way.

I tidied up the code in my personal drinks tracking app — a small tool I built to keep tabs on my alcohol consumption. This included some general refactoring and a bug fix.

I set up the initial project structure for Tastine, a personal app built with Svelte. This was the foundational first commit to get the project off the ground.

idle-task is a JavaScript library for running tasks during browser idle time so your app stays responsive. I fixed a typo in the README where “priority” was misspelled as “prioriy.” Ironically, my commit message also contained a typo — Muphry’s law in action.

Chicken Dinner Timer is a web app I built for timing how long to cook chicken. I added a README file to the repo so visitors can quickly understand what the project is and how to use it.

I updated the README for a small project about double prime vowel symbols used in linguistics. The explanation of what the double prime symbol is and how it’s used wasn’t clear enough, so I rewrote it to be easier to understand.

I updated the README documentation for my personal blog, which is built with SvelteKit.

I added a new blog post to my personal SvelteKit blog.

Svelte Tiny Linked Charts is a small library for rendering sparkline charts in Svelte apps. Previously, the charts were display-only — you could look at them but not interact. I added a click handler so developers can run custom code when a user clicks on a data point in the chart, like showing more details about that value.

I updated my family photo management app to use EXIF data (the metadata embedded in photos by cameras, like the date and time a photo was taken) for generating file names. This gives much more accurate file naming than guessing or using arbitrary names, making it easier to organise and find photos.

CapRover is a self-hosted platform for deploying apps with one click. One of its app templates had “STMP” instead of “SMTP” (the protocol used for sending email). I fixed the typo.

Notesvac is a small app I built for tracking notes and vacation days. I improved the styling to make it feel more like a native app and added a proper footer with privacy policy and terms of service information.

Directus is an open-source headless CMS that connects to your database. Some cloud database providers require you to specify a database version, but Directus wasn’t passing that setting through correctly. I fixed it so that setting a DB_VERSION environment variable actually works as expected.

Astro is a static site framework. I added support for setting a default layout for Markdown pages through the configuration, so you don’t have to specify which layout template to use at the top of every single Markdown file.

The 1MB Club is a curated list of websites that are under 1MB in total size. I submitted traist.co.uk to be included in the collection.

Directus is an open-source headless CMS. I noticed developers in the Discord were frequently running into a confusing authentication error when building front-end apps locally. I added a tip to the docs explaining why the error happens (it is related to how browsers handle secure cookies during local development) and two ways to work around it.

I rewrote my personal fork of Elpea, a music discovery app, from scratch using SvelteKit. The migration included visual improvements like using album cover art as a semi-transparent background, along with better reactivity so the interface updates more smoothly.

Directus is an open-source headless CMS. Its JavaScript SDK had a bug where users would get unexpectedly logged out after refreshing the page, even though their login session was still valid. I fixed it so the SDK automatically checks and refreshes the login token when it starts up, keeping users properly signed in.

Bubi Bikes is an app I built for checking Budapest’s bike-sharing system. The app fetches data from an external API, but browsers block those requests for security reasons unless they go through a proxy. I updated the proxy the app uses so it could keep working.

Elpea is a music discovery app. When you searched for an artist and got no results, the page would just show a blank area, which was confusing. I added a friendly message that appears when no results are found, so users know their search didn’t turn up anything rather than wondering if the app is broken.

Elpea is a web app I worked on at Traist. I updated the mockup screenshot in the repo to reflect the latest design of the application.

Elpea is a music discovery app. I upgraded it to the latest version of Next.js (the web framework it’s built on) and fixed a few bugs that came up during the upgrade, including one related to how device information is passed to the music player.

TinaCMS is a Git-backed headless CMS. I added documentation explaining how to use Next.js’s built-in image optimization component with TinaCMS, including the benefits it provides and important caveats developers should be aware of.

TinaCMS is a Git-backed headless CMS for editing Markdown content. I updated the documentation on the TinaCMS website to reflect changes that were made in the main TinaCMS repo, keeping the docs in sync with how the code actually works.

TinaCMS is a content management system that lets you edit Markdown files visually. The docs had a code example that could crash if the editor hadn’t fully loaded before the cleanup code ran. I added a check to make sure the editor is actually ready before trying to clean it up, preventing the error.

TinaCMS is a Git-backed headless CMS for editing content. Their docs had a code example showing how to dynamically load the editor, but the example was missing a cleanup step that prevents memory leaks in React. I added the missing cleanup function so developers copying the example would get working, production-ready code.

TinaCMS is a content management system that lets you edit website content visually. I fixed a gap where developers using a shortcut function to create editing forms couldn’t customize things like the icon or layout style. Now those options can be passed through directly, so you don’t need a workaround.

Traist is a company website I worked on. I integrated Chatwoot, an open-source live chat widget, so visitors to the site can start a conversation directly from the page. I also fixed a small performance issue with font loading along the way.

TinaCMS is a Git-backed headless CMS for editing Markdown content. The docs had a code example for fetching files from GitHub that was using the wrong parameters, which would have confused anyone copying it. I fixed the example so it actually works.

TinaCMS is a content management system with a visual editing toolbar that sits at the top of the page. I contributed a CSS trick to the docs showing how to push your site’s own sticky menus below TinaCMS’s toolbar, so they don’t overlap and hide each other.

I upgraded the Traist company website to use SASS modules, a more modern way of organizing CSS stylesheets that keeps styles neatly scoped and easier to maintain. I also improved some of the typography along the way.

ApostropheCMS is a Node.js content management system. I spotted a typo in one of the documentation page headings and submitted a quick fix to correct it.

UploadFS is a Node.js library for storing files in cloud storage like Amazon S3. I noticed the docs were missing information about how to configure a custom S3 endpoint (which you need if you’re using an S3-compatible service that isn’t AWS), so I added that documentation.

ApostropheCMS is an open-source content management system. I updated the codebase to use the newer “prompts” library instead of the older “prompt” library for handling interactive command-line input during the 3.0 rewrite.

Ackee is a self-hosted, privacy-focused web analytics tool. I fixed a few spelling mistakes in the codebase.

Umami is a privacy-focused web analytics tool (like a simpler, open-source alternative to Google Analytics). When using MySQL as the database, special characters weren’t being stored correctly because the database tables weren’t set up with the right character encoding. I fixed this by making sure tables are created with UTF-8 support, so all characters display properly.

ApostropheCMS is an open-source content management system for Node.js. I spotted a typo in its documentation and submitted a fix.

I updated the README documentation for my Simon Says game web app to better describe the project.

I updated the README documentation for my Simon Says game web app.

I updated the README documentation for my Simon Says game web app.

I updated the README documentation for my Simon Says game web app.

This is a Leaflet maps plugin for OctoberCMS. If a map marker’s popup text contained an apostrophe (like “Joe’s Coffee”), the whole map would break and refuse to load. I fixed this by switching from single quotes to template literals in the code, so apostrophes in popup content no longer crash the map.

Figbird is a React hooks library for working with Feathers.js APIs. I spotted an error in its documentation and submitted a fix to correct it.

Figbird is a React library for working with Feathers.js APIs. The getting-started example was missing important setup details, so I added the Feathers client configuration to make it easier for new users to get up and running.

I made updates to my COVID-19 data tracker for Hungary, syncing changes from the Glitch online code editor where I was building and iterating on the project.

FlipDown is a JavaScript countdown timer with a retro flip-clock style. The labels for the time units (days, hours, minutes, seconds) were hardcoded in English. I added an option to customize these headings, which is handy for using the timer in other languages or for changing labels like “Days” to “Jours” in French.

Apostrophe Monitor is a tool that watches over an ApostropheCMS website and restarts it if it crashes. Previously, if the CMS couldn’t start at all (for example, due to a code error), the monitor would just give up and exit. I changed it so that the monitor stays running and shows a helpful error page in the browser instead, giving you time to fix the problem without losing the monitoring process.

Apostrophe Palette is a UI editor plugin for ApostropheCMS. The README had a code example with a missing closing curly brace, which would have caused errors if someone copied and pasted it. I added the missing brace to fix the example.

I pushed an update to my BuBi Bikes app, which shows real-time availability of Budapest’s bike-sharing stations so you can quickly find a nearby bike or an open dock.

I made updates to my wedding save-the-date web app, syncing changes from Glitch (an online code editor that makes it easy to build and iterate on small web projects).

I made updates to my wedding save-the-date web app, syncing changes from Glitch (an online code editor that makes it easy to build and iterate on small web projects).

I made updates to my wedding save-the-date web app, syncing changes from the Glitch online code editor where I was working on it at the time.

I made updates to my wedding save-the-date web app, syncing changes from Glitch (an online code editor that makes it easy to build and iterate on small web projects).

I made updates to my wedding save-the-date web app, syncing changes from Glitch (an online code editor that makes it easy to build and iterate on small web projects).

I made updates to my wedding save-the-date web app, syncing changes from Glitch (an online code editor that makes it easy to build and iterate on small web projects).

I updated my wedding planning web app with some code refactoring (moving logic into controllers) and a language selection feature, syncing the changes from the Glitch online editor.

Screen2vid is a simple web tool I built for screen recording. The footer was floating in the middle of the page when there wasn’t much content, so I fixed it to stick to the bottom where it belongs.

I set up the initial version of a wedding planning web app, including the base styling and date formatting with proper locale support so dates display correctly for different regions.

This is a collaborative coding dictionary project. I added WebSocket support so that the app could update in real time — when someone adds or edits a definition, everyone else sees the change instantly without reloading the page.

Shepherd is a JavaScript library for creating guided product tours — those step-by-step walkthroughs that show new users around an app. The tour.removeStep method existed but wasn’t documented, so developers didn’t know it was available. I added the missing documentation so people can discover and use it.

Hacktobermap is a Hacktoberfest project that plots contributors on a world map. I added myself to the map as part of my Hacktoberfest contributions.

FizzBuzz is a classic programming challenge where you print numbers but replace some with “Fizz”, “Buzz”, or “FizzBuzz”. This repo collects creative solutions in different languages and styles. I contributed a deliberately ugly JavaScript one-liner using nested ternary operators — because sometimes the fun is in making it as unreadable as possible.

The Name Suggestion Index is a community-maintained list of well-known businesses and how they should be tagged in OpenStreetMap. I added details for “Sem’ya,” a Russian retail chain, including its Wikipedia link and English name, so mappers can correctly identify and tag these stores.

Feathers-vuex is a library that connects Vue.js apps to Feathers.js, a real-time API framework. A recent update to Feathers accidentally broke things by not always including required request parameters, causing crashes. I added a safety check so that parameters are always set when creating or removing data, preventing “undefined” errors even if the upstream library has a hiccup.

VBB-AnyBar is a tool that shows Berlin public transit departures using a little coloured dot in your menu bar. I added a “time to station” setting so the app can account for how long it takes you to walk (or cycle, or drive) to the station, making its departure alerts actually useful for knowing when to leave.

This is a tool for filtering German public transit departures by direction. It already supported a “when” option to look up departures at a specific time, but this wasn’t mentioned anywhere in the documentation. I added it to the README so other developers could discover and use the feature.

This is a tutorial project for setting up user authentication with Passport.js and RethinkDB. I fixed a typo in the .gitignore file, which tells Git which files to leave out of the repository.

Redash is an open-source tool for visualising data from databases. I added an example to their documentation showing how to filter results when querying a MongoDB database, making it easier for new users to understand how to narrow down their data.

I added a data file to my personal website that lists my projects, making it easy to display them on the site without hardcoding everything into the page itself.

I created the initial version of a web project aimed at helping homeless people. This was the first commit that set up the project and got it off the ground.

Disease Info UI is a Hacktoberfest project that aggregates information about various diseases. The page was getting long and hard to navigate, so I added a table of contents at the top with jump links to each section, making it easier to find the disease you’re looking for.

Primerpedia is a tool for quickly looking up Wikipedia article introductions. I added the ability to share search results via URL — you can now link someone directly to a search by adding a query parameter (like ?page=cats) to the web address, and the search will run automatically when the page loads.

Jedi Validate is a lightweight JavaScript form validation library. I proofread and copy-edited the project’s README to improve clarity and fix grammatical errors, making it easier for new users to understand how to use the library.

DPicker is a minimal date picker component for the web. The setup instructions in the documentation used a modern JavaScript syntax (arrow functions) that Safari didn’t support at the time, so I replaced them with traditional function syntax to make the examples work in all browsers.

Meteor Starter is a template for quickly spinning up Meteor.js apps. I spotted that “Google” was misspelled as “Googe” and fixed the typo.

I added some extra CSS styles to my personal website for things like hover effects. These styles aren’t essential for the page to work, but they make it feel more polished.

On an older version of my personal website, elements would briefly flash when the page loaded because they were being hidden with display: none, which causes the browser to recalculate the layout. I switched to using opacity: 0 instead, which hides things without triggering a reflow, making the page load smoother.

I added fluid typography to my personal website. Instead of text jumping between fixed sizes at certain screen widths, fluid typography makes the font size scale smoothly as you resize the window, so it always looks good whether you’re on a phone or a big monitor.

I added hover effects to links and interactive elements on an older version of my personal website, so users get visual feedback when mousing over clickable things.

I optimised my personal website’s loading speed by deferring non-essential stylesheets. Instead of making the browser load all the CSS upfront before showing any content, less important styles now load in the background so the page appears faster.

Patchwork is a beginner-friendly project for learning how to use Git and GitHub. I completed the tutorial by adding my username to the project, practising the basics of forking, branching, and submitting a pull request.

I added browser notifications to my chat app so users get alerted when new messages arrive in their channels, even if they’re not actively looking at the chat window.

I fixed a security vulnerability in my personal real-time chat app built with Meteor.js, where database insert operations weren’t being properly validated, potentially allowing malicious data to be submitted.

I built a personal real-time chat app using Meteor.js. In this update, I added the logic for channels to update in real time when new messages arrive, so users automatically see the latest content without refreshing the page.

I added channel subscriptions and several other features to my personal chat app, including the ability to subscribe to specific chat channels, infinite scrolling to load older messages, and improved channel permissions so people can only see the channels they have access to.

I merged several recent features into the development branch of my personal chat app, including message editing, infinite scroll for loading older messages, and the channel subscription system.

I built a personal real-time chat app using Meteor.js. In this update, I added channel-level permissions so that only authorised users can see messages in private channels, and admins can add or remove users from those channels.

I built a personal real-time chat app using Meteor.js. In this update, I added the ability for users to edit their own messages after sending them.

I merged the markdown and emoticon features from my development branch into the main branch of my chat app, making rich text formatting and emoticons available to all users.

I added permission controls to my chat app so that only users who have access to a channel can see its messages. I also built an admin panel for managing channels, adding and removing users, and added user avatars via Gravatar.

I built a personal real-time chat app using Meteor.js. This was an early merge bringing in several improvements, including better notification pop-ups when things go wrong, and an access control system so channels can be public or restricted to specific users.

I added support for markdown formatting (like bold and italic text) and emoticons to my personal chat app, so messages look richer and more expressive instead of just plain text.

I built the first working version of a personal real-time chat application using Meteor.js, with basic visual design and the ability to create and switch between different chat channels.

Codiad is a code editor that runs in a web browser. Its file-comparison feature was breaking when files contained special characters (like accented letters), because it wasn’t explicitly set to handle UTF-8 encoding. I added the UTF-8 encoding declaration so that comparing files with non-English characters works correctly.

Anchor CMS is a lightweight PHP blogging platform. It would crash when running on a machine without internet access because it tried to check for updates without handling the case where it couldn’t connect. I added a check so it gracefully skips the update check when there’s no network connection, instead of crashing.