Hypercore

Decentralized Data Protocol

Append-only, signed, sparsely-replicated log structure that forms the foundational data primitive of the Holepunch (formerly Hypercore Protocol / dat) ecosystem. Each Hypercore is a single-writer log identified by a public key, with cryptographic verification via Merkle trees enabling secure partial replication between peers. Designed for genuinely peer-to-peer operation with relays used only for hole-punching peer discovery; once peers find each other, all data flows directly between them.

Community
Links
Visit Community

Details

License Open source — MIT (github.com/holepunchto/hypercore)
Dev Status 🟢 Active
Dev Status Detail Released / Mature (production-deployed in Beaker Browser, Pear runtime, Holepunch Keet app)
Owner Holepunch (formerly Hypercore Protocol / dat); core development by Mathias Buus and team; supported by Tether (commercial relationship since 2023 rebrand)
Country International (distributed team; Holepunch entity incorporated in connection with Tether)
Start Year 2013
Stack JavaScript / Node.js (primary reference implementation); also Rust bindings (hypercore-protocol-rs); WebAssembly builds for browser use; modular component architecture
Funding Tether Holdings (commercial backing since 2022–2023 rebrand to Holepunch); prior funding via dat project grants and various foundation support
Last Investigated Jul 1, 2026

Use Case Domains

Platform Evolution & Sovereignty

Decentralized Data Protocol Attributes

Origins Distributed data / Peer-to-peer file sharing (evolved from dat project for scientific dataset sharing; designed to enable verifiable partial replication without centralized servers)
Database Append-only log (each Hypercore is itself the data structure; persistence via underlying storage adapter — typically random-access-file on disk, random-access-memory in tests, or random-access-idb in browsers)
Query Language N/A (Hypercore is a log structure with sequence-number access; higher-level structures like Hyperbee provide query semantics)
Data Formats Arbitrary binary blocks (Hypercore stores opaque blocks; higher-level structures impose schemas); blocks indexed by sequence number; Merkle tree of block hashes for verification
Collaborative Live Editing Single-writer per Hypercore (collaborative editing requires Autobase or application-level CRDT layered on multiple Hypercores)
Rich Text Editing N/A (application-layer concern)
Mobile Support Yes (Holepunch ecosystem deploys to iOS and Android via Pear runtime; Keet messaging app published for both platforms)
Web Support Yes (browser builds via WebAssembly; historically deployed in Beaker Browser; WebRTC-based transport via Hyperswarm for browser peers)
Native Apps Yes (Keet messaging app for desktop, iOS, Android; Pear runtime for building native P2P applications)
Terms Open Source / Free — MIT License; ecosystem includes commercial Tether-funded development
Funds Tether investment amount not publicly disclosed; Holepunch operates as Tether-affiliated entity since 2022
Based On Merkle DAG concepts (cryptographic verification of partial replication); BitTorrent-style swarm replication; dat protocol predecessor (Hypercore is the successor specification)
P2P Architecture True P2P with hole-punching: peers connect directly after Hyperswarm DHT-based discovery; relays only used for NAT traversal hole-punching, not for data transit; no centralized infrastructure required for data movement
Overlay Network Hyperswarm (DHT-based peer discovery and connection management; built atop UDP with TCP fallback)
Content Addressing Public-key addressing per Hypercore (each Hypercore identified by Ed25519 public key); blocks within a Hypercore addressed by sequence number; integrity via Merkle tree of block hashes
Local-First Yes — Hypercores can be created, written to, and read entirely offline; peer replication is opportunistic; data persists locally regardless of network state
E2EE Transport encryption via Noise Protocol Framework (all peer-to-peer connections encrypted by default); content-layer encryption is application-level concern (Hypercore data is technically public to anyone who knows the public key)
CRDTs Lib Autobase (Holepunch's CRDT-like primitive for multi-writer scenarios built atop multiple Hypercores); external CRDT libraries can also be layered on top
Byzantine Fault Tolerance Single-writer model (no consensus required within a Hypercore; signatures prevent tampering); multi-writer via Autobase uses convergent eventual consistency rather than Byzantine consensus
Signature Ed25519 signatures (each block signed by the Hypercore's owning key; Merkle tree provides incremental verifiability for partial replication)
Permissions Public-key gated (whoever holds the Hypercore public key can read; whoever holds the secret key can write); no native ACL; access control layered at application level
Semantic Web Compatibility N/A — Hypercore is content-agnostic at the protocol level; semantic-web-compatible data can be stored as block payloads but is not a protocol concern
Smart Contract N/A (no smart contract capability)
Protocol Stack Position L4 Data & Semantic (data primitive); often composed with L3 (Hyperswarm) for transport
Asset / Value Embedding None — Hypercore is a content-addressed data protocol with no native token or economic incentive layer. Tether's commercial backing of Holepunch is organizational, not protocol-level
Protocol Maturity / Standardization Released / Production-deployed; not submitted to formal standards body; specification maintained at github.com/holepunchto; community-driven evolution