About Hashhog

Bitcoin's protocol is one of the most demanding distributed systems ever deployed. It combines cryptography, networking, game theory, and consensus into a single protocol that must produce identical results across every implementation, every time. A single deviation means a chain split.

We wanted to know: can you implement Bitcoin correctly in Rust, Go, TypeScript, Erlang, OCaml, Zig, Haskell, Lua, and Nim? Not by wrapping Bitcoin Core or linking to its libraries, but by writing every line from scratch — serialization, cryptographic verification, script interpretation, P2P networking, block validation, UTXO management, mempool, RPC, wallet, and mining.

The answer is yes. All 10 implementations pass 100% of Bitcoin Core's 1,222 consensus test vectors, including the full taproot suite. All 10 are now at the Bitcoin mainnet chain tip, validating every new block in real time.

Every language forces different design decisions. Erlang's supervision trees handle crash recovery naturally. Rust's ownership model prevents entire classes of memory bugs. Haskell's type system makes invalid states unrepresentable. Zig's comptime evaluation eliminates an entire category of runtime overhead. Lua, running on LuaJIT, proves that even a scripting language can handle consensus.

The hardest part isn't any single feature — it's the intersection of all of them. Script evaluation must match Bitcoin Core exactly across thousands of edge cases. P2P networking must handle malicious peers, network partitions, and protocol versioning. Block validation must enforce every consensus rule from the genesis block through every soft fork to the present day.

Every implementation covers 30+ BIPs and a comprehensive feature checklist: wire serialization, cryptographic primitives (SHA-256, RIPEMD-160, secp256k1, Schnorr), a complete script interpreter (including SegWit v0 and v1/taproot), P2P networking with BIP324 encrypted v2 transport, full block validation, UTXO set management, header-first sync, initial block download, mempool with fee estimation, a Bitcoin Core-compatible JSON-RPC server, HD wallet support (BIP-32 / BIP-39 / BIP-44 / BIP-86) with PSBT, taproot key-path signing in 8 of 10 implementations and full tapscript signing in the flagship, mining/block template generation, script test vector validation, and mainnet sync.

All 10 implementations are at the Bitcoin mainnet chain tip — Rustoshi (Rust), Blockbrew (Go), Clearbit (Zig), Nimrod (Nim), Camlcoin (OCaml), Beamchain (Erlang), Hotbuns (TypeScript), Ouroboros (Rust/Python), Lunarblock (Lua), and Haskoin (Haskell). Each node validates every new block independently from genesis up through the current tip, running side by side on the same fleet.

Every node has passed through testnet4, regtest, and the full Bitcoin Core script_tests.json suite before being activated on mainnet. All 10 nodes are alive with zero known blocking bugs. Each implementation also exposes a Bitcoin Core-byte-parity gettxoutsetinfo RPC, so cross-implementation UTXO state can be compared deterministically against Core itself.

The wallet stacks are the most active edge today. Every implementation ships a working HD wallet with BIP-32 derivation, BIP-39 mnemonic backup, BIP-44 path conventions, and ECDSA signing for legacy P2PKH, native SegWit (P2WPKH / P2WSH), and the P2SH-wrapped variants. Eight of the ten also sign Taproot key-path (BIP-340 + BIP-341 + BIP-86) inputs, with full tapscript script-path signing currently shipping in Haskoin.

The Node Runner orchestrates builds across all projects using the Claude Agent SDK, managing multi-phase development with language-specific skill injection.

Every implementation was built with AI-assisted development using Claude (Anthropic). The process was iterative: write code, run tests, debug failures, repeat. Claude handled the bulk of code generation while a human directed architecture decisions, chose languages and storage backends, and validated correctness against Bitcoin Core.

Development followed four phases:

The hardest bugs were always in script evaluation edge cases — off-by-one errors in OP_CHECKMULTISIG, sighash serialization differences between SegWit versions, and subtle encoding issues with BIP-341 taproot annex handling. Each language surfaced different classes of bugs: Haskell's laziness caused unexpected evaluation order in consensus-critical code, Erlang's binary pattern matching silently truncated malformed scripts, and Zig's comptime evaluation required careful handling of variable-length Bitcoin structures.

Every implementation is open source under the MIT license. Browse the code, contribute features, or use them as reference implementations for learning Bitcoin internals.