The stack

Every Contrast app ships the same stack. You do not pick a framework, a state library, an ORM, or a host. That is deliberate: because every project is built the same way, the agents know the stack deeply, the previews are faithful to production, and deploys are one click. This page is the tour of what you are actually building on, with links to each project’s own docs for depth.

#One, the framework

Apps are built on One, a universal React framework. The essentials:

• File-system routing. Files in app/ are your routes. app/index.tsx is /, app/blog/[slug].tsx is /blog/:slug.
• One codebase, two platforms. The same routes render as a server-rendered web app and as a native iOS app through React Native. In Contrast you see both side by side in previews.
• API routes. Files ending in +api.ts are server endpoints, deployed with the app.

One’s own docs cover routing, loaders, and middleware in full at onestack.dev/docs.

#Zero, the sync engine

Data flows through Zero, a sync engine from Rocicorp. The short version of how it works:

• You write queries in your components. Zero syncs the rows those queries need into a local store, so reads are instant and work like local state.
• When data changes anywhere, changes stream live to every connected client. Two browsers looking at the same app stay in sync without you writing any realtime code.
• Writes go through mutators: they apply optimistically on the client, then the server confirms them against the real database.

In development the whole sync stack runs in your browser. In production the same engine runs inside your deployment. Data covers the day-to-day workflow.

#Tamagui, the UI library

Interfaces are built with Tamagui, a universal UI library. The same components render native views on iOS and optimized CSS on web, styled through themes and tokens rather than one-off values. Templates ship with a configured theme, and agents build UI in it by default.

#Data: one authoring surface, SQLite everywhere

You author your schema in Drizzle, write named queries and mutators with on-zero, and keep the same application contract in every runtime:

• In the browser: the Orez Rust sync engine and Bedrock SQLite run in one project worker.
• In production: Orez runs against SQLite in a Durable Object.

One on-zero contract over both hosts lets the same app code run unchanged across the browser and Cloudflare, and it means there is never a database for you to provision or operate.

#Production: Cloudflare

The stack deploys to Cloudflare, and only Cloudflare, on purpose. Every deploy creates an isolated Worker serving your pages, assets, and API routes, plus two Durable Objects: one running the Zero sync engine, one holding your database. Your app comes up at https://<slug>.contrast.run, with a shareable in-browser iOS version at https://ios-<slug>.contrast.run running against the same live backend.

What that shape buys you:

• Isolation. Every app is its own Worker with its own data.
• Cost. Idle apps hibernate, so keeping ten experiments deployed does not cost ten servers.
• Durability. Deployments are backed up automatically several times a day, and any snapshot can be restored without redeploying.
• No ops. Nothing to patch, resize, or monitor. Contrast owns the infrastructure end to end.

The deploy flow is in Publish, the support matrix in Deploy targets.

#Opinionated on purpose

A standardized stack is what makes an agent-driven product work. Agents ship better code on a stack they know deeply than on one they are guessing at, and every layer here was picked to survive production, with local-first sync and real isolation as the defaults. If you outgrow Contrast, nothing is locked in: Project Settings → Export project hands you the full source, and GitHub sync keeps every branch in a repo you own.