Labs · the app surface
The app built to measure, and to keep.
Not a product reshaped for you — one built for the floor it runs on: education, industry, or whatever sector you bring. A Rust core that works with zero bars of signal, native on every screen, and a design where your data stays yours.
Not a template with your colours. Software shaped to the work it is actually for.
A classroom, a factory line, a field crew — the app is written for how that work really happens, not for a demo. The sector shapes it, not the other way around.
A basement, a remote site, a dead spot — the work does not stop. The device keeps the truth, and reconciles with the edge the moment the signal returns.
No account you cannot leave, no data held hostage. The core is yours, the records are yours, and the engineer who built it is the one who answers.
Four figures from an app built to last.
The craft of a serious app is a core the compiler guards, that keeps working with no signal, and that runs on every floor from one source of truth.
// the core of the app · typed, so a wrong state cannot be reached #[derive(Clone, Deserialize)] struct Job { id: Uuid, site: SiteId, state: State, // Scheduled → OnSite → Done — nothing else is legal readings: Vec<Reading>, synced: bool, // the device knows what the edge has not yet seen } impl Job { /// A job closes only once every required reading is in. fn can_close(&self) -> bool { matches!(self.state, State::OnSite) && self.readings.iter().all(Reading::valid) } }
// works at zero bars · the floor does not wait for a signal fn record(&mut self, r: Reading) { self.readings.push(r.clone()); self.queue.push(Op::Add(r)); // kept on the device, durable self.synced = false; } /// When the signal returns, the device reconciles — in order, idempotent. async fn reconcile(&mut self, edge: &Edge) -> Result<()> { for op in self.queue.drain(..) { edge.apply(op).await?; // the edge is the record; the device, the witness } self.synced = true; Ok(()) }
# one core, every floor it must run on [targets] ios = "aarch64-apple-ios" # a thin Swift shell over the Rust core android = "aarch64-linux-android" # a thin Kotlin shell over the same core desktop = "x86_64 · aarch64" # Windows · macOS · Linux # the logic is written once, in Rust. only the shell changes per floor. # Swift and Kotlin carry the screen; Rust carries the truth.
Why an app built for your floor beats a product reshaped to fit it.
A reshaped product cannot be made for your floor — it was made before your floor was known. An online-only app cannot be trusted where the signal dies — waiting is built into it. That is why we write one Rust core, guard it with the compiler, and sign it ourselves — and why we quote what we measure, not a shelf price.
Before a line is written, how your work is kept. This part is not negotiable.
An NDA is the default here, not an upsell. What you share is read by one engineer and no one else — nothing is sold, shared, or passed on.
Credentials and records stay in your house, under least privilege. We keep no copy we do not need, and nothing leaves your reach without your word.
What runs in your house is yours to read and audit — no black box you must trust unseen. The engine room stays ours; what you run is yours.
Two lines — the floor it runs on, and the work it must carry. We read them ourselves and we answer ourselves.
It is already on a screen in Zürich — not in a queue, not in a ticket. The engineer who would build this reads it, and writes back himself.
·