Tilo

A local first collaboration runtime that combines Rust CRDTs, offline synchronization, and cloud persistence to power scalable collaborative applications.

Comment

Tilo

Inspiration

Most collaborative applications still depend on a central server for every edit. When the network is slow or unavailable, collaboration stops and users experience delays, conflicts, or lost work.

We wanted to build a collaboration runtime where every edit happens locally first. Users should be able to continue working offline, reconnect automatically, and have their changes merged deterministically without manual conflict resolution.

That idea became Tilo, a local first collaboration runtime powered by Rust CRDTs.

What it does

Tilo is a local first collaborative whiteboard built on top of a Rust CRDT engine.

Every change is applied immediately on the local device. When peers reconnect, edits are synchronized using CRDT operations instead of document locking or manual conflict resolution.

The platform provides:

  • Local first editing
  • Offline support
  • Real time collaboration
  • Deterministic conflict resolution
  • Mesh networking with relay fallback
  • Version history
  • Team workspaces
  • Secure authentication
  • Subscription management

Instead of treating offline mode as a fallback feature, Tilo treats offline as the default operating model.

How we built it

The frontend is built with Next.js, React and TypeScript, while the collaboration engine is written in Rust and compiled to WebAssembly.

Synchronization combines peer to peer mesh networking with a relay transport when direct connections are unavailable.

For cloud infrastructure we used:

  • Vercel for frontend hosting, serverless APIs and deployment
  • AWS DynamoDB for durable metadata, billing state and collaboration records
  • AWS infrastructure for scalable persistence
  • Paddle for subscription billing

The architecture separates local editing from cloud persistence, allowing the application to remain responsive even during network interruptions.

Challenges we ran into

Building a local first system introduced challenges that traditional web applications rarely encounter.

Some of the biggest challenges included:

  • Designing deterministic CRDT synchronization
  • Handling offline and online transitions without losing edits
  • Scaling synchronization between multiple collaborators
  • Building an idempotent billing workflow
  • Preventing duplicate webhook processing
  • Optimizing synchronization latency while maintaining consistency
  • Ensuring Safari and mobile browser compatibility

We also spent significant time hardening production infrastructure through retries, idempotency, webhook auditing, structured logging, reconciliation flows and automated recovery.

Accomplishments that we're proud of

  • Built a Rust based CRDT engine for deterministic collaboration
  • Achieved local first editing with offline support
  • Implemented hybrid mesh and relay synchronization
  • Integrated AWS DynamoDB for scalable persistence
  • Built a production ready billing system with reconciliation and webhook recovery
  • Created a responsive collaborative whiteboard experience
  • Designed the platform to scale beyond a single whiteboard into a reusable collaboration runtime

What we learned

This project reinforced that collaboration is fundamentally a distributed systems problem rather than a UI problem.

We learned how important deterministic synchronization, idempotent backend workflows, resilient cloud architecture and observability are when building production collaboration software.

Working with AWS services alongside Vercel also highlighted how serverless infrastructure can simplify deployment while still supporting complex distributed applications.

What's next for Tilo

Our roadmap includes:

  • Native desktop applications for macOS, Windows and Linux
  • Collaborative documents and notes
  • Shared databases and knowledge workspaces
  • Plugin ecosystem
  • Self hosted deployments
  • AI assisted collaboration
  • End to end encryption
  • Larger collaborative workspaces with thousands of concurrent users

Our long term vision is to make Tilo a reusable collaboration runtime that developers can integrate into their own applications.

Built With

Share this project:

Updates