Full stack Bitcoin software

Firsts

Designs and implementations that appeared first in libbitcoin, in order, with the version that shipped each one and its first commit or publication.

2011v1

First full node independent of the Satoshi node#

Libbitcoin was announced in July 2011 and validated blocks, including the search for double spends, by October 2011, in code written from scratch rather than derived from the Satoshi node.

2011v1

First node in C++11#

Libbitcoin was written in C++11 from its first commit in May 2011, as C++0x, before the standard was ratified that August. Bitcoin Core moved from C++03 to C++11 in 0.13 (2016).

2011v1

First fully asynchronous and concurrent network design#

The network has been asynchronous since May 2011. Every connection's I/O completes on a shared thread pool, and each connection is confined to its own strand, so connections proceed concurrently without locks. Bitcoin Core runs one socket thread and one thread that handles the messages of all peers.

2011v1

First full stack development toolkit for a full node#

Libbitcoin is a set of libraries, from primitives and cryptography through the store, network and node to the server, on which its own full node is built and on which others can build theirs. Bitcoin Core's libbitcoinconsensus (2015), now libbitcoinkernel, is a partial counterpart, limited to consensus.

2011v1

First unit-testable script implementation#

The script interpreter has dispatched each opcode to its own function since July 2011, so each operation is tested in isolation.

2011v1

First node with a spender index#

Every output is indexed by the inputs that spend it, by default and since 2011. The Satoshi node internally recorded the transaction that spent each output, as its test for spent, until it replaced that with a set of unspent outputs in 2012 (Bitcoin Core 0.8). Bitcoin Core added an optional spender index in 2026.

2014v2

First and only stealth payments indexation and scanning#

A stealth address lets a payer derive a new output key for each payment from the recipient's published key, so payments to one address cannot be linked on chain. Libbitcoin implemented stealth addresses in February 2014, a month after the design was posted, and Dark Wallet was built on them. The server indexed stealth outputs and scanned them by prefix for clients, through version 3. Silent payments (BIP 352) are the same model: a one-time output key for each payment, found by a client through a server that indexes and scans for it.

2014v2

First and only node with CurveZMQ encryption#

The server encrypts and authenticates its ZeroMQ services with CurveZMQ, the ZeroMQ form of CurveCP, from 2014 through version 3, and natively in version 4.

2014v2

First node to drop OpenSSL#

Libbitcoin completed the removal of OpenSSL in August 2014. OpenSSL signature parsing had been implicitly part of consensus: when OpenSSL 1.0.0p and 1.0.1k (January 2015) stopped accepting signatures that deviate from DER, nodes linked to them rejected the chain, and BIP 66 made strict DER a consensus rule. Bitcoin Core removed OpenSSL in 0.20 (June 2020).

2014v2

First node with a purpose-built store#

In 2014 libbitcoin replaced LevelDB, which had replaced BerkeleyDB, with memory-mapped hash tables designed for the chain's own data, first released in Bitcoin Server 2.0 (2015). Bitcoin Core embeds LevelDB. Its earlier use of BerkeleyDB split the chain in March 2013, when the database's lock limit became an unintended consensus rule. gocoin's qdb (2013) is a general-purpose key-value store. rbitcoin's store (2026) was modeled directly on libbitcoin's.

2015v2

First and only node to integrate libbitcoinconsensus#

Libbitcoin-consensus packages the consensus code of Bitcoin Core, which became libbitcoinconsensus and later libbitcoinkernel, and the node could validate scripts with it in place of its own. Version 4 dropped it in 2024, after Bitcoin Core deprecated it in 27.0, and Bitcoin Core removed it in 28.0. Given the inflation consensus soft fork (2018, CVE-2018-17144) and its removal hard fork, the BIP 90 hard fork, and several similar undocumented hard forks since, as well as performance, dependency and complexity considerations, libbitcoinkernel is not incorporated.

2016v3

First and only node with consensus factored into verifiable rules#

Each consensus rule is a distinct check with its own error code, partitioned by what it requires: check (the block alone), accept (chain context and previous output values) and connect (previous output scripts).

2016v3

First and only node with configurable historical forks and protocols#

Each historical consensus fork, from BIP16 through taproot, is an individual setting, as are the range of peer protocol versions and each optional protocol message, such as alert, reject, compact blocks and witness relay. Bitcoin Core fixes its forks and protocol versions in code, allowing only test chains to move an activation height.

2017v3

First and only rolling validation context#

The context that validates a block, its height, active rules, median time past and required work, is computed from the store once and then rolled forward: each state is constructed from its parent state and the new header, without querying the store. The context requires values from many previous blocks: the timestamps of 11 for median time past, the versions of up to 1,000 for version majority (BIP 34, 65 and 66), and the signals of a 2,016-block period for version bits and speedy trial (BIP 9, and BIP 54 as libbitcoin deploys it). The rolling state carries these windows forward. When BIP 90 was proposed in November 2016 to avoid this cost, libbitcoin stated on bitcoin-dev that the cost was avoidable without a fork, and implemented the rolling state in January 2017. Bitcoin Core does not roll its state forward. To avoid the cost of version majority it hard forked BIP 90 into its rules in 2017, fixing the activation heights of BIP 34, 65 and 66, and it has since done the same for CSV and segwit without documenting the hard fork in a BIP. It derives the rest of the context by walking its block index, which holds every header in memory.

2017v3

First and only node without a transaction memory pool#

Version 3 archived unconfirmed transactions in the transaction table beside confirmed ones, in place of a memory pool. Version 4 makes the tx pool an index over the archive, store tables that are not bound by RAM and that outlive the process.

2021v4

First and only node with fail-stop reliability#

Fail-stop is the highest integrity a single component can provide: when it fails, it stops detectably, and it never returns wrong data as good. The store decides whether it closed cleanly, never whether its contents are valid. A lock held while the store is open is removed only by a close in which no storage faulted, and a store that still holds the lock is never opened or repaired. Bitcoin Core's store is fail-partial: after a crash it cannot reliably detect a fault, and cannot reliably repair an inconsistency it detects.

2021v4

First and only concurrent block validation#

Blocks are validated many at a time, across all cores and in any order, as soon as their previous outputs are known to be archived. Confirmation follows in chain order. All other nodes validate one block at a time, in order. This is why libbitcoin is the only node that can validate at a network-limited rate.

2022v4

First and only generalized hardware acceleration#

Hashing and cryptography use, on x86, SSE4.1, AVX2, AVX-512, AVX-IFMA, AVX-512 IFMA, SHA-NI, the SHA-512 extensions, AES-NI and VAES; on ARM, NEON and its SHA-2, SHA-512 and SHA-3, and AES extensions; and CUDA on NVIDIA GPUs. Each algorithm is written once, generic over vector width, and cascades from the widest available vector to scalar code, with native instructions where the processor has them. The CUDA kernels (PTX) are compiled from the same hash and cryptography source. Bitcoin Core accelerates SHA-256 (SSE4, SSE4.1, AVX2, SHA-NI and the ARM SHA-2 extensions), each a separately written implementation of the whole algorithm, and the CRC32C checksums of LevelDB (SSE4.2 and the ARM CRC extension).

2022v4

First and only variant script stack#

Each element of the script machine's stack is held as a boolean, number or byte vector, as it was produced, so standard scripts execute without type conversions. A number remains a number, never encoded to new bytes and decoded again, which eliminates costly heap allocations in the performance-critical phase of validation. All other nodes hold every element as bytes, and convert each number as it is read and written.

2022v4

First and only node to resolve the Rock and Roll quadratic script cost#

Rolling an element from deep in the stack moves every element above it, so a script of repeated OP_ROLL costs time quadratic in its size, about 5.6 seconds for one block (Lerner, 2017). Libbitcoin executes any script that contains OP_ROLL on a linked stack, on which a roll is constant time.

2022v4

First and only node with store recovery#

A store that did not close cleanly is restored to its last snapshot and resumes. Bodies are append only and head snapshots are replaced by one atomic operation, so truncating each body to the counts each head recorded returns the store exactly to a state that existed. Snapshots are taken while the node runs, from the console or the command line. Other nodes implement attempts at repair, which are provably ineffective.

2022v4

First node with a full Electrum address index#

Version 4 indexes every output by the SHA-256 of its script, the script hash of the Electrum protocol, so the node itself holds the history of any address. Electrum servers otherwise build this index outside the node. Floresta's Electrum index (November 2022) predates libbitcoin's by one month, but indexes only the addresses its wallet watches, so it is a wallet feature, not a full node index.

2024v4

First milestone sync#

Blocks at or under a configured milestone on the candidate chain are archived with identity checks, not partial validation. Identity is based on the operator's assertion of having validated to the milestone block previously. Bitcoin Core's assumevalid skips part of validation under the presumption that partial validation provides good enough security for the operator and the network, though fundamentally this is incoherent. These are distinct trust models.

2024v4

First and only hot backup of a node store#

An external backup system can copy the store's files while Bitcoin Server runs. Restored from that copy, the store recovers to its most recent snapshot, with its fail-stop guarantee intact, which a hot backup of a general-purpose database cannot provide.

2025v4

First and only node with a navigable REST object model#

The native interface navigates blocks, headers, transactions, inputs, outputs, spenders and addresses: every related object is reachable by path from any other, and a path by hash names an object that never changes, so its response is cacheable. Bitcoin Core's REST serves blocks, transactions, headers and unspent outputs, with no path from an output to its spender or from an address to its history. Esplora (2018), which is not a node, and rbitcoin's Esplora interface (2026) navigate blocks, transactions and addresses, but not inputs and outputs.

2026v4

First and only node to prune witnesses on download#

Under a milestone, blocks are requested without their witnesses, so witness data is never downloaded, and they are stored without their input scripts. Bitcoin Core downloads every witness, under assumevalid as well, and prunes only whole blocks after they are processed. rbitcoin downloads every witness, under its milestone as well, and drops witness bytes after they are stored.

2026v4

First and only signature batch capture for initial block download#

Validation matches script patterns whose outcome is determined by the success or failure of their signatures, and captures those signatures, more than 99% of all signatures, into a store-side batch, so they are verified in bulk rather than one at a time.

2026v4

First node with a silent payment index#

The node builds the BIP 352 silent payment index as it validates, so the server answers silent payment scans from its own store. BlindBit Oracle (2023) and Frigate (2025) build this index but are not nodes.

2026v4

First and only node with a per-channel continuous throttle#

Every channel, peer and service alike, is throttled to a configured send rate. Each send is allotted time in proportion to its size, and the next send waits out what the last did not use, so idle time earns no burst credit. A channel over the rate is slowed, never dropped. gocoin (2013) limits the node's total upload and download per second, which permits a burst at the start of each second. Bitcoin Core has no limit per connection. Its optional daily upload target, off by default, once reached disconnects every peer that requests a historical block or the mempool, so one peer can exhaust it for all.

2026v4

First pruned node that keeps its indexes#

A pruned store keeps its transaction, spender and address indexes. Pruning drops only the input scripts and witnesses of blocks under the milestone. Bitcoin Core cannot keep its transaction index when pruned; a change to allow it was proposed in 2026 and is not merged. btcd refuses to prune with its transaction index.

2026v4

First and only bitcoind JSON-RPC over TCP and TLS#

Bitcoin Server serves the bitcoind JSON-RPC interface over raw TCP and TLS, as well as HTTP, HTTPS, WS and WSS. Bitcoin Core serves it over HTTP only.

2026v4

First and only btcd JSON-RPC over TCP and TLS#

Bitcoin Server serves the btcd JSON-RPC interface over raw TCP and TLS, as well as HTTP, HTTPS, WS and WSS. btcd serves it over HTTP, HTTPS, WS and WSS only.

2026v4

First and only Electrum over HTTP and HTTPS#

Bitcoin Server serves the Electrum protocol over HTTP and HTTPS. The protocol names TCP, TLS and WebSocket transports, and no other Electrum server serves it over HTTP.

2026v4

First and only node to serve Electrum over WebSocket#

Bitcoin Server serves the Electrum protocol over WS and WSS from the node itself. ElectrumX (2019) and Fulcrum serve it from outside a node, and the other nodes that serve Electrum use TCP and TLS only.

2026v4

First and only Sparrow protocol over HTTP and WebSocket#

Bitcoin Server serves the Sparrow silent payment protocol over HTTP, HTTPS, WS and WSS, as well as TCP and TLS. Frigate serves it over TCP only.

2026v4

First and only Esplora over WebSocket#

Bitcoin Server serves the Esplora interface over WS and WSS, as well as HTTP and HTTPS. Esplora itself, and every other server of its interface, uses HTTP only.

2026v4

First and only hardware-accelerated compact block resolution#

A compact block names its transactions by short identifiers keyed to that block, so no index can hold them. The node hashes the witness hash columns of its whole pool across vector lanes to match each block's identifiers.

2026v4

First and only node with GPU-batched silent payment scanning#

The node scans for silent payments in batches, matching a client's scan key against the indexed tweaks on a GPU when one is present, and in vector lanes otherwise. Frigate (2025) scans on a GPU but is not a node.

2026v4

First and only node to compute its silent payment index on a GPU#

The node computes the tweak data of its silent payment index in batches on a GPU when one is present, and in vector lanes otherwise, as it validates blocks.

2026v4

First and only lock-free node#

The network, node and server, with the system library beneath them, are lock-free: no thread ever waits on another, so some thread always completes its step, whatever the scheduling of the others. In the store, reads are wait-free and archival writes are lock-free; its few blocking locks are taken only to grow a file, reorganize the chain height index or change the store's lifecycle, and the store is deadlock-free for any use of its interface. Bitcoin Core serializes its chain state and validation under one global lock (cs_main), and its network hands each message from a socket thread to a message thread through per-peer mutexes and a condition variable. btcd, Floresta, rbitcoin and satd guard shared state with mutexes and read-write locks.

2026v4

First and only node free of dependencies#

Bitcoin Server builds on the C++ standard library and the operating system alone, with no internal or external source or binary dependencies.

2026v4

First and only node to sync with milestone in under one hour#

Bitcoin Server syncs to a milestone, over the P2P network, in 14 minutes.

2026v4

First and only node to fully validate in under one hour#

Bitcoin Server syncs with full validation, over the P2P network, in 26 minutes.

Copyright © 2011-2026 libbitcoin developers