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. Seven are fully synced on testnet4 and validating new blocks 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 the same 14-point 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 the Bitcoin wire protocol, 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, mining/block template generation, script test vector validation, and testnet4 sync.

All 10 implementations compile, run, and pass the full Bitcoin Core script_tests.json suite (1,222 test vectors including taproot). All 10 mine and sync blocks via P2P on regtest. Seven — Ouroboros (Rust/Python), Rustoshi (Rust), Beamchain (Erlang), Camlcoin (OCaml), Haskoin (Haskell), Lunarblock (Lua), and Nimrod (Nim) — are fully synced on testnet4. The remaining three — Blockbrew (Go), Hotbuns (TypeScript), and Clearbit (Zig) — are actively syncing.

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 three 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.