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. It’s like Lego for the web.
Documents, databases, canvas, tasks. Like Notion, but your data stays on your device.
Three React hooks, TypeScript schemas, real-time sync. No backend to deploy.
An open protocol for apps that share data — across devices, users, and apps.
The app is built on the SDK. The SDK implements the protocol. Start anywhere.
Your whole workspace. One app.
A keyboard-first workbench that works offline, syncs across your devices, and keeps your data private. No account. Free forever.
Documents
Write together in real time. Slash commands, blocks, formatting — synced across devices.
Databases
Track anything with 15 field types. Tables, boards, galleries, calendars.
Canvas
An infinite whiteboard for visual thinking. Draw connections, embed documents.
Tasks
Projects with status, priority, assignees, and due dates — editable on any surface.
Chat & Calls
Channels, DMs, and peer-to-peer video calls on the same local-first sync.
AI assistant
Answers grounded in your own knowledge graph, with optional on-device search. AI content is always badged, never passed off as yours.
…and eight more surfaces — dashboards, notifications, instant search, CRM, finance, experiments, maps, and labs. All 14 in one workbench →
Electron — full features, plugins
PWA — any browser, installable
Expo — iOS and Android (coming soon)
Free forever. Self-hostable. Every feature is open source.
For Developers
Build local-first apps with three React hooks — storage, crypto, and networking 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() },
actions: { read: allow('owner', 'assignee'), write: allow('owner') }
}
})
// 1. useQuery — read data
const { did } = useIdentity()
const { data: tasks } = useQuery(TaskSchema, {
where: { assignee: did }
})
// 2. useMutate — write data
const { create, update, remove } = useMutate()
create(TaskSchema, { title: 'New task' })
// 3. useNode — real-time collaboration
const { doc, peerCount } = useNode(PageSchema, id) - Full TypeScript inference from schemas
- Offline-first by default
- P2P sync with no server code
- No backend, auth service, or database to run
Sync peer-to-peer with no server at all, through a managed Hub, or against
your own backend — same hooks either way. Not on React?
@xnetjs/runtime drives the same client anywhere.
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 --apply Files first, safe by construction
Agents already read, grep, and edit files brilliantly. xNet checks out a scoped slice of the workspace as Markdown and JSONL — edits become schema-validated mutation plans, so a malformed write can’t corrupt anything.
~9x cheaper than MCP tools
One ~500-token SKILL.md teaches Claude Code, Codex, Gemini CLI, or Cursor the whole workflow. On a 15-task benchmark, files+CLI used 0.11x the tokens of an MCP toolset with equal success.
Bring your own agent
OpenClaw, Hermes, Buzz, Claude Code — xNet is not a competing harness. Every agent gets its own key and a narrowly scoped grant, and every change it makes lands in a signed log you can export and verify without trusting us.
No black boxes
No magic, no lock-in. Every layer is documented, standardised, and yours to inspect.
An open protocol
A written standard, not just an app — anyone can re-implement it in any language. A ~100-line Python kernel already verifies TypeScript-signed changes byte-for-byte.
Read the protocol →Cryptography-first
Every change is signed, every node can be end-to-end encrypted, and the signatures are hybrid post-quantum (ML-DSA-65). You hold the keys, not us.
Under the hood →Hubs for teams
Optional always-on sync, encrypted backup, and team permissions on a $5 VPS or Railway. The Hub relays ciphertext — it never sees your data.
Run a Hub →Connectors
GitHub, Notion, Linear, Slack, and more, synced into your workspace as normal, permissioned data — or define your own in a few lines.
Browse connectors →Not the only ones building local-first. See the landscape: 46 projects compared, 35 more acknowledged →
Built to be left.
xNet keeps no behavioral surplus and has no ad model — you are not the product. Six commitments hold us to it, several enforced by a CI gate that fails the build on regression.
- Own You hold the master copy.
- Exit Leaving is your right, and it loses nothing.
- Calm We compete for your wellbeing, not your time.
- Consent Nothing leaves without permission.
- Agency AI makes you more capable, not less.
- Commons You own your audience and your space.
The long game: an open data layer where all your apps share data — offline, private, yours. See where this is going →
Alpha software, honestly labelled. See the open metrics →
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.