Ditto is thrilled to announce the public preview of our new Java Server SDK, a major expansion of the Ditto platform into the enterprise Java ecosystem. This SDK is purpose-built for enterprise Java applications and extends our real-time data synchronization platform beyond mobile and web into server and desktop environments. With the Java Server SDK, enterprise teams can now integrate Ditto’s offline-first, peer-to-peer data sync capabilities natively into Java backend services, cloud platforms, and desktop apps – marking a significant broadening of our platform support.

Built on Kotlin Multiplatform for Speed and Reliability

Over the past several months, our engineering team has been laying the groundwork for this release through extensive work on Kotlin Multiplatform (KMP). This effort initially modernized our Android SDK and enabled it to run across multiple targets, including server and desktop. By leveraging a solid KMP foundation, we were able to reuse battle-tested, cross-platform components from the Android SDK and rapidly develop the new Java Server SDK without compromising quality. In short, the heavy lifting we invested in KMP is paying off – it allowed us to bring a full-featured Java SDK to market in a fraction of the time, all while adhering to our high engineering standards for reliability and performance.

A Natural Java-First API for Enterprise Developers

One of the highlights of the new SDK is its Java-first API design. Rather than exposing a Kotlin-centric API or forcing Java developers to adapt to Kotlin idioms, we built this SDK’s interface with pure Java in mind. The result is an API that feels natural to Java developers. By providing a true Java-native API, we aim to lower the learning curve and integrate seamlessly into existing enterprise Java stacks (e.g. Spring Boot, Jakarta EE). This Java-first approach ensures that Java teams can adopt Ditto with minimal friction, using the languages and tools they know best.

Major Feature Parity in a Public Preview Release

Even though this is a “public preview” release, the Java Server SDK is already major feature-complete and compatible with Ditto’s other SDKs (Java Roadmap & Support Policy - Ditto). In practical terms, Java developers have access to the same core capabilities that Ditto offers on mobile (Swift, Kotlin) and other platforms – including real-time data sync, peer-to-peer mesh networking, conflict-free data types (CRDTs), live queries, and robust offline support. This cross-compatibility means you can build Java services that sync and share data effortlessly with your mobile and web clients using Ditto.

That said, we do consider this a preview. APIs may evolve based on feedback, and we anticipate some breaking changes before the final 4.11 release. We’re following an iterative approach: ensuring stability for early adopters while remaining agile enough to refine the API. Early testing indicates the SDK is stable, but we want to be transparent that the API is not frozen yet. We will communicate any breaking changes in our release notes as we progress toward the 4.11 stable release.

Comprehensive Documentation and Guides

To help you get started quickly, we have prepared a full suite of documentation and learning resources for the Java Server SDK:

• Java Server SDK Overview & Setup Guide – Covers prerequisites and how to add Ditto to your Java projects. This guide shows how to include the SDK via Gradle and configure your environment.
  
• Java Spring Quickstart App – A step-by-step quickstart (with a sample Spring Boot application) to demonstrate using Ditto in a Java server context. You can clone the Quickstart repo, run the Spring Boot app, and see real-time sync in action via a simple web interface.
  
• Java Roadmap & Support Policy – Details on the SDK’s preview status, including expectations around API changes and our commitment to support. (It also outlines how long-term support will work once the SDK is stable.)
  
• Release Notes – The official release notes for 4.11.0-preview.1 describe the new Java support and any other changes. This is the best place to track incremental updates and fixes during the preview.
  

Java API Reference – A complete reference for all classes, methods, and data structures in the Java SDK, for those who want to dive into the details of the API.

All these resources are available on our documentation site as of today. We encourage you to read the overview guide and try out the quickstart app to familiarize yourself with the SDK. The API reference and release notes will be useful as you integrate Ditto into your projects.

Ready for Early Production Use (with Enterprise Support)

We know that many of our customers are eager to deploy Ditto in production backends and desktop applications. In fact, several design partners have already begun integrating it. Our Customer Experience team is ready to support any enterprise customers who want to pilot the Java SDK in a production environment. During this preview phase, we recommend working closely with our team to ensure a smooth integration. We’ll offer guidance on best practices, help triage any issues, and provide workarounds if needed. Your success is our priority, and we’re confident that with the proper support, the Java SDK can power real-world applications even before its official GA (General Availability) release.

Do keep in mind that because this is an early access release, you should plan for the possibility of minor updates or adjustments as we approach the final 4.11. However, our team will assist in any required changes, and we don’t anticipate any fundamental shifts that would undermine a well-architected integration. In short, you can start building with Ditto Java now and be production-ready, especially with our team backing you up.

Reduce Binary Footprint with Selective Binaries

The Ditto Java SDK uses native libraries under the hood for each platform (to interact with the operating system for networking, storage, etc.). By default, when you include the SDK, you get binaries for all supported platforms. However, enterprise apps often target a specific server OS and architecture, and including unnecessary binaries can increase your application size. We offer a way to trim the binary footprint by including only the platform-specific binary you need.

For example, if your Java server app will only run on Windows x64, you can declare the dependency in Gradle with a capability filter to pull in only the Windows binary:

implementation('live.ditto:ditto-binaries:4.11.0-preview.1') {
    capabilities {
        requireCapability('live.ditto:ditto-binaries-windows-x64')
    }
}

In the above snippet, instead of bringing in all binaries, we require only the Windows x64 binary. Similar options exist for macOS (both Intel x64 and Apple Silicon) and Linux (coming soon). By tailoring the binaries to your deployment platform, you can significantly reduce the size of your final JAR/WAR package. See the Install Guide for more details on optional binary dependencies.

If you prefer simplicity over size, you can alternatively include live.ditto:ditto-java:4.11.0-preview.1 which bundles support for all platforms by default. However, the capability approach is recommended for production deployments to cut down on application size.

Upcoming Improvements on the Roadmap

We are actively working on enhancements and additional support based on feedback. Some upcoming improvements planned for the Java SDK (on the roadmap leading to the 4.11 GA) include:

• Kotlin Multiplatform (KMP) support – We know some of you are interested in integrating Ditto into your own user-facing mobile apps powered by KMP. We will be releasing a preview of our KMP support for Android, iOS, and Linux. Stay on the lookout for KMP support next quarter.
• API Consistency Improvements – Unifying asynchronous patterns. Currently, the SDK uses a mix of futures, callbacks, and blocking calls; we aim to streamline this for a more consistent developer experience. Future updates will likely introduce a more uniform async API (potentially embracing Java’s CompletableFuture or reactive streams more broadly).
• JDK 11 Support – At present, the SDK requires Java 17. We recognize many enterprise environments still run on Java 11, so we’re working to extend support to JDK 11. This will broaden compatibility with legacy systems.
• Linux x86_64 Support – The preview release supports Windows (x86_64) and macOS (Intel and Apple Silicon). We plan to add Linux x86_64 binaries in an upcoming preview update, enabling full support for running Ditto on Linux servers and devices.
  
  

These improvements are in progress and expected soon. We’ll keep the community updated via release notes as each of these enhancements comes to fruition.

Join the Preview & Share Your Feedback

The release of the Ditto Java Server SDK in public preview is a major milestone in our mission to support resilient sync everywhere - and on every platform. We invite you to try out the SDK, kick the tires, and let us know what you think. Your feedback is incredibly valuable – it will help us polish the API, squash any remaining bugs, and ensure the GA release meets your needs. Feel free to reach out to our team with any feedback or questions (our engineers are standing by on our support channels).

We look forward to working with our community and customers as we drive toward the 4.11 release and beyond. Happy coding, and welcome to Ditto for Java 🎉.

‍