Your pages, your knowledge,
your ship.

How it works

lattice's ship side is a nexus inside the grubbery framework. Your pages and your knowledge live in grubbery's vault on your ship. The client is served by the ship too, so there is nothing to install beyond one dojo command.

What it does

• Pages, not just gemtext Markdown, gemtext, HTML, plain text, JS, or CSS. Or write a page in Hoon and it computes its content: programmable pages with commands, state, and dependencies on other pages.
• Knowledge store A private, tagged note store with per-entry history and a trash you can restore from. Browse it with folders, tag filters, and live updates; drive it from the web app, HTTP, MCP, or the filesystem mount.
• Search A term index over your pages and your knowledge store, queried from the reader's omnibar. Every hit is badged with its scope, so a published page never reads like a private note.
• A real filesystem lattice-fs mounts your pages as local files, over HTTP or grubbery's local IPC. A cold mount warms in one round-trip, so grep and cat run from RAM, and editor backup files never touch the ship.
• Publish Every page you save is a signed value in the Urbit namespace, readable by anyone as urb://~you/that/path. Pages and whole folders can also go clearweb-public over plain HTTP. Share a folder and you've published a site.
• Editor Syntax highlighting for every page kind, live preview, compile errors for Hoon pages, templates, folder-level share, move, and delete, and drag-and-drop upload of files or whole directories. Name a page "My Page" and it keeps that name in the tree.
• Works offline Lose the ship mid-session and saves queue locally, then replay when it returns. Deletes, moves, and renames queue too, in order. Concurrent edits are never lost: the overwritten version is kept as a real page under conflicts/.
• Export and restore One button downloads every page and every memory as a single tar of plain files you can read, grep, or put in git without lattice. Restore takes an archive back, paths, tags, and dates intact, and says what it will overwrite before it acts. The desktop app schedules these backups to a folder on your machine.
• Sharing that scales Named groups of ships with per-path read and edit grants, per-file grants from the editor, and a banlist that revokes on ban. Readers can leave comments on the pages you publish; a moderation inbox lists and removes them.
• Follow & subscribe Follow ships to keep track of what they publish, or subscribe to a single file and get the edit the moment it happens, over a live namespace subscription rather than a timer.
• Browse urb:// Read anything any ship publishes, peer-to-peer over remote scry, from the web reader. Star pages as bookmarks; fetch urb://~ship/manifest to see a stranger's index; copy a remote file onto your own ship at a path you choose.
• Light and dark The reader, the editor, and the PWA follow your system theme.

Memory for your AI agents

The knowledge store speaks MCP through eleven tools compiled into the ship itself: save, read, list, search, explore by tag, move, delete, restore, tag, untag, and list tags. Anything an agent saves shows up in the knowledge browser, and vice-versa. There is nothing to run beside the ship and nothing to register; the tools survive restarts and redeploys.

The cookie is a normal ship session, minted from /~/login with your +code, and it is the only credential involved. Your assistant's memory lives on your ship, not in someone's cloud. Details in the docs.

What it isn't

• Not a host. Bring your own ship: yours, a friend's, or a hosted one.
• Not the HTTP web. Pages are Urbit-native (urb://~ship/path) and move between ships over remote scry. The exception is what you choose to publish clearweb, which your ship serves itself.
• Not an app to install. The client is served by your ship. The desktop app and the filesystem mount are optional extras.
• Desktop builds are unsigned for now: Gatekeeper will warn on first launch on macOS.

Privacy

Under the hood

The ship side is Hoon: a grubbery nexus whose pages and memories are grubs in the vault, published into the Urbit namespace and served to other ships over remote scry. The web client is served by the same nexus, with live updates over an Eyre SSE channel and a service worker that keeps the shell and your last-known tree at hand offline. The filesystem client is Rust, the desktop app is Tauri, and the MCP tools are Hoon compiled into the desk.

Install

1. On your ship

The desk is grubbery with lattice and its MCP server and nothing else. If you already run a full grubbery from another publisher, read the notes on switching first. On first boot lattice also installs %obelisk for the optional search mirror.

2. Open it

Log into your ship's web login with your +code, then open /apps/lattice to read and /apps/lattice/app to write. On a phone, use your browser's Add to Home Screen: lattice is a full PWA with its own icon and standalone window.

3. Optional: the desktop app

The same ship-served client in its own window, plus managed filesystem mounts, scheduled backups, and auto-detection of piers running on the same machine. Direct links resolve to the latest release; the releases page has older versions and notes.

Windows and Android use the PWA. The filesystem client on its own is lattice-fs in the repo, built with cargo build --release.

New to Urbit? urbit.org/overview/running-urbit walks you through booting a ship.