Published OnMay 11, 2026May 11, 2026

Ditto SDK v5: Built for Speed and Developer Experience

Automatic performance improvements, unified DQL across all platforms, and modern developer-friendly APIs make this the fastest, most extensively tested Ditto release yet.


Intro — Ditto v5

Today, we're thrilled to announce Ditto SDK v5.0.0 — the most significant evolution of our edge sync platform since launch. This isn't just an incremental update. It's a complete rearchitecture that delivers faster performance, simpler APIs, and a modern foundation for building the next generation of edge applications.

After three years of powering mission-critical applications in retail, healthcare, logistics, and beyond, we've taken everything we've learned and rebuilt the SDK from the ground up.

v5 Features — Ditto
Faster apps

Automatic performance improvements across queries and sync — your users notice the difference with zero code changes.

More responsive apps
Query planner optimizations and shared statement caching kick in automatically
Lower sync latency
Improved storage architecture and session handling get data where it needs to be, faster
Better developer experience

Clean initialization, schema-free iteration, platform-native APIs, and clearer error messages. Your team ships faster.

Simpler initialization
Clean, modern patterns replace confusing legacy APIs across all platforms
No more schemas
Start building immediately; iterate faster with field-level sync
Error messages that help
Clearer diagnostics mean less time debugging, more time building
Production observability

Query internal metrics and debug issues without external tools. Solve production problems in minutes, not hours.

Built-in observability
Query system metrics and configuration directly with DQL
Faster device reconnection
Better session handling gets devices back online after network interruption
Simpler codebases

One query language, cleaner APIs, 25% smaller SDK. Less code to maintain means more time building features.

One query language
DQL handles all data operations consistently across mobile, web, and server
25% smaller SDK
Removed legacy code means faster startup and smaller bundle sizes
Future-proof foundation

Modern networking, platform modernization, extensible architecture. Built for the next 3+ years of edge computing.

Future-ready networking
Modern transport architecture for tomorrow's edge connectivity and mesh topologies
Most rigorously tested release
44 scenarios, 9 builds, 40+ concurrent devices, 24-hour stability runs
Lower risk migrations

AI-powered tools, backwards compatibility, and incremental rollout support. Deploy with confidence.

Backwards compatible with v4.11+
Mixed-version meshes sync seamlessly; deploy incrementally with zero downtime
Comprehensive migration guides
Step-by-step guides for every platform with before/after examples, common pitfalls, and testing checklists
AI migration scripts
Platform-specific tools that intelligently transform v4 patterns to v5 equivalents with a 90%+ success rate
Performance — Ditto v5
Faster Apps
Fastest Data Store & Sync Engine Yet

Performance improvements you'll actually notice — and you get them for free.

Intelligent Query Planning

v5 introduces an intelligent query planner with automatic optimization. Your queries run faster without changing a single line of code.

Automatic ID Scan Conversion
The query planner detects when queries can use document ID scans instead of full collection scans, dramatically reducing execution time for common patterns
Deferred Document Fetching
For queries that only need specific fields, v5 defers fetching full documents until absolutely necessary, reducing memory overhead and I/O operations
Covering Index Improvements
Enhanced covering index support means more queries can be satisfied entirely from indexes without touching document data
Shared Statement Cache
Query plans are automatically cached and reused across executions. The database gets smarter the more you use it, with automatic invalidation when schemas change
Streaming Execution
Operators like DISTINCT now stream results instead of buffering everything in memory. Operator inlining reduces intermediate allocations — lower memory usage on constrained devices
Next-Level Sync Performance
Tiered Blob Storage
Intelligent storage tiering keeps frequently-accessed data hot and moves cold data to efficient storage. Smaller sync updates avoid unnecessary disk I/O as datasets grow
Improved Session Handling
Better reconnection logic minimizes session resets when devices rejoin the mesh. Users get back online faster with less wasted bandwidth re-syncing data they already have
Optimized fsync Policy
Document sync operations avoid forcing files to disk by default, dramatically reducing latency on mobile devices where disk I/O is expensive
These performance gains are automatic. Upgrade to v5 and your app gets faster — no code changes required.
DX Reimagined — Ditto v5
Developer Experience
Developer Experience Reimagined

v5 isn't just faster — it's fundamentally easier to work with. We've rebuilt the SDK around modern platform conventions and simplified every API surface.

Clean, Config-Based Initialization

Gone are the days of tangled initialization code mixing connection, authentication, and configuration logic. v5 introduces a clean, predictable initialization pattern with clear separation of concerns:

Configure Initialize Authenticate Sync

Type-safe configuration with compile-time validation means fewer runtime surprises. No more workaround patterns like disableCloudSync = true or updateTransportConfig hacks. Just clean, explicit, easy-to-reason-about setup.

Swift
// Configure
let config = DittoConfig(databaseId: "my-app")
    .persistenceDirectory(path)
    .minimumLogLevel(.info)

// Initialize
let ditto = try DittoFactory.create(config)

// Authenticate
ditto.auth.expirationHandler = { /* handle token refresh */ }
await ditto.auth.login(provider, token)

// Sync
await ditto.sync.start()

Clear, explicit, and simple to configure.

Schema-Free Mode by Default

Ship features faster with field-level data sync that requires minimal schema definitions. Unlike v4's strict whole-object replacement semantics, v5 defaults to schema-free mode where changes merge intelligently at the field level.

Automatic type inference means you can iterate rapidly without writing complex schema migrations or managing database versions. Define schemas only where you need them (like attachments and counters), and let Ditto handle the rest.

Faster prototyping, quicker iteration cycles, and less time fighting your database. Start building immediately — add structure as your application evolves.

Platform Modernization Across the Board

We've rebuilt each SDK to embrace modern platform conventions, making Ditto feel truly native on every ecosystem:

Swift 6 & Modern Concurrency
Full Swift 6 support with modern async/await patterns replacing callbacks. Swift Package Manager is now the only distribution method, eliminating CocoaPods complexity.
Kotlin Flow & Multiplatform
Completely rewritten from scratch using Kotlin Multiplatform. Legacy callback patterns are replaced with elegant Flow-based reactive streams — native Kotlin architecture, not a C library wrapper.
.NET 8 & Immutable Patterns
Target the latest .NET 8 runtime with immutable configuration patterns and modern C# idioms. LINQ-style queries, compile-time safety, and familiar patterns for C# developers.
Zero Dependencies in JavaScript
All external dependencies removed from the JavaScript SDK. Smaller bundles, faster load times, and zero npm audit warnings. Your web apps ship lighter and start faster.
Enhanced Error Messages That Actually Help

We've completely overhauled error reporting across the SDK. Clearer DQL parser errors, improved diagnostics, and more actionable error messages mean less time debugging and more time building.

When something goes wrong, you'll know exactly what happened and how to fix it. No more cryptic error codes. No more hunting through stack traces. Just clear, actionable guidance.

Observability — Ditto v5
Observability
Production-Ready Observability

We've extended the ability to query your Ditto instance's internal state using DQL itself. v5 introduces virtual collections that expose runtime metrics, configuration, and performance data — no external tools, no log aggregation delays. Just write a DQL query and get the answers you need.

What You Can Query
system:system_info
Inspect your Ditto configuration and runtime parameters. Verify settings, check platform info, and validate deployment configurations — all via DQL.
SELECT * FROM system:system_info
system:request_history
Query the history of requests processed by the Ditto store, including execution metadata and error details.
SELECT * FROM system:request_history
system:shared_statements
Examine the query plan cache to understand which queries are being reused and optimize frequently-run patterns.
SELECT * FROM system:shared_statements
Debug Production Issues Without External Tools

No more shipping special debug builds or waiting for log aggregation. Just write a DQL query and get the answers you need, right from within your application.

DQL
-- Query all active subscriptions
SELECT * FROM system:system_info
WHERE starts_with('local_subscriptions', key)

These virtual collections are local-only — never replicated across the mesh — making them perfect for monitoring, debugging, and understanding exactly what Ditto is doing in production.

Enhancing Remote Query With Virtual System Collections

Combine v5's virtual collections with the Ditto Portal's remote query feature to debug production issues from your desk. Query system:system_info on any device in your fleet in real-time — no SSH access, no app updates, no special debug builds.

Investigate a customer-reported performance issue by running DQL queries directly against their device to inspect query execution times, check configuration settings, or examine the query plan cache. It's like having a SQL console into every device in your deployment.
DQL, Testing & Migration — Ditto v5
DQL
DQL Everywhere: One Query Language to Rule Them All

Say goodbye to maintaining multiple query systems. Ditto v5 makes DQL the single data API across every platform — mobile, web, and server. We've removed the legacy query builder and retired 62+ deprecated APIs across 7 languages, leaving you with one powerful, unified interface.

If you know SQL, you already know DQL. Familiar SELECT, INSERT, UPDATE, and DELETE syntax means faster onboarding and zero context switching between platforms.

What's New in v5 DQL
CASE Statements & BETWEEN
Build conditional logic directly in queries with SQL-familiar CASE/WHEN/ELSE syntax. Filter ranges elegantly with BETWEEN for cleaner, more readable queries
Array & Object Search
Use ANY and EVERY operators to search within arrays and objects — perfect for querying tags, filtering product attributes, or searching nested data structures
Array & Object Transformation
New syntax for transforming arrays and objects directly in DQL, enabling powerful data manipulation without pulling data into your application layer
Extended String Literals & Hex Constants
Better support for complex string patterns and binary data, making it easier to work with real-world datasets
Write queries once, deploy everywhere. Your team moves faster, your codebase stays cleaner, and your developers stay productive.
Testing
Most Tested Release in Ditto History

This isn't a "move fast and break things" release. This is production-ready, battle-tested infrastructure you can trust.

40+
Concurrent Devices
iOS, Android, and heterogeneous platform mixes
24hr
Stability Runs
Continuous load — memory, connections, long-running behavior
44
Test Scenarios
Every platform, transport, and deployment combination
9
Build Configs
Each scenario validated across 9 build configurations
Real Data, Real Networks
Dataset Validation
Tested from 1MB datasets to 50MB+ product catalogs, retail inventories, and healthcare records — real customer data patterns, not synthetic test data
Network Condition Testing
LAN, BLE, WiFi Aware, AWDL, and mixed transport scenarios. Network partitions, poor connectivity, intermittent failures — we've tested it all
Lifecycle Edge Cases
Background/foreground transitions, crash recovery, memory pressure, connection churn — the cases that break normal databases don't break v5
We've done the hard testing so you can deploy with confidence. Extensively validated heterogeneous meshes mixing v4.11+ and v5 devices. Deploy incrementally, validate in production, rollback if needed.
Migration
Migration Made Simple

We know migrations can be daunting. That's why we've built tools and strategies to make the v4 → v5 transition as painless as possible.

AI-Powered Migration Assistants
90%+ Automated Success Rate
Migration scripts achieve very high success rates across internal complex applications, extensively tested on real-world codebases including our own sample apps and customer projects
Platform-Specific Intelligence
Each platform's migration tool understands the nuances of Swift, Kotlin, C#, JavaScript, and Rust — transforming callbacks to async/await, updating imports, handling platform-specific patterns
Incremental Migration Strategy
Backwards Compatible
Run v4.11+ and v5 devices in the same mesh. Your iOS v5 app syncs perfectly with Android v4 devices and web clients still on v4.14
No Downtime Required
Deploy to a subset of devices, validate with real traffic, and expand at your own pace. No risky big-bang deployments
Rollback Safety
Redeploy your v4 build to rollback. Data remains intact — no format changes — and the mesh continues syncing seamlessly
Migration Guides by Platform
Detailed before/after code examples
Common pitfalls and how to avoid them
Testing strategies specific to your platform
Checklists to ensure nothing is missed
Comprehensive AI scripts for quick migration
Get Started
Get Started with v5 Today

Ready to experience the future of edge sync?

Welcome to Ditto v5
The Edge Just Got Faster
Faster performance, simpler APIs, and built-in observability combine to create the best developer experience we've ever shipped. The future of edge sync is here.

Read more
April 19, 2026
Building an LLM Wiki for Ditto: How a Mac Mini Became My Second Brain
by
Adam Fish
How I built a Karpathy-style LLM wiki for Ditto on a Mac mini with Claude Code skills and local hybrid search. Template on GitHub.
April 16, 2026
We Built a Browser Robot Because Webflow's API Can't Handle a Code Block
by
Adam Fish
We Built a Browser Robot Because Webflow's API Can't Handle a Code Block