Ghostline

A self-hosted, P2P, end-to-end encrypted chat system

in progress

overview.md

// what it is

Ghostline is a peer-to-peer, end-to-end encrypted chat system written in Rust. It's inteded to be a 1:1 / group oriented chat service, minus the third party. Messages stay encrypted between peers, with an optional self-hosted relay for offline delivery. It's built library-first: a core Rust crate handles identity, encryption, networking, and storage, with the CLI and (eventually) GUI as thin consumers of that API.

stack.json

// how it's built

language Rust

networking libp2p (TCP, Noise, Yamux, gossipsub)

crypto openmls, ed25519, x25519, ChaCha20Poly1305

storage sled

CI Nothin', 'cause I don't care yet

numbers.txt

// good ol' numbers

— startup time

— idle memory usage

— message send / receive latency

— handshake time (first connect)

numbers incoming once phase 1 is benchmarkable

progress.md

why?

For most of my adult life, the main social platform my friends and I use has been Discord - group chats, calls, sharing clips. We've always been interested in E2E encrypted alternatives but didn't want to switch to another third party service. Self-hosting something we could all message through over the internet seemed like a great fit. I do run a mesh network with E2EE already, but it's not internet-facing and isn't friendly for less technical friends. Seeing as we have no real need for this tool, and I was overdue for a solid default Rust project. Enter Ghostline.

approach

I plan to build this thing in phases, which I like to do for anything with a bit of complexity (or surrounding topics I'm unfamiliar with). Core functionality first: encryption, networking, a clean library API, any other basic piece of functionality. My goal is to drive all of this from the command line before getting any UI involved. Once a working P2P demo exists, group support gets layered on. From there, nice-to-haves like an optional relay for offline delivery might get stapled on. UI comes last, once there's a stable API to build against. I'm currently leaning toward something native rather than an Electron or a web app, but that could change.

phase_0.md

Phase 0

Core foundations

Identity, libp2p transport with Noise handshake, and 1:1 encrypted send/receive via the core API.

testing ed25519 identity + fingerprint
in progress libp2p swarm (TCP + Noise + Yamux)
in progress 1:1 encrypted send/receive
in progress Event stream API

phase_1.md

Phase 1

Local history & retention

sled-backed message storage, configurable retention, save/pin, and the first real CLI interface.

planned Encrypted local message store
planned Configurable retention (default 7d)
planned Save / pin messages
planned ghostline-cli (connect/send/history/save)

phase_2.md

Phase 2

Group chat

MLS-based group conversations routed over gossipsub, reusing phase 1 storage.

planned openmls group state
planned gossipsub topic routing
planned Member add/remove

phase_3.md

Phase 3

Relay & offline delivery

Store-and-forward relay protocol, offline message delivery, and file transfer.

planned Relay protocol (store/fetch)
planned ghostline-relay binary
planned Offline delivery via relay
planned Chunked file transfer

phase_4.md

Phase 4

Native GUI

A lightweight native UI (egui or iced) consuming the core library directly — no Electron, no web app.

planned GUI shell + core integration
planned Conversation list & message view
planned Image previews

phase_5.md

Phase 5

Polish & multi-device

Multi-device sync, media polish, and performance passes.

planned Multi-device identity sync
planned Media handling polish
planned Performance pass on storage layer