Light Protocol for Layered Peer Network
LP2LN
A decentralized P2P network — protocol and product I'm designing and building from the ground up.
- Role
- Founder / Architect / Rust Developer
- Period
- 2024—Now
- Status
- Active development
- Team
- Solo
- Stack
- Rust · Tokio · QUIC · React
At a glance
Problem
Centralized services depend on servers, domains, and providers — single points of failure. We need an architecture where devices connect directly.
My contribution
I own the idea, architecture, core development, product concept, and growth of LP2LN.
Challenge
The problem
Centralized services depend on servers, domains, and providers — single points of failure. We need an architecture where devices connect directly.
I'm designing and building a P2P network in Rust: direct connections, smart topology, encrypted channels, and an application layer on top. The foundation already works; the application layer is the current focus.
What I owned
My role
I own the idea, architecture, core development, product concept, and growth of LP2LN.
- 01Protocol and network architecture
- 02Core development in Rust
- 03Connectivity through NAT and direct links
- 04Product concept, brand, and open source
How it works
Connect devices directly
LP2LN is built on direct connections between devices over the regular internet. No central server: if one node is down, the network keeps working through the rest.
A network that holds itself together
Nodes pick reliable neighbors, restore links, and find each other on the local network after a reboot. No external phone book required.
From protocol to product
Next step is the application layer: data exchange between devices and the first user scenario — a shared folder that syncs over the network.
Gallery
Engineering decisions
Direct connections
Devices find each other and connect directly — even behind a router and without a public IP. If there's no direct path, traffic goes through a neighbor temporarily, then upgrades to a direct link.
Smart topology
The network decides which peers to keep, drop, or dial. Devices on the same local network find each other after a reboot without an external directory.
Security
Every connection is end-to-end encrypted. Nodes sign messages, so an impersonator or a replayed packet can't get through.
Path to a product
On top of the network sits an application layer: data exchange, file sync, and first user scenarios like a shared folder across devices.
Stack
Timeline
- Network core ✓2024
Direct connections, routing, encrypted channels, and debug tooling.
- Smart topology ✓2024—2025
The network picks neighbors, keeps links healthy, and recovers after failures.
- Local discovery ✓2025
Devices on the same network find each other after a restart without external services.
- Application layer ← now2025—2026
A secure channel between the app and the network core — the base for products on top.
- Products on the network2026+
Content exchange, network updates, and the first user product — a shared folder across devices.
Outcome
What we achieved
Status
Current state
The network core works: direct connections, topology, encryption, and local device discovery. I'm now building the application layer on top.
Next
What's next
Content transfer between real nodes, network updates, and the first user product — a shared folder across devices.
Next project
AI personalities with memory, voice, and access to your computer — my own product built from scratch.