Libp2p

libp2p
Original author	Protocol Labs
Developer	The libp2p community
Initial release	c. 2016
Stable release	Various (per implementation)
Repository	{{URL|example.com|optional display text}}
Written in	Go, JavaScript, Rust, Python, Java, Nim, C++
Engine
Operating system	Cross-platform
Type	Network stack, P2P
License	MIT License, Apache License 2.0
Website	libp2p.io github.com/libp2p

libp2p is a modular network stack and open-source library that enables developers to build decentralised, peer-to-peer (P2P) applications. It originated part of the InterPlanetary File System (IPFS) and was later spun off into a standalone project. The software was developed to provide a set of tools for handling the networking challenges of P2P systems. This includes peer discovery, routing, identity management, and secure communication. There are multiple implementations of libp2p across multiple programming languages. Major projects like Ethereum's consensus layer and Filecoin use libp2p as their foundational networking layer.

History

libp2p was developed by Juan Benet and the team at Protocol Labs during the development of IPFS. The team recognised that building a robust P2P network required solving a set of recurring problems that were not specific to file sharing. Instead of creating a monolithic networking layer tightly coupled to IPFS, they designed a modular and extensible framework that could be abstracted away and used by any P2P application.

The project was separated from the main IPFS codebase to encourage independent development and adoption. This decision proved successful, as libp2p has become a fundamental building block for many other decentralised protocols, allowing their developers to focus on application-level logic rather than reinventing the networking wheel. The project is maintained as an open-source initiative with contributions from a global community of developers.

Core Concepts

libp2p is built around a set of core concepts that, when combined, provide a complete P2P networking solution.

Peer Identity (PeerID)

In a libp2p network, every node, or "peer," is uniquely identified by a PeerID. A PeerID is the cryptographic hash of a peer's public key. This design provides a secure and verifiable identity system. When two peers communicate, they can use the other's public key to encrypt communications and verify signatures, ensuring authenticity and preventing impersonation.

Multiaddress (multiaddr)

Locating peers across different network protocols and locations is addressed using multiaddress (or multiaddr). This is a self-describing network address that allows for multiple layers of addressing information. A host can have multiple multiaddrs, advertising all the ways it can be reached.

For example, a multiaddr might look like:

/ip4/192.168.1.100/tcp/8001

This describes a peer accessible via an IPv4 address 192.168.1.100, using the TCP protocol on port 8001.

Transports

libp2p is transport-agnostic, meaning it can operate over various network transport protocols. Common transports include:

• TCP
• UDP
• QUIC
• WebSocket
• WebRTC
• WebTransport

A machine running libp2p can listen for incoming connections on multiple transports simultaneously which increases the likelihood of successful connections between peers across different network environments.

Stream Multiplexing

To reduce the overhead of opening each new connection libp2p relies on stream multiplexing. This allows multiple independent, bi-directional streams to run concurrently over a single underlying transport connection, enabling different application-level protocols to operate without interference.

libp2p achieves this in two ways:

• For transports like TCP that do not natively support streams, libp2p layers a dedicated multiplexer protocol (such as mplex or yamux) on top of the connection.
• For modern transports like QUIC and WebRTC, libp2p leverages the protocol's built-in, native multiplexing capabilities directly, without needing an additional layer.

Protocol Negotiation (multistream-select)

When a peer initiates a new stream to another peer, libp2p uses a mechanism called multistream-select. The peer proposes a protocol identifier (e.g., /ipfs/bitswap/1.2.0), and the listening peer either accepts it or rejects it. This allows peers to support multiple protocols and versions simultaneously and ensures that both sides of a conversation understand each other.

Peer Discovery

Finding other peers in a decentralised network is a fundamental challenge. libp2p provides several mechanisms for peer discovery:

• Bootstrap Lists: A list of known, peer addresses used by new nodes to join the network.
• mDNS: Used for discovering peers on a local area network (LAN).
• Distributed Hash Table (DHT): For discovering peers on the wider internet, libp2p networks often employs a Kademlia-based DHT. A peer can query the DHT to find the addresses of other peers.

Secure Communication

When two peers connect, they upgrade their connection to a secure channel using protocols like TLS 1.3 or Noise. This protects against eavesdropping and man-in-the-middle attacks.

Publish/Subscribe

The most widely used implementation of a publish/subscribe (PubSub) system is GossipSub. This is a scalable and resilient gossip protocol that propagates messages through the network by having peers gossip with a random subset of their neighbours. This is used extensively for tasks like block and transaction propagation in blockchain networks.

Implementations

As libp2p is a specification with multiple implementations in different programming languages. As of 2025, the most mature implementations are:

• go-libp2p (Go)
• js-libp2p (JavaScript)
• rust-libp2p (Rust)

Other official implementations include:

• py-libp2p (Python)
• cpp-libp2p (C++)
• swift-libp2p (Swift)
• nim-libp2p (Nim)
• jvm-libp2p (Java or Kotlin)
• zig-libp2p (Zig)
• dotnet-libp2p (C# with .NET)
• c-libp2p (C)
• litep2p (Rust)
• erlang-libp2p (Erlang)