About Hashhog
Hashhog is 10 Bitcoin full node implementations, each built from scratch in a different programming language. No forks. No shortcuts. Every node validates the real Bitcoin mainnet.
Why build 10 Bitcoin nodes?
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 syncing Bitcoin mainnet, with three already at the chain tip validating new blocks in real time.
The technical challenge
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.
What each node implements
Every implementation covers 20+ 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 with PSBT, mining/block template generation, script test vector validation, and mainnet sync.
Current status
All 10 implementations are live on Bitcoin mainnet. Rustoshi (Rust), Haskoin (Haskell), and Beamchain (Erlang) have reached the chain tip and are validating new blocks in real time. The remaining seven — Camlcoin (OCaml), Nimrod (Nim), Ouroboros (Rust/Python), Hotbuns (TypeScript), Blockbrew (Go), Lunarblock (Lua), and Clearbit (Zig) — are completing initial block download at varying speeds, from ~180 blocks/hour (Ouroboros) to ~9,800 blocks/hour (Clearbit).
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.
The Node Runner orchestrates builds across all projects using the Claude Agent SDK, managing multi-phase development with language-specific skill injection.
How it was built
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:
Built all 10 node implementations from scratch — serialization, script interpreter, P2P networking, block validation, UTXO management, mempool, RPC, wallet, and mining.
Ran all 1,222 Bitcoin Core script_tests.json vectors (including the full taproot suite) against every implementation until all 10 passed 100%.
Connected each node to Bitcoin's testnet4 network for initial block download, validating real blocks against real consensus rules.
Activated all 10 nodes on Bitcoin mainnet. Three reached the chain tip on day one. The remaining seven are completing IBD with zero blocking bugs.
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.
Open source
Every implementation is open source under the MIT license. Browse the code, contribute features, or use them as reference implementations for learning Bitcoin internals.