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.
Documents, databases, canvas. Free, offline, private.
3 hooks, TypeScript, React. Zero backend.
Decentralized data layer for the open web.
What is xNet?
Three layers. Use just the app. Or build your own. Or join the movement.
A productivity app
Documents, databases, canvas, tasks. Like Notion, but your data stays on your device.
A developer toolkit
React hooks, TypeScript schemas, real-time sync. Build local-first apps in minutes.
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.
Documents, databases, and canvas working together.
Try it free in your browser.
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.
Electron — full features, plugins, background services
PWA — works in any browser, installable
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.
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
pnpm add @xnetjs/react defineSchema({ authorization: { ... } }) useQuery(MySchema) useIdentity() 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
Electron — macOS, Linux, Windows
Expo — iOS, Android
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.
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.
# 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 |
Where this is going
From local-first primitives to the decentralized data layer of the internet. Each layer builds on the last.
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
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)
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)
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
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
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
We're looking for developers who want to
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
$ 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.