One game.Three clients.Nothing drifts.

Everywhen is a monorepo with three separate clients: SwiftUI on iPhone and iPad, Kotlin and Compose on Android, React on the web. What they share is not interface code but data and rules. Content lives in one place and is compiled out to each app; new days arrive from a CDN.

Porting a scoring curve by reading Swift and retyping it in Kotlin and TypeScript works until someone tunes one of them. So the Swift is the rulebook: a generator calls the shipping Swift code and dumps 1,141 golden cases, and the Android and web tests assert against those files directly. Drag the pin, then retune Swift alone.

Tuning without a release

Native apps can’t download code, so over-the-air changes are data. Nine scoring and hint keys can be tuned from a rules.json on the CDN, each inside hard bounds. Round count, weights and the 1,000 max are not on the list: stored results, streaks and shares are built on them.

A place never repeats in the daily, and an unscheduled place is invisible in the app. At five a day that is about 150 places a month, forever, so the schedule is a ledger with rules, and a validator that fails the build.

New months reach phones as packs on Cloudflare R2, listed by one manifest. The upload order is fixed so an interrupted publish can’t hurt anyone. Try the other order.

“A manifest naming an object nobody uploaded is an outage on every phone at once; objects nobody’s manifest names are harmless litter.”

From publish.py. The phone mirrors it: a downloaded manifest is written to disk last, after its packs, and a failed fetch leaves the last good catalog exactly where it was.

You never need an account to play. Every screen reads the store on the device; signing in adds a background sync to Supabase that reconciles when it can. The interesting part is the small rules that keep that honest.

syncedAt == nil   // dirty

.upsert(rows, onConflict: "user_id,day_key",
        ignoreDuplicates: true)

let wireDateEpsilon: TimeInterval = 0.002

StreakTracker.currentStreak(days:now:)

Where the interface has to match, I share the numbers rather than the code. The review sheet moves with the same constants on all three platforms, ported from my motion prototypes.

static let decelerationRate = 0.998
static let rubberBandFactor = 0.55
static let overhang = 400.0
static let settle = Spring(stiffness: 200, damping: 30, mass: 1)
static let settleReduced = Spring(stiffness: 260, damping: 40, mass: 1)

static let size = CGSize(width: 360, height: 450)
let renderer = ImageRenderer(content:
    PassportShareCard(stats: stats, milestone: milestone))
renderer.scale = 3          // 360×450 pt → 1080×1350 px

930 icons, read the way iPhone reads them

Each place’s icon is a few SVG path strings, drawn natively everywhere. Browsers and Android forgive things iOS’s path parser doesn’t, so a glyph can look right in two places and break in the third.

All 930 places read in Traditional and Simplified Chinese: titles, clues, stories, answers and choices. Only the Traditional is written by hand. The Simplified is generated from it, so the two can’t disagree.

There is no XCTest target. Game logic lives in Foundation-only Swift files, so each rule compiles into a small command-line harness that runs without a simulator.

./scripts/ship.py runs the whole iOS release: preflight, the gate, archive, upload, and the App Store record. Android goes up through the Gradle Play Publisher, and the web deploy runs tsc -b first, so there is no way to ship a tree that doesn’t typecheck.

1. Generate agreement.Three clients stay one game when the rules are dumped from one implementation and asserted everywhere else.
2. Order writes so failure is harmless.The same rule on the server and the phone: the pointer goes last.
3. Green isn’t the flow.The first Android daily passed every test and still felt wrong in five ways. Now every port gets played end to end before it ships.