The workspace is a real directory
Canonical content lives in Finder, Explorer, a terminal, Git, and any editor. Not a database you can only reach through one app.
Local-first desktop workspace · active development
One workspace for
everything, kept as
plain files.
Lattice is a fast, local-first desktop workspace for pages, canvases, tables, and ordinary files. Canonical content stays in a real directory while one Rust command core keeps app edits consistent, inspectable, and reversible.
What exists today
A working local notebook shell, not a finished everything-app.
Phase 0 is complete and Phase 1 is underway. The current build focuses on the native filesystem, semantic mutation path, fast page workflows, honest external edits, and the shell needed to grow into richer data and compute surfaces.
- Native Tauri workspace shell with open-directory workflows
- Markdown page editor with links, backlinks, embeds, autosave, and conflict handling
- Resource tree, search, command palette, tabs, inspector, and quick capture
- Basic JSON Canvas viewing and SQLite-backed data applications
- Semantic command history, undo, external-edit reconciliation, and a headless CLI
Core promises
The best ideas from many tools, without inheriting their limits.
Lattice combines normal files, spatial canvas, polished editing, a relational data model, real compute, and dashboards — composed through open formats and one semantic runtime.
Offline is the normal state
Open, edit, search, query, draw, and run approved local tasks with no server in the loop. Connectivity is an option, never a requirement.
Every GUI action is a command
Desktop UI, CLI, local API, MCP, scripts, and agents share one semantic mutation core — with transactions, review, and history.
No lock-in, only open formats
Markdown, SQLite, Parquet, JSON Canvas, and ipynb. Rich composition references independent resources instead of trapping them.
Large data is first-class
SQLite for mutable application data, Parquet and DuckDB for analytics, Arrow to move tabular data fast — right on your machine.
AI-legible, no bundled brain
Legible and editable by any external agent through files, commands, CLI, API, and MCP — with no proprietary model or hidden memory graph.
A real directory
Your workspace is files you already understand.
Canonical content is visible in Finder, Explorer, terminals, Git, editors, and backup tools. Different information keeps an appropriate native format — Markdown is never forced to impersonate a database, canvas, notebook, or app.
- Names and paths communicate purpose, with a readable manifest and README.
- Rich resources ship portable previews and honest fallbacks.
- Deleting the hidden .lattice/ never destroys your work.
An illustrative Lattice workspace on disk
One command core
Every surface speaks the same semantic language.
Desktop UI, CLI, local API, MCP, scripts, workflows, plugins, and agents all flow through one command-and-transaction core. That core is the only thing that writes your files — so changes are consistent, reviewable, and reversible.
- Proposed transactions can be reviewed before they touch disk.
- Automation, permissions, logs, and lineage stay visible and versionable.
- External edits are reconciled as honest revisions, not silent overwrites.
GUI · CLI · API · MCP · agents → core → files
Large data is first-class
Analysis far beyond SaaS table limits — locally.
SQLite serves mutable application data; Parquet and DuckDB serve analytical workloads; Arrow moves tabular data efficiently between them. Datasets that would hit a hosted row ceiling stay fast on your own machine.
- Partitioned Parquet datasets with a queryable semantic model.
- DuckDB queries and Vega-Lite charts over local and remote sources.
- Annotation overlays keep analysis attached without mutating source data.
Illustrative — not a benchmark
Open-native composition
One workspace vocabulary, without flattening every resource into a block.
Page, Canvas, Table, Notebook, and File are understandable entry points. Each keeps an appropriate open format and specialized renderer, while shared commands, links, inspection, history, and permissions make the workspace feel coherent.
- React coordinates the shell; specialized renderers own performance-critical loops.
- Rust owns canonical resource state, validation, storage, search, and commands.
- Capabilities appear contextually instead of crowding the primary interface.
Different formats · shared command and inspection surfaces
Desktop themes
Semantic color systems, not component-by-component skins.
Built-in YAML themes resolve into the same compact set of surface, text, line, signal, danger, type, and geometry roles. The gallery previews the Tauri app themes; the site itself stays on Lattice Slate.
lattice-slate lattice-carbon lattice-fjord lattice-ultraviolet lattice-blueprint lattice-vellum Roadmap
Architecture commitments, staged delivery.
Long-term capabilities are documented now so early choices never foreclose them. Eleven phases move from a headless core to native ink on mobile.
Phase 0
Specifications & headless core
Manifests, command + transaction model, permissions, Rust storage, CLI.
Phase 1
Fast local notebook
Tauri shell, editor, links, backlinks, basic canvas, external-edit reconciliation.
Phase 2
Data applications
SQLite, typed fields and relations, grid, board/list/gallery/calendar/form views.
Phase 3
Analytical data
Native DuckDB, Parquet datasets, Arrow transport, charts and dashboards.
Phase 4
Programmable workspace
Local HTTP API, MCP server, proposed transactions, Python, Jupyter, artifacts.
Phase 5
Automation & daemon
Typed events, workflow YAML, scheduler, latticed, durable jobs and lineage.
Phase 6
Remote data & BI
ADBC connectors, live/extract/composite modes, semantic models, cross-filtering.
Phase 7
Lattice Apps & publishing
Full app packages, UI kit, static and connected publishing, docs adapters.
Phase 8
Plugins & capability packs
WASI component runtime, WIT interfaces, sandboxed UI, registry, packs.
Phase 9
Sync & collaboration
Operation outbox, Rust sync server, text/canvas collaboration, team permissions.
Phase 10
Mobile & native ink
iPad reader/editor, PencilKit overlay, Lattice Ink, handwriting search.
Open source · early native build
Use the public guide, or inspect the implementation.
The public docs now stay concise and product-facing. The repository retains the full architecture corpus, decision records, formats, performance contracts, and roadmap.