Pre-release — Join us in building the future

Your data. Your devices.
Your rules.

xNet is a local-first platform for apps that work offline, sync peer-to-peer, and keep your data under your control.

$ pnpm add @xnetjs/react @xnetjs/data

What is xNet?

Three layers. Use just the app. Or build your own. Or join the movement.

App Layer

A productivity app

Documents, databases, canvas, tasks. Like Notion, but your data stays on your device.

SDK Layer

A developer toolkit

React hooks, TypeScript schemas, real-time sync. Build local-first apps in minutes.

Protocol Layer

An open ecosystem

A protocol for apps to share data across devices, users, and even other apps.

Each layer builds on the last. The app uses the SDK. The SDK implements the protocol. Start wherever makes sense for you.

Documents. Databases. Canvas. Tasks.

A complete productivity app that works offline, syncs across your devices, and keeps your data private. No account required. Free forever.

xNet
See it in action

Documents, databases, and canvas working together. Try it free in your browser.

Try the App

Your data stays on your device

Unlike cloud apps, your files never leave your computer unless you want them to. No servers reading your notes. No accounts to create.

Works offline, syncs automatically

Edit on a plane, in the subway, anywhere. When you're back online, changes sync between your devices without you lifting a finger.

Documents

Write and collaborate in real-time. Slash commands, blocks, formatting — everything syncs instantly between your devices and teammates.

Databases

Track anything with 15 field types. See your data as tables, boards, galleries, or calendars. Filter, sort, and group your way.

Canvas

Visual thinking on an infinite whiteboard. Arrange ideas freely, draw connections, embed documents. Like Miro meets Obsidian.

Tasks

Manage projects with status, priority, assignees, and due dates. View as kanban boards, lists, or calendars.

Desktop

Electron — full features, plugins, background services

Web

PWA — works in any browser, installable

Mobile

Expo — iOS and Android (coming soon)

Free forever. Self-hostable. Every feature is open source and will stay that way.

For Developers

Build local-first apps with three React hooks. Everything else — storage, crypto, networking — is handled for you.

App.tsx
import { defineSchema, text, person } from '@xnetjs/data'
import { allow, role } from '@xnetjs/data/auth'
import { useIdentity, useQuery, useMutate, useNode } from '@xnetjs/react'

// Schema with built-in authorization
const TaskSchema = defineSchema({
  name: 'Task',
  namespace: 'xnet://my-app/',
  properties: {
    title: text({ required: true }),
    assignee: person()
  },
  authorization: {
    roles: {
      owner: role.creator(),
      assignee: role.property('assignee')
    },
    actions: {
      read: allow('owner', 'assignee'),
      write: allow('owner'),
      share: allow('owner')
    }
  }
})

// 1. useIdentity — current DID and auth state
const { did, isAuthenticated } = useIdentity()
if (!isAuthenticated) return null

// 2. useQuery — read data
const { data: tasks } = useQuery(TaskSchema, {
  where: { assignee: did }
})

// 3. useMutate — write data
const { create, update, remove } = useMutate()
create(TaskSchema, { title: 'New task' })

// 4. useNode — real-time collaboration
const { doc, peerCount } = useNode(PageSchema, id)
// Plug doc into TipTap, ProseMirror, etc.

What you get

  • Full TypeScript inference from schemas
  • Offline-first by default
  • P2P sync with no server code
  • Works with any AI coding assistant

What you skip

  • Backend deployment
  • Auth configuration
  • Database setup
  • API design

Architecture comparison

Before xNet
Database (Postgres)
API layer (REST/GraphQL)
Auth service (Auth0)
Real-time (WebSockets)
Offline sync (custom)
Deployment (Vercel)
With xNet
pnpm add @xnetjs/react
defineSchema({ authorization: { ... } })
useQuery(MySchema)
useIdentity()
Done.

How it works

Built on open standards and proven technology. No magic, no lock-in — just solid engineering.

Sync

  • Edits merge without conflicts (CRDTs)
  • Devices connect directly (P2P)
  • Changes are cryptographically signed
  • Works offline, syncs when online

Security

  • Hybrid classical + post-quantum signing
  • ML-DSA-65 (NIST FIPS 204) ready
  • Per-node end-to-end encryption
  • Read access enforced by cryptography

Identity

  • You own your keys, not us
  • Seed phrase key recovery
  • Multi-device via deterministic derivation
  • No central login server

Storage

  • Browser: SQLite (OPFS)
  • Desktop/Mobile: SQLite
  • Files sync peer-to-peer
  • Full history, never lose changes
Desktop

Electron — macOS, Linux, Windows

Mobile

Expo — iOS, Android

Web

PWA — any modern browser

For Teams: Hubs

xNet works without any servers — your devices sync directly. But when you want always-on availability, backups, and team access, add a Hub.

Desktop
Peer A
Phone
Peer B
Browser
Peer C
P2P when online Hub when offline
Hub
Railway or $5/month VPS — Docker, SQLite, single process
Sync relay Backups Auth Search Blobs
The Hub never sees your plaintext data. It relays encrypted updates and stores ciphertext. Optional — everything works without it.

Always-on sync

Your devices sync directly when both are online. When one goes offline, the Hub holds updates until it reconnects. Nothing gets lost.

Encrypted backups

Your data is encrypted on your device before it reaches the Hub. Even we can't read it. Restore to any device, anytime.

Team permissions

Control who can view, edit, or admin your workspaces. Permissions are enforced at the Hub — no shared passwords, no account sharing.

Web access

Your Hub serves the xNet app directly. Share a URL with your team and they can access everything from any browser.

Custom data types

Create and share custom schemas across your team. The Hub tracks what types are available so everyone stays in sync.

File storage

Images, attachments, and exports sync between devices. The Hub acts as always-on storage so files are available even when teammates are offline.

Full-text search

Find any document, task, or note by its content. Search runs locally first for speed, with Hub results filling in the gaps.

terminal
# Deploy on Railway (recommended)
# https://railway.app/template/xnet-hub

# Or self-host with Docker
$ docker run -d -p 4444:4444 \
    -v xnet-data:/data \
    ghcr.io/crs48/xnet-hub:latest

# Point your app at wss://your-hub:4444

Deploy on Railway or Docker. Read the Hub setup guide.

The Vision

Imagine if all your apps could share data.

Your task manager, your notes, your calendar, your CRM — all using the same underlying data layer. Offline. Private. Yours.

Tesla built Warp — their own ERP connecting every bolt, every person, every decision. Love them or hate them, it's why they're the most vertically integrated company on the planet. They own their nervous system and can adapt it as needed. We don't own ours.

Beneath every forest, a mycelial network connects the trees — sharing water, nutrients, signals. Data should work like soil: an open foundation that lets everything grow.

xNet is an open protocol for local-first apps where data flows freely between devices, users, and applications. Not blockchain. Not Web3. Just good architecture that puts you in control.

What this enables

Apps that work together

Shared contacts, unified search, data that flows between tools.

Data portability

Export everything, anytime. Your data, your format, your choice.

Community schemas

Like npm for data types. Share and reuse data structures.

Decentralized social

Follows, feeds, comments — without a platform in the middle.

This is a long-term vision. Today, start with the app or SDK. Tomorrow, join the ecosystem.

Why local-first?

Traditional apps store your data in the cloud. xNet keeps it on your device.

Traditional xNet
Data location Cloud servers Your device
Offline support Limited or none Full functionality
Real-time sync Requires backend Built-in P2P
Backend required Yes (deploy & maintain) No
Vendor lock-in High None — open source

We're not the only ones building toward this vision. Check out Anytype, Jazz, DXOS, and many more.

Where this is going

From local-first primitives to the decentralized data layer of the internet. Each layer builds on the last.

Built

The Foundation

Core primitives for local-first apps

  • Hybrid post-quantum crypto (ML-DSA-65, NIST FIPS 204)
  • Crypto identity (DID:key, Ed25519, UCAN)
  • Schema system with 15 property types
  • P2P sync engine (Yjs + Lamport clocks)
  • Encryption-first authorization (roles, grants, key recovery)
  • Rich text editor, infinite canvas, devtools
  • Electron app with real-time collaboration
  • 2400+ tests across 21 packages
Now

Daily Driver

Make xNet an app you actually use every day

  • Personal wiki & task manager
  • Query API improvements
  • Polished desktop experience
  • Plugin system & custom views
  • Sharing UI (useCan / useGrants in app)
Next

Hubs & Multiplayer

Always-on sync nodes and shared workspaces

  • Hub MVP — backup, relay, key registry
  • Workspace invites & sharing flows
  • Presence & live cursors
  • Mobile app (Expo)
Then

Federation

Hubs talk to each other. Data flows freely.

  • Hub-to-hub federation protocol
  • Federated queries across hubs
  • Schema registry & discovery
  • ERP framework & domain modules
Vision

The Decentralized Data Layer

A global namespace for structured knowledge

  • Global namespace — xnet://*
  • Decentralized search engine
  • Social federation (follows, feeds, reputation)
  • Domain-specific networks (farming, science, education)
  • Data commons — humanity's shared knowledge graph
Every app built on xNet makes the network stronger

This is early. That's the point.

xNet is pre-release software. The APIs will change. There are rough edges. But the foundation is solid — and your contributions will shape what it becomes.

What's working now

2400+ tests passing across 21 packages
Electron app with full P2P sync
Schema system with 15 property types
Real-time collaboration via Yjs
Cryptographic identity (DID:key + Ed25519)
Rich text editor with TipTap
Infinite canvas with spatial indexing
7-panel devtools suite

We're looking for developers who want to

Shape the API before it's set in stone — your feedback directly impacts the design
Build plugins for an extensible ecosystem — custom views, schemas, and integrations
Contribute to core — sync engine, query system, canvas, editor, devtools
Build apps on xNet and push the boundaries of local-first software

Get Started

Choose your path

Use the App

Try xNet as a productivity tool

No install needed. Works offline.

Build with xNet

Add local-first superpowers to your React app

terminal
$ pnpm add @xnetjs/react @xnetjs/data

Join the Movement

Contribute to the open protocol

Good first issues waiting for you.

Requires Node.js 22+ and pnpm for development.