Roadmap
Lattice is the foundational SDK for web3 and data. The roadmap isn't about building capabilities — they already exist. It's about making them accessible from every language, every platform, and every use case.
Why Lattice is Structurally Different
These aren't roadmap items. They're already built into the SDK — structural consequences of the architecture that make Lattice the foundation for both web3 and data applications.
State proofs are free
All state is Cashew Merkle trees. Any claim about any state — "Alice's balance at block 50,000 was 1,000" — can be proven with a sparse proof of a few hundred bytes, regardless of total state size. No special prover circuits, no trusted setup.
Multi-chain without splitting security
Merged mining means one proof of work secures unlimited child chains. Adding a chain adds throughput without dividing hashrate. This isn't a shard, rollup, or sidechain with separate validators — it's structural.
Granular privacy without ZK
Cashew's selective encryption lets you encrypt individual fields in state. Alice's balance encrypted, Bob's public, same tree, same contract. CIDs remain valid for proof verification even when data is encrypted.
Indexing is structural
Cashew's diffing computes exact changesets between any two state versions. Subscribe to a root CID, diff against the previous version, get precisely what changed. No external indexer, no event logs, no subgraph.
Cross-chain without bridges
Parent blocks structurally contain child blocks. Cross-chain transfers are verified by Merkle proof against the parent state root — directly, trustlessly. No multisig bridge, no oracle, no escape hatch risk.
State syncing is lazy
A new node downloads the state root and lazily loads branches on demand. Access a single account? Load a single branch path. The full trie never needs to be materialized until it's needed.
Development Timeline
The foundational SDK. Eight Swift packages that compose into hierarchical blockchains with verifiable Merkle state, tiered content-addressed storage, reputation gating, and Kademlia networking.
Make the SDK trivially easy to adopt. A developer should go from zero to running chain in under five minutes, with tooling that feels as polished as Foundry or Cargo.
lattice CLI
Init, devnet, keys, status, query. treehauslabs/lattice-cli
lattice devnet spins up a local chain with configurable block time and storage. Part of lattice-cli
lattice init --template token scaffolds a working Swift project
The foundational SDK should be accessible from any language. The protocol is simple enough that a full client SDK is hundreds, not thousands, of lines — making Lattice the data and web3 layer for every ecosystem.
Every phone is a node. Lattice's lazy state loading makes light clients genuinely lightweight — download roots, verify proofs, load branches on demand.
Layer zero-knowledge proofs on top of Cashew's existing Merkle infrastructure. Prove state claims without revealing state. Verify chains without replaying history.
A self-sustaining ecosystem where the community governs protocol evolution, standards emerge organically, and builders have the resources they need.
Comparison
How the Lattice SDK compares to existing chains on the features that matter to builders.
| Feature | Ethereum | Solana | Cosmos | Lattice |
|---|---|---|---|---|
| State proofs | MPT proofs (~3KB) | None native | IAVL proofs | Cashew sparse proofs (bytes) |
| Multi-chain security | L2 fraud/validity proofs | Single chain | Independent validators | Merged mining (shared PoW) |
| Cross-chain transfers | Bridge contracts | Wormhole (bridge) | IBC relayers | Structural Merkle proofs |
| Field-level privacy | None (needs L2) | None | None | Selective encryption per field |
| State diffing | Event logs + indexer | Geyser plugins | Event logs | Structural Merkle diffs |
| State syncing | ~1TB full sync | ~100GB+ snapshots | State sync module | Lazy branch-level loading |
| Concurrency model | Single-threaded EVM | Parallel (Sealevel) | Single-threaded | Swift actors (compile-time safe) |
| Application logic | Solidity / EVM | Rust / BPF | CosmWasm / Go | Client-side apps + state transactions |
| Multi-language SDKs | JS, Go, Rust, Python | JS, Rust, Python | Go, JS, Rust | Phase 2: TS, Python, Go |
The Application Model
Lattice separates state from logic. The SDK provides verifiable data infrastructure — applications bring their own logic.
Traditional: Logic On-Chain
On Ethereum, application logic runs inside the EVM. Every node re-executes every contract call. This creates a global computer, but one that's slow, expensive, and constrained by gas limits. The chain stores both state and the code that mutates it.
Lattice: Verifiable Data Layer
On Lattice, the SDK provides a verified state layer. Applications — whether web3 dApps, data pipelines, or traditional backends — define their logic client-side and interact with Cashew Merkle state. The SDK guarantees data integrity, ordering, and cross-chain verifiability. This makes Lattice useful far beyond blockchain:
- Rich state structures — dictionaries, arrays, and sets with built-in pagination, queries, and sorted iteration. Data primitives, not byte blobs.
- Sparse proofs — prove any claim about state in bytes. Clients verify without trusting the server. Ideal for auditable data systems.
- Structural diffs — subscribe to state roots and get exact changesets between versions. Real-time data sync without polling or indexers.
- Selective encryption — encrypt individual fields. Private and public data coexist in the same verifiable tree.
- Lazy loading — clients fetch only the state branches they need. A query loading one record doesn't download the entire dataset.
- Cross-chain reads — read and verify state from any chain in the hierarchy via Merkle proofs against parent roots.
This makes Lattice the foundational SDK for two converging worlds: web3 applications that need trustless state, and data-intensive systems that need verifiable, content-addressed storage with built-in provenance.
Web3: A DEX defines its matching engine client-side and writes order book state through transactions. Any client verifies state via Merkle proofs, subscribes to structural diffs for real-time updates, and reads cross-chain balances — without The Graph or a custom indexer.
Data: An audit system stores compliance records as Cashew Merkle state. Any auditor can independently verify the complete history of any record, prove specific claims without revealing the full dataset, and detect tampering via content addressing — without trusting the system operator.