Bitcoin Development Kits Compared: BDK, LDK, and Wallet SDKs

Bitcoin Development Kit Landscape

Building a Bitcoin wallet or payment application requires choosing the right development kit. The ecosystem offers everything from low-level cryptographic primitives to high-level SDKs that abstract away protocol complexity. Picking the wrong library can mean months of wasted integration work, missing feature support for modern Bitcoin standards like Taproot and PSBTs, or a dependency on a project that has stalled.

This comparison covers six libraries and SDKs that span the full stack of Bitcoin development: Bitcoin Dev Kit (BDK), Lightning Dev Kit (LDK), bitcoinj, rust-bitcoin, bcoin, and the Spark SDK. Each serves a different layer of the stack, from raw transaction construction to turnkey Layer 2 integration.

Overview Comparison

The following table provides a high-level snapshot of each development kit. Language, scope, and maintenance activity are the three factors that most often determine whether a library fits a given project.

Feature Matrix

Feature support determines what you can build without writing custom code. The table below compares support for key Bitcoin capabilities across each library. A "Via dep" entry means the feature is available through a dependency in the same ecosystem rather than built into the core library.

Bitcoin Dev Kit (BDK)

BDK is the most complete on-chain wallet library available today. Built in Rust by the Bitcoin Dev Kit Foundation (funded through OpenSats and Spiral grants), it provides a descriptor-based wallet architecture that supports output descriptors, Miniscript, multiple coin selection algorithms (branch-and-bound, oldest-first, largest-first), and full PSBT workflows. BDK supports Electrum, Esplora, and Bitcoin Core RPC as chain data backends.

BDK generates mobile bindings via UniFFI, providing native Swift and Kotlin packages for iOS and Android. Python bindings are also available. The project is organized into a workspace of focused crates: bdk_wallet, bdk_chain, bdk_electrum, bdk_esplora, and bdk_bitcoind_rpc. Production users include Bitkey (Block's consumer hardware wallet), ProtonWallet, Bull Bitcoin, AnchorWatch, Liana by Wizardsardine, and Alby.

BDK depends on rust-bitcoin for core Bitcoin data structures and rust-miniscript for descriptor parsing. This layered architecture means you get the benefits of rust-bitcoin's well-audited primitives without needing to assemble wallet logic yourself.

Lightning Dev Kit (LDK)

LDK provides a modular Lightning Network implementation in Rust, maintained by the Spiral team at Block. Unlike monolithic Lightning nodes such as LND or Core Lightning, LDK is designed to be embedded into existing applications. It implements BOLT specifications including BOLT12 offers, anchor outputs, keysend, and multi-path payments. LDK reportedly powers an estimated 25% of all Lightning Network volume.

LDK deliberately does not include its own networking stack, storage layer, or chain data backend. This "bring your own components" design gives developers full control but requires more integration work. The higher-level ldk-node package bundles sensible defaults (BDK for on-chain, SQLite for persistence) to reduce boilerplate, with Swift and Kotlin bindings for mobile apps. Notable production users include Cash App and Bitkit.

Simple Taproot Channels support in LDK is in active development, upgrading funding and commitment outputs from P2WSH to P2TR using MuSig2. LDK depends on rust-bitcoin and rust-secp256k1 for all Bitcoin and cryptographic primitives. For a deeper look at Lightning implementations, see our Lightning implementation comparison.

bitcoinj

bitcoinj is the oldest Bitcoin library still in active use, originally created by Mike Hearn in 2011 and currently maintained by Andreas Schildbach. Written in Java, it provides SPV verification, peer-to-peer networking, HD wallet support (BIP-32/BIP-44), and coin selection. The v0.17 release (February 2026) added the ability to send to P2TR (Taproot) addresses, though receiving and spending from Taproot outputs is not yet supported.

bitcoinj runs natively on Android and any JVM platform. It powered early Android wallets like Bitcoin Wallet (Schildbach) and remains a core dependency of Bisq, the decentralized exchange. However, the library lacks PSBT support, output descriptors, and Miniscript. With over 200 contributors and 15 years of history, bitcoinj is stable but evolving slowly. New projects targeting Android should evaluate BDK's Kotlin bindings for more modern feature coverage.

rust-bitcoin

rust-bitcoin is the foundational Rust library for Bitcoin, maintained by a community led by Andrew Poelstra (Blockstream). It provides consensus-level data structures: transactions, scripts, blocks, addresses, sighash computation, and PSBT handling. It supports Taproot/Schnorr natively and offers no_std compatibility for embedded and WASM targets. The companion crate rust-miniscript (same GitHub organization) adds Miniscript and descriptor support.

rust-bitcoin is not a wallet library. It does not manage UTXOs, perform coin selection, or connect to the Bitcoin network. It is the layer that BDK and LDK build on top of: both depend on rust-bitcoin for their core Bitcoin types. The bitcoin crate has over 12 million total downloads on crates.io, making it the most widely used Rust library in the Bitcoin ecosystem. Its CC0 (public domain) license makes it usable in any context without attribution requirements.

bcoin

bcoin is a full Bitcoin node implementation written in JavaScript for Node.js. It includes an SPV mode, wallet functionality, an indexer, and JSON-RPC and REST APIs. The Handshake (HSD) project was forked from bcoin. Originally sponsored by Purse.io, bcoin's development has effectively stalled: the last tagged release (v2.2.0) was in November 2021, and the last commit on master was in August 2023.

bcoin has no Taproot support, no PSBT support, and no Miniscript. With 114 open issues and no recent triage activity, it should not be chosen for new projects. Developers working in JavaScript or TypeScript who need on-chain Bitcoin functionality should look at bitcoinjs-lib (a lighter alternative) or consider the Spark SDK for L2 functionality.

Spark SDK

The Spark SDK operates at a different layer than the on-chain libraries above. Spark is a Bitcoin Layer 2 protocol built by Lightspark that provides instant, fee-free transfers between Spark users using a statechain-based architecture with FROST threshold signatures. The SDK is available in TypeScript (via npm as @buildonspark/spark-sdk), Kotlin (Android), and Swift (iOS). The Breez Spark SDK adds Rust, Python, Go, Flutter, and C# bindings.

The Spark SDK complements libraries like BDK and LDK rather than replacing them. A wallet application might use BDK for on-chain UTXO management, LDK for Lightning channel management, and the Spark SDK for fast off-chain transfers and stablecoin functionality (including USDB). Spark uses Taproot internally for its virtual transaction output (VTXO) model, but the SDK abstracts this away so developers interact with simple send/receive APIs. Over 20 production integrations are live, including Cake Wallet, Xverse, and Deblock. For a broader view of wallet SDK options, see our wallet SDK comparison and crypto wallet SDK landscape.

Language Bindings and Mobile Support

Mobile wallet development is one of the primary use cases for these libraries. Language binding availability often determines which libraries are practical for a given project.

BDK and LDK both use UniFFI to generate bindings from Rust, which provides type-safe interfaces with minimal overhead. The Spark SDK offers native implementations for each platform, plus the Breez Spark SDK extends coverage to Rust, Flutter, Go, and C#. bitcoinj's Java codebase runs directly on Android but has no path to iOS. For developers building cross-platform embedded wallets, BDK plus the Spark SDK covers both on-chain and L2 functionality across iOS and Android. See our research on embedded wallets on Bitcoin for architectural patterns.

Full-Featured SDKs vs. Low-Level Libraries

The choice between a full-featured SDK and a low-level library comes down to control versus speed of development. Here are the key tradeoffs:

Full-featured SDKs (BDK, LDK, Spark SDK):

• Faster time to working prototype
• Wallet logic, coin selection, and chain sync handled for you
• Mobile bindings reduce platform-specific code
• Opinionated architecture limits customization
• Larger dependency tree and binary size

Low-level libraries (rust-bitcoin, bitcoinj, bcoin):

• Full control over transaction construction and signing
• Smaller dependency footprint
• Requires writing your own wallet, sync, and storage logic
• Longer development timeline to reach feature parity
• Better suited for custom protocols or non-standard use cases

Most production wallets combine both approaches. A typical architecture uses rust-bitcoin (via BDK) for on-chain operations and layers a higher-level SDK on top for L2 functionality. The Bitcoin development tools landscape provides a broader view of the tooling ecosystem beyond wallet SDKs.

How to Choose a Bitcoin Development Kit

If you are building an on-chain Bitcoin wallet with modern standards (descriptors, Taproot, PSBTs): use BDK. It provides the most complete wallet library with the best mobile binding support. Production wallets like Bitkey and ProtonWallet validate this approach.

If you are adding Lightning Network support to an existing application: use LDK. Its modular design lets you integrate Lightning without running a separate node process. The ldk-node package reduces integration complexity for common use cases, and Cash App demonstrates LDK at scale.

If you need a JVM-based library for an existing Java/Kotlin codebase: bitcoinj still works for basic SPV wallets, but BDK's Kotlin bindings are a stronger choice for new projects that need Taproot spending and descriptor support.

If you need low-level transaction construction with maximum control: use rust-bitcoin directly. It gives you consensus-level primitives without wallet-layer opinions.

If you want instant Bitcoin transfers, Lightning interop, and stablecoin support: the Spark SDK provides L2 functionality that complements on-chain libraries. It is particularly suited for embedded wallet use cases where speed and low fees are priorities.

If you are building in JavaScript/TypeScript: avoid bcoin for new projects due to dormant maintenance. Consider bitcoinjs-lib for on-chain needs or the Spark SDK (TypeScript) for L2 functionality.

Dependency Relationships

Understanding how these libraries relate to each other helps avoid redundant dependencies and version conflicts. rust-bitcoin sits at the foundation: both BDK and LDK depend on it for core Bitcoin data structures (BDK pins bitcoin ^0.32.8, LDK pins bitcoin ^0.32.2). The rust-secp256k1 crate provides the elliptic curve cryptography layer that all three use for signing.

BDK additionally depends on rust-miniscript (v12.3+) for its descriptor-based wallet model. The ldk-node higher-level package optionally depends on BDK for on-chain wallet management, creating a clean separation: rust-bitcoin handles primitives, BDK handles on-chain wallet logic, and LDK handles Lightning protocol state. The Spark SDK operates independently, communicating with the Spark protocol layer rather than constructing raw Bitcoin transactions.

Frequently Asked Questions

What is the best Bitcoin development kit for building a wallet?

For most new wallet projects, BDK (Bitcoin Dev Kit) is the strongest choice. It provides a descriptor-based wallet with PSBT support, multiple coin selection algorithms, Taproot compatibility, and native Swift/Kotlin bindings for mobile. BDK is actively maintained by the Bitcoin Dev Kit Foundation with funding from OpenSats and Spiral (Block). Production wallets like Bitkey, ProtonWallet, and Liana are built on BDK.

What is the difference between BDK and LDK?

BDK handles on-chain Bitcoin wallet operations: UTXO management, coin selection, transaction construction, and signing. LDK handles Lightning Network protocol operations: channel management, payment routing, invoice creation, and HTLC resolution. They serve different layers of the Bitcoin stack and are often used together. The ldk-node package can optionally use BDK for its on-chain component.

Is bitcoinj still maintained?

bitcoinj is still maintained and received a v0.17 release in February 2026 that added Taproot send support and Signet compatibility. However, its feature set trails Rust-based alternatives: it lacks PSBT handling, output descriptors, and Miniscript. Existing projects like Bisq continue to rely on it, but new JVM-based wallet projects should evaluate BDK's Kotlin bindings for modern feature coverage.

Can I use BDK and the Spark SDK together?

Yes. BDK and the Spark SDK are complementary. BDK manages on-chain Bitcoin (L1) operations: receiving funds, building transactions, and managing UTXOs. The Spark SDK handles L2 operations: instant off-chain transfers, Lightning send/receive, and token functionality like USDB. A wallet application can use both to offer users the full range of Bitcoin capabilities. For more on combining wallet SDKs, see our wallet SDK research article.

What programming language should I use for Bitcoin development?

Rust has become the dominant language for new Bitcoin library development. BDK, LDK, and rust-bitcoin are all Rust-native, with bindings generated for other languages via UniFFI. Rust's memory safety, performance, and strong type system make it well-suited for cryptographic code. That said, mobile developers typically interact with Swift or Kotlin bindings rather than writing Rust directly. If your team is JavaScript or TypeScript-focused, the Spark SDK provides a native TypeScript experience for L2 functionality.

Does BDK support Taproot and Schnorr signatures?

Yes. BDK has full Taproot and Schnorr signature support through its dependency on rust-bitcoin and rust-secp256k1. BDK can create and spend from P2TR (Pay-to-Taproot) outputs, construct Tapscript spending paths, and handle key-path and script-path spends via descriptors. BDK made the first-ever mainnet OP_CHECKSIGADD transaction.

What happened to bcoin?

bcoin was a full Bitcoin node implementation in JavaScript, originally sponsored by Purse.io. After Purse.io shut down, bcoin's development effectively stalled: the last tagged release (v2.2.0) was November 2021, and the last commit was August 2023. It does not support Taproot, PSBTs, or Miniscript. While the Handshake (HSD) project was forked from bcoin and remains active, bcoin itself should not be used for new projects.

This tool is for informational purposes only and does not constitute financial or technical advice. GitHub statistics, feature support, and maintenance status are approximate and based on publicly available information as of mid-2026. Library capabilities change with each release. Always verify current documentation and release notes before selecting a development kit for production use.