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.
Your whole workspace. One app.
Documents, databases, canvas, tasks, dashboards, chat — in a keyboard-first workbench that works offline, syncs across your devices, and keeps your data private. No account required. Free forever.
Free in your browser — no account, no install.
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 and edit connections, embed documents. Like Miro meets Obsidian.
Tasks
Manage projects with status, priority, assignees, and due dates. Edit tasks in place on any surface — boards, lists, pages, or the sidebar.
Dashboards
Metrics, charts, and feeds over your live data. Pick from built-in widgets or write your own — they run sandboxed and sync like everything else.
Chat & Calls
Channels, DMs, and peer-to-peer video calls — built on the same local-first sync as your documents. Every page gets its own discussion thread.
Notifications
Mentions, assignments, and replies land in a private inbox derived locally from sync — no notification server reading your activity.
Instant search
One palette (⌘K) opens anything, runs any command, and full-text searches every page — entirely on your device.
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() Built for agents
AI agents are first-class users of your workspace — through the filesystem they already know, not a wall of tool definitions.
# An agent working in a workspace checkout
$ xnet checkout --query "q3 roadmap"
Pages/q3-planning.md
Databases/tasks.rows.jsonl
$ grep -l "launch" Pages/ # files are just files
$ xnet query tasks --where status=open --format tsv
# edits become validated mutation plans
$ xnet commit --applyThe same plan/validate/apply core sits behind files, the CLI, and MCP.
Files first
Agents already read, grep, and edit files brilliantly. xNet checks out a scoped slice of the workspace as Markdown, JSONL, and JSON Canvas — the store stays the source of truth.
A ~500-token contract
One cross-harness SKILL.md teaches Claude Code, Codex, Gemini CLI, or Cursor the whole workflow. That is the entire standing context cost — not thousands of tokens of tool definitions.
Safe by construction
File edits become schema-validated mutation plans. Conflicts quarantine with a human-readable note instead of overwriting. An agent cannot corrupt the workspace with a malformed write.
~9x cheaper than MCP tools
On a 15-task benchmark, the files+CLI surface used 0.11x the tokens of a legacy MCP toolset with equal task success. A slim MCP server remains as the no-shell fallback.
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 (coming soon)
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.
Call signaling
Team voice and video rooms use the Hub to set up their peer-to-peer connections — media flows directly between participants, not through the Hub.
Abuse protection
The Hub validates relayed messages — mention declarations are shape-checked and capped — so a hostile client can't spam your team's notifications.
# 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:4444Deploy 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 — and an app you can live in
- Hybrid post-quantum crypto (ML-DSA-65, NIST FIPS 204)
- Crypto identity (DID:key, Ed25519, UCAN) with passkey sign-in
- Schema system with 15 property types
- P2P sync engine (Yjs + Lamport clocks)
- Encryption-first authorization (roles, grants, key recovery)
- Workbench shell — tabs, panels, command palette, zen mode
- Documents, databases, infinite canvas & task manager
- Dashboards with pluggable, sandboxed widgets & charts
- Real-time chat, presence & peer-to-peer calls
- Notification inbox with mentions & triage
- Agent surface — xnet CLI, SKILL.md, files-first checkout
- Hub — encrypted backup, relay & full-text search
- 6,000+ tests across 30 packages
Daily Driver
Make xNet an app you actually use every day
- Polished desktop experience
- Workspace invites & sharing flows
- Sharing UI (useCan / useGrants in app)
- Push notification delivery (Web Push, Electron, mobile)
- Query API improvements
Multiplayer at Scale
Bigger teams, bigger calls, more devices
- Mobile app (Expo)
- SFU tier for larger calls
- End-to-end encrypted channels
- Hub key registry & device directory
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
Updated June 2026
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/dataJoin the Movement
Contribute to the open protocol
Good first issues waiting for you.
Requires Node.js 22+ and pnpm for development.