About the project

Pulse

A local-first P2P social network for physical spaces. No accounts. No servers. Fully peer-to-peer.

Problem

People at hackathons, conferences, campuses, coworking spaces, meetups, airports, and other physical communities are already in the same place, but their communication is still fragmented across WhatsApp, Discord, Telegram, X, event apps, and QR-based tools.

These platforms were designed around centralized online communities. Even when two people are sitting a few meters apart, their messages are routed through cloud infrastructure somewhere else. Users have to create accounts, join another platform, depend on centralized services, and often split the event's conversations across several different apps.

For temporary physical communities, that model is unnecessarily complicated. It's currently looking something like this:

People in the same room
        ↓
     Internet
        ↓
   Cloud server
        ↓
     Internet
        ↓
People in the same room

People are already together and the network should be there too; no need for a third party cloud server.

Solution

Pulse is a peer-to-peer social network built specifically for physical communities. Users enter a local Space and immediately get a shared social layer for the people around them: posts, replies, live presence, and file sharing.

There is no application backend, account server, centralized database, API, or WebSocket services. Each device participates directly in the network and collectively maintains the community.

Fabian ───────── Sergio
  │              │
  │              │
Charlie ─────── Daniel

The community does not live on a server; so therefore it lives across the devices of the people who are actually there at the event.

How Pulse Works

Pulse is built as a standalone application using Pear, Bare, and the Holepunch peer-to-peer stack.

Each installation generates and stores a persistent Ed25519 cryptographic identity locally. There are no usernames and passwords, no email registration, and no OAuth flow. A user's public key acts as their identity while a human-readable display name makes the experience social.

Users join a Space, such as:

a hackathon
a conference
a university campus
a coworking space
a meetup
an airport gate
a LAN party

Once inside a Space, peers discover and connect to one another through Hyperswarm / HyperDHT (we utilize more Bare services in the Bare Worker, see graph below).

Every social action is represented as a signed event through the Pulse Protocol (created by me). Posts, replies, profile information, reactions, and shared content can be authenticated by every peer before being accepted into the network.

Impact

Physical communities appear everywhere: universities, conferences, hackathons, festivals, coworking spaces, airports, meetups, and local events.

Pulse gives those communities a communication layer that can exist with the community itself.

Organizers do not need to provision a backend or convince every participant to join another centralized platform. Users do not need an account. The social graph does not need to exist forever.

A Space can appear when the community appears and disappear when that community is gone.

Core Architecture

Pulse separates the interface from the peer-to-peer engine.

┌─────────────────────────────────────────────┐
│                PULSE TUI                    │
│                                             │
│   feed · posts · replies · people · files   │
└──────────────────────┬──────────────────────┘
                       │
                       │ IPC
                       ▼
┌─────────────────────────────────────────────┐
│                BARE WORKER                  │
│                                             │
│ identity - spaces - protocol - persistence  │
│ presence - files · networking - updates     │
├─────────────────────────────────────────────┤
│ Hyperswarm - Corestore - Autobase           │
│ Hypercore - Hyperdrive - Pear Runtime       │
└──────────────────────┬──────────────────────┘
                       │
                    P2P swarm
                       │
             ┌─────────┼─────────┐
             ▼         ▼         ▼
           Peer A    Peer B    Peer C

Peer-to-peer networking

Hyperswarm and HyperDHT allow users participating in the same Space to discover and connect directly without Pulse operating a central application server.

Cryptographic identity

Each Pulse installation owns a persistent Ed25519 keypair.

The public key is the user's identity, while the private key remains on the user's device and is used to sign actions.

A profile can look like:

fabian · @84ac19

Display names are friendly metadata; the cryptographic identity underneath is what prevents another peer from impersonating that user.

Pulse uses an append-only event protocol rather than mutable rows in a centralized database.

Examples include:

post:create
post:reply
post:react
post:delete
profile:update
file:share

Every event is validated and cryptographically verified before being accepted.

This means peers do not have to blindly trust data received from other devices.

Pulse uses Corestore, Hypercore, and Autobase to maintain durable multi-writer social state across peers.

Instead of one server owning the canonical feed, participants contribute signed events from their own devices and Autobase produces a deterministic shared view of the Space.

Fabian log ─┐
Alice log ──┼──▶ shared social feed
Marco log ──┘

The result is a social feed that is replicated across the community rather than stored in one central database (that's exactly the point!!).

Live presence

Pulse also shows who is currently present in a Space.

Presence is derived from active peer connections instead of being written permanently into social history.

People here

● alice      @a918bc
● marco      @e023ab
● fabian     @84ac19
● lucas      @993bc0

This makes every Space feel like a live representation of the physical community around you.

Files are shared using Hyperdrive.

A user can publish a file to the Space and another peer can download it directly through the P2P network.

fabian
shared a file

📄 demo.pdf
3.8 MB

[Enter] download

There is no centralized upload bucket between the sender and receiver.

Peer-to-peer distribution and updates

Pulse itself is distributed through Pear.

The application can be packaged as a standalone executable, and software updates are distributed peer-to-peer as well. The architecture of the social network and the architecture used to distribute the application follow the same principle: peers replace centralized infrastructure.

User Experience

A user opens Pulse, enters or discovers a Space, and immediately sees the community. This was a prototype of the TUI at the start of the hackathon (changed a bit during development).

╭──────────────────────────────────────────────────────╮
│ PULSE                                   ● 18 peers   │
│ Aleph Hackathon                                      │
├──────────────────────────────────────────────────────┤
│                                                      │
│ alice                                      10:42     │
│ Anyone figured out Autobase writers?                 │
│                                                      │
│     ↳ bob                                            │
│       yes, come to table 8                           │
│                                                      │
│ marco                                      10:44     │
│ Looking for someone who knows Rust!                  │
│                                                      │
│ fabian                                     10:45     │
│ Just shipped our first Pear build.                   │
│                                                      │
│ lucas                                      10:46     │
│ 📎 testrfile.mov · 12.3 MB                           │
│                                                      │
├──────────────────────────────────────────────────────┤
│ > What's happening?                                  │
├──────────────────────────────────────────────────────┤
│ [p] post  [r] reply  [f] file  [u] users  [?] help  │
╰──────────────────────────────────────────────────────╯

The experience is intentionally closer to a local social feed (like X kind of!) than a traditional chat room.

Important links and notes

GitHub repo: https://github.com/FabianSanchezD/pulse

Pear installation with the CLI (note: add the timeout at 180s): pear install --timeout 180 pear://dhur8r47grcknqxdpqke7yu9h61jpoo4ih4x4qj3wbscg6shqg4o

Pitch + demo: https://youtu.be/_UZHdkVZ1kw

Telegram for suggestions/questions: @fabiansanchd

Checkout the quickstart section below for how to use it (and how to make 2 instances from 1 computer).

This was built around hello-pear-bare in the main branch (used the template).

The repo is in my profile but after the hackathon I will move it to an organization, I'd like to pursue this!

Quickstart

npm install npm start

Two instances on one machine need separate identities, so give each its own storage:

npm start -- --storage /tmp/pulse-a --name alice and --storage /tmp/pulse-b --name bob.

Or install it, don't clone it (using Pear CLI):

npm i -g pear

pear install --timeout 180 pear://dhur8r47grcknqxdpqke7yu9h61jpoo4ih4x4qj3wbscg6shqg4o

pulse --name yourname

IMPORTANT: pass --timeout: the 30s default is shorter than the 45–60 s DHT discovery routinely needs. A seeder must be online for this to work (I will be keeping my seeder during judging).