PowerSync Changelog: May 2026

Community PRs have been strong lately, and we're doubling down on open-source transparency by moving more engineering discussions into #engineering-discussions on our Discord server. Thanks to all the contributors!

On the product side, highlights were that Sync Streams reached GA, the Dart SDK got a major overhaul, the Swift SDK was rewritten in pure Swift, and you can now search and filter instance logs in the Dashboard.

Grab another coffee, here's everything that happened over the past couple of months.

Product updates shipped

PowerSync Service:

• Sync Streams are now GA: Since beta we added global CTEs, type-safe generated client wrappers, better error reporting with source offsets, and a long list of bug fixes. If you're still on Sync Rules, now's the time to migrate. Use the button in the dashboard or run powersync migrate sync-rules in the CLI. Release notes and Docs.
• Earlier detection of Postgres WAL slot problems: For Postgres source databases, if a replication slot is lost during initial replication, the Service now catches it early and stops rather than running to completion and failing. More importantly, WAL budget warnings now surface in the Dashboard and diagnostics API before a slot is lost, so you can fix the underlying conditions before they become a problem. Docs.
• HA replication for Pro plan+: PowerSync Cloud instances on the Pro plan and above now get high-availability replication processes.

Client SDKs:

• Dart/Flutter SDK v2.0 — consolidated and faster: powersync is now the only package you need. We removed powersync_core, powersync_sqlcipher, and powersync_flutter_libs. Encryption is built in, the native connection pool is Rust-backed for faster queries and multi-isolate support, and web databases now default to OPFS on Chrome and Firefox. Learn more in our feature story below.
• Inspect your database in DevTools (Dart/Flutter): v2.1.0 adds a PowerSync tab to Dart & Flutter DevTools. Inspect open PowerSyncDatabase instances, view active Sync Streams and sync status, and run queries against the local SQLite database while debugging. Docs.
• Swift SDK rewritten in pure Swift (v1.14.0): Previous versions wrapped a Kotlin XCFramework. The SDK is now native Swift throughout: no Kotlin dependency, smaller binary, better debuggability in Xcode, and typed CRUD payload fields. There are no breaking changes to the public API, but parts of the SDK are a full rewrite so we recommend smoke-testing your queries after upgrading. Release notes.
• Concurrent reads and faster web writes (Web SDK v1.38.0): Added support for OPFSWriteAheadVFS, a new synchronous VFS using write-ahead logging. Reads no longer block on writes and multiple read queries run in parallel. Currently Chromium-only (it relies on OPFS's readwrite-unsafe mode). Docs.
• Attachments and Mac Catalyst for .NET (v0.1.2): The .NET SDK gained attachment sync APIs matching the implementation in other SDKs, plus Mac Catalyst support. Changelog.
• Improved raw tables across all SDKs: put and delete statements are now inferred automatically. You only need to provide the tableName. Local-only columns and other table options now work with raw tables too. Docs.
• Capacitor SDK reached beta: Production-ready for tested use cases and covered by our SLAs. New since alpha: Swift Package Manager support for iOS (requires Capacitor 8+), and significantly faster sync on native platforms via NDJSON-HTTP. Docs.

Tools:

• Search and filter instance logs: The Logs view in the PowerSync Dashboard now supports free-text search and structured alias:value filters (by user_id, client_id, error code, and more), plus CSV export. Release notes and Docs.
• Self-service Private Endpoint setup: Private Endpoints (AWS PrivateLink) can now be created and managed directly in the PowerSync Dashboard — no support ticket needed. Available on Team and Enterprise plans for Postgres and MongoDB Atlas. Release notes and Docs.
• Trigger compaction from the CLI: powersync compact triggers compaction on your linked PowerSync Cloud instance directly, with an optional --timeout flag for large datasets. Docs.

New demos & guides:

• Self-hosting on AWS EKS — step-by-step guide for deploying PowerSync on Kubernetes via Helm Charts.
• Dart/Flutter DevTools extension guide — how to use the new database inspector for Dart/Flutter apps.
• Replication lag guide — what this metric means, common causes, and remediation steps.
• Diagnosing sync latency — how to isolate which stage of the sync process is slow, and how to correlate user reports with sync session logs.

Community feed

• We added a PowerSync add-on to the TanStack CLI. Run create powersync-app --framework react --add-ons powersync to get a working PowerSync setup for React.
• Steven built a MikroORM + PowerSync PoC. Here's the discussion if you have thoughts or want to help take it further.
• Dev wrote a series on the role sync engines can play in AI apps: most AI chat apps throw away in-flight responses on refresh or disconnect — treating LLM output as synced state fixes that, why AI apps default to single-player and how sync engines bring multiplayer collaboration, and a two-part practical guide on building collaborative, synced AI apps (Part 2).
• Simon wrote up Easy Tauri Integration Tests with Vitest — useful if you're building with the Tauri SDK.
• New engineering proposals:
  • Write API — Christiaan is exploring a first-class write protocol for PowerSync, covering mutators, conflict handling, and how writes flow from client to backend. This would be a significant change to how you build with PowerSync and we want input from people actually building with it. Join the discussion in Discord.
  • Raw Table High Performance Diffs — trigger-based diffing specifically optimized for raw tables, where the current approach has limitations. Proposal.
  • Faster and incremental sync_local — a more internal proposal, with the goal to make initial sync faster and eventually incremental, so it can report progress and avoid blocking writes for minutes on large datasets. Discussion #178.
  • Streaming attachments — the attachment queue currently loads the entire file into JS memory, which can be a problem with large files. Discussion #968.
• @austinbhale: thank you for building out attachments support for the .NET SDK, bringing it to parity with our other SDKs! PR #68.
• Thank you also to @Shamyyoun, @sravan27, @VIVAAN-DHAWAN, @Sagbyy, @johnnysedh3lllo, and @JexanJoel for your contributions.
• Built with PowerSync:
  • Fig by the team at figwealth.io: freelancer finance — expense tracking, invoicing, P&L, and tax estimates. App Store and Google Play.
  • Thunderbolt by the team behind Mozilla: an open-source, self-hostable enterprise AI client with chat, search, and research workflows across devices. Blog post.
  • Capubridge by @aybinv7: a Tauri desktop devtool for debugging WebView-based Android apps, with direct SQLite inspection. Useful for anyone debugging PowerSync sync state on Capacitor or React Native. GitHub.

Feature story: The Dart SDK gets a proper foundation

The Dart/Flutter SDK has in many ways been our flagship SDK. It was the first SDK we shipped, and it's still one of the most widely used. But it had accumulated a fair amount of technical debt: separate packages for core functionality, encryption, and Flutter libs that you had to wire up yourself; a legacy Dart sync client running in parallel with the Rust one; and some platform-specific rough edges we've been working around. On the web in particular, the setup was annoying: manual WASM file copying, and Safari requiring special cross-origin isolation headers just to use storage.

v2.0 addresses that. powersync is now the only package you need, whether you're building a Flutter app, a CLI tool, or a server-side Dart service. SQLite loading is now automatic through build hooks — you no longer need powersync_flutter_libs or a manual initialization step. Encryption is built in. On native, the connection pool is now Rust-backed, which makes queries faster and lets you safely open the same database across isolates or Flutter engines. On the web, new databases now default to the more performant OPFS on Chrome and Firefox. The sync and database workers are also merged into one file now, so there's less to configure and your compiled output is smaller.

We're now doing the same kind of work on the JavaScript SDK. A few open proposals and PRs give a sense of where it's headed: merging the web workers into one (same as we did in Dart), making WebSocket support an optional dependency so you don't bundle it if you don't need it, and dropping js-logger as a dependency in favor of letting you bring your own.

A good open-source SDK should be easy to use and easy to contribute to. We want both, and that's what inspired this.

That's it for this issue.