Freenet
Integrated P2P Runtime
Community
Details
License Open source — MIT/Apache 2.0; GitHub: github.com/freenet/freenet-core
Dev Status 🧪 Alpha
Dev Status Detail Alpha / Pre-release — network operational with early users; River chat functional across peers as of December 2025; not yet ready for general public use
Owner The Freenet Project, Inc. — 501c3 non-profit (USA); President: Ian Clarke (original Freenet architect); Chief Strategy Officer: Steven Starr; core developers: Ignacio Duart, Hector Alberto Santos Rodriguez
Governing Body The Freenet Project, Inc. (501(c)(3) non-profit)
Country USA
Start Year 2019
Stack Rust (core node and contracts); WebAssembly (contract execution); TypeScript / JavaScript (frontend apps); Dioxus (River UI)
Funding Freenet Project Inc. (501c3 non-profit); FUTO (demonstrated at FUTO event)
Last Investigated Mar 9, 2026
Integrated P2P Runtime Attributes
Origins Ian Clarke's realization that centralization (not just surveillance) was the primary threat to the open web; original Freenet's static storage model was insufficient for dynamic decentralized apps. Locutus (Star Trek reference: the Borg Collective's network) was the internal codename during development. Renamed Freenet in 2023.
Database Global key-value store — keys are WebAssembly contracts; values are contract state; peers cache contracts near their network location using small-world routing
Query Language N/A — contracts retrieved by cryptographic key derived from WebAssembly code + parameters
Data Formats WebAssembly (contracts); JSON / bincode (contract state serialization); standard web formats (HTML/CSS/JS for browser-based apps)
Collaborative Live Editing Yes — contracts define their own merge operators using commutative monoids; enables real-time collaborative state across peers; River chat demonstrates sub-second latency
Rich Text Editing Partial — browser-based apps can include rich text editors; no built-in rich text layer
Mobile Support Yes — River runs in browser on mobile; Rust node can run on Android
Web Support Yes — apps run in browser as normal websites; Freenet node serves as local gateway
Native Apps Yes — native Rust node (Windows, macOS, Linux); installed as system service
Terms MIT / Apache 2.0
Funds N/A (non-profit; no disclosed investment amounts)
Based On Original (novel architecture); conceptually related to original Freenet routing philosophy and Web of Trust; small-world network topology shared with Hyphanet; WebAssembly contract model distinct from any prior P2P system
P2P Architecture Small-world network — peers assigned location 0–1 on join; contracts cached near their location; requests routed greedily toward location closest to contract key
Overlay Network Small-world overlay — self-organizing peer network; UDP hole punching for NAT traversal
Content Addressing Yes — contract key is cryptographic hash of WebAssembly code + parameters; content-addressed at the contract level
Local-First Yes — Freenet node runs locally; no central servers; all data distributed across peers
E2EE No built-in anonymity or E2EE — deliberately omitted from core; anonymizing layers can be added by applications
CRDTs Lib Yes — contract state merging uses user-defined commutative monoids (CRDT-equivalent pattern); contracts define their own merge logic
Byzantine Fault Tolerance No formal BFT — small-world routing provides decentralized resilience; no consensus mechanism
Signature Yes — contract keys are cryptographic hashes; contract state signed by owner key for update authorization
Permissions Contract-based (WebAssembly contract code + parameters = key; state update requires owner signature; invite-tree permissioning demonstrated in River)
Semantic Web Compatibility No
Smart Contract Yes — WebAssembly contracts are the network's fundamental unit; equivalent to smart contracts; state validated and merged by contract logic rather than external consensus
Protocol Stack Position Application-layer (built on TCP/IP); Freenet Core runs as a local daemon providing HTTP/WebSocket interface to browsers; small-world DHT routing layer sits above TCP/IP; WebAssembly contracts execute within the Freenet runtime.
Asset / Value Embedding None — Freenet has no native token or economic incentive layer. The project is a 501(c)(3) non-profit funded by donations; node operators participate voluntarily; no tokenomics govern resource contribution.
Development Tools freenet-scaffold crate (project scaffolding CLI for contract/delegate/UI workspace generation); cargo + wasm-pack (Rust-to-WebAssembly compilation); Dioxus (Rust UI framework compiling to WASM, used by River reference app); React/Vue (JavaScript UI frameworks via WebSocket API); freenet-stdlib (Rust contract standard library implementing ContractInterface trait); freenet-core binary (local node/daemon); River (reference chat app demonstrating full contract/delegate/UI pattern).
Deployment Options Self-hosted node (freenet-core system service, installed via quickstart script on Linux/macOS/Windows/Android); browser-based UI access via local HTTP proxy (port configurable); UDP hole punching for NAT traversal (10-20% of users behind symmetric NATs may have connectivity issues); no cloud hosting or centralized server option — fully P2P.
Authentication & Identity Delegate-based cryptographic identity — private keys are held exclusively by Delegate components running inside the Freenet Kernel on the user's device; UIs and contracts never receive raw keys; Delegates sign messages and return only signatures; Ed25519 keys used in reference apps (River wiki); sender attestation allows Delegates to verify which contract a UI was downloaded from; no global identity registry or DID standard mandated at protocol level.
Storage Model Global distributed key-value store — keys are cryptographic hashes of WebAssembly contract code (+ parameters); values are arbitrary contract state (opaque bytes); peers subscribe to contracts and cache state near their small-world routing location; state synchronization via summary/delta exchange (commutative monoid requirement: merge(A,B) = merge(B,A)); Delegates store private data locally on the user's device within the Freenet Kernel; no global replication of all data — only subscribing peers cache a given contract.
Interoperability Open protocol — any language compiling to WebAssembly can implement contracts (Rust best supported; TypeScript, AssemblyScript also viable); UIs are standard web apps (HTML/CSS/JS/WASM) served via local HTTP proxy; WebSocket API for UI↔contract and UI↔delegate communication; no mandatory federation protocol (not ActivityPub); interoperability between Freenet apps is via shared contracts addressable by cryptographic hash; bridge to wider web is a design goal but not yet implemented.
Social Graph No built-in social graph at protocol level — social relationships are implemented per-application via contract state; River (reference chat app) implements room-based social contexts; applications may define arbitrary relationship models via contract logic; no protocol-level identity graph or follow/friend primitive.
Protocol Maturity / Standardization Alpha / Novel Architecture — River milestone achieved December 2025; early user network operational; no external standards body submission; 501c3 non-profit governance
Update Policy Contract-defined / append-style — contract state is updated via cryptographically valid delta operations as defined by each contract's WebAssembly merge function; state must form a commutative monoid (updates are order-independent); contracts themselves (the WASM code) are content-addressed and immutable once deployed — upgrading requires deploying a new contract at a new address; Delegates store private state locally and may be updated by the user.
Relationships
How this tool connects to other tools and organizations, from relationships reviewed by the OpenHaven data steward. They describe how projects connect, not how good they are.
- Based on