The Secret to our Mobile SDKs

Side Channel – Where Ledger engineers talk about how they design, build, and scale our systems.

---

In the Web3 world, our hardware wallets have become essential for millions of users who want to secure their digital assets. This trust is built on the excellence of our products and the robustness of the software that supports them.

Security isn’t just a feature; it’s the essence of our products. This requirement becomes even more critical when our partners need tools to interact with our products and sign transactions.

Before you dive in: 

• Kotlin MultiPlatform (or KMP) is a technology that enables the sharing of business logic across multiple platforms, including Android, iOS, Desktop and Web. At Ledger, we leverage KMP to unify our logic between mobile applications.
• This article isn’t a comprehensive guide on how to create a Kotlin Multiplatform library from scratch. Instead, we’ll share our real-world experience at Ledger and explain why KMP was the right choice for us.
• This article isn’t just for experienced mobile developers; it’s for anyone who’s struggling with code duplication and is looking for an elegant, sustainable solution.
• As of the publication of this post, our project is still a work in progress, with new features currently under development.

Our Dilemma: Develop Twice or Innovate Once?

Many partners have asked us for development kits to interact with our wallets. For mobile, we had two options to meet this demand: develop two native SDKs (one in Kotlin for Android and one in Swift for iOS), or adopt a smarter approach to move faster.

We knew that a “platform-by-platform” approach would be a never-ending race of duplication, a source of errors, and an inefficient use of time. The slightest change in business logic would have to be manually replicated across all platforms, which increased risks. That’s why, based on our available resources, we adopted an elegant and powerful solution that changed the way we work: Kotlin Multiplatform (KMP).

Introducing Kotlin Multiplatform (KMP)

Kotlin Multiplatform (KMP) is a technology that allows developers to build a codebase using the Kotlin language that can be shared across multiple platforms while still being able to access platform-native libraries and tools.

Some of the advantages of using KMP include:

• A single codebase for business logic and shared functionality, such as hardware communication, networking, and parsing.
• Business logic across platforms is handled in a single location, which reduces the testing burden on developers as unit tests can be run for both platforms simultaneously.
• The Kotlin code is directly compiled into native code (Kotlin for Android and Objective-C for iOS). The Objective-C will be replaced by Swift in a couple of months.
  

Note on Swift Export: While iOS targets currently use Objective-C interop, direct swift export is currently in an experimental phase and promises even more seamless integration in the coming months.

Some of the challenges of integrating KMP include:

• For now, Kotlin code is compiled in Objective-C for the iOS target

• Not all libraries have a Kotlin-based equivalent, but this can be solved with platform-specific code using the expect/actual pattern. This pattern allows us to define a common interface in the shared code (expect) and provide platform-specific implementations (actual) for Android and iOS.
• Some iOS libraries are only exported in Swift and cannot be directly used in KMP but this can be solved by creating an Objective-C bridge 

KMP in Practice at Ledger: Less Code, More Features

To make it easier for our partners to integrate our products, we decided to develop different SDKs, each with a clearly defined responsibility

As you can see in the diagram below, our architecture is designed to maximize code sharing. 

The Device Management Kit, for instance, which is responsible for communicating with our devices, contains the complex core logic for ApduParsing and DeviceActions. These are shared across platforms, while the specific implementations for USB and Bluetooth communications are handled by native libraries. This allows us to maintain a single source of truth for our business logic while leveraging the unique capabilities of each platform

The same principle applies to our Ethereum Signer, where Clear Signing and Transaction Check are also part of the shared KMP layer. It includes complex features for extracting data from the Application Binary Interface (ABI) or Recursive Length Prefix (RLP) and relies on platform-specific libraries when necessary.

Our main architecture is still evolving, but this logic will be applied to our future signers for other blockchains, like the Bitcoin Signer, the Solana Signer and more. 

Implementing these features at the KMP level has significantly reduced development time and shortened the business logic learning curve for developers.

Finally, to ensure everything works as expected, each component is thoroughly unit tested.

From Duplication to Innovation

Kotlin Multiplatform has transformed our approach to development at Ledger. We’re no longer in a cycle of duplication and heavy maintenance. Instead, we are focused on innovation and optimization.

This shift has enabled us to develop features for our partners more quickly, despite having a small mobile team, while significantly improving our code quality.

Although many technologies enable code sharing across multiple platforms (such as React Native, to name just one), KMP proved to be the superior choice for our native mobile SDKs. Our specific requirements—direct communication with hardware via USB and Bluetooth—demand the high performance and low-level access that only native compilation can provide.

Because Kotlin Multiplatform code compiles directly into native binaries, it is more easily optimized and integrated into native projects without the overhead of a JavaScript bridge. This approach offers our partners the best of both worlds: the efficiency of shared logic with the power of a truly native experience and the flexibility to build their applications either entirely in native code or entirely with Kotlin Multiplatform (KMP and Compose Multiplatform). 

In either case, they can seamlessly integrate our SDKs, as we deliver Android, iOS, and Kotlin Multiplatform versions.

---

Sanders MARTINE – Staff Android Engineer ( X / Linkedin)