Labs · la superficie de la app
La app hecha a medida, y para quedarse.
No un producto remodelado para usted — una app construida para el terreno donde opera: educación, industria, o cualquier sector que traiga. Un núcleo en Rust que funciona sin una sola barra de señal, nativa en cada pantalla, y un diseño donde sus datos siguen siendo suyos.
No una plantilla con sus colores. Software moldeado al trabajo para el que realmente existe.
Un aula, una línea de fábrica, un equipo de campo — la app está escrita para cómo sucede realmente ese trabajo, no para una demostración. El sector la moldea, no al revés.
Un sótano, un lugar remoto, una zona sin señal — el trabajo no se detiene. El dispositivo conserva la verdad, y se reconcilia con el borde en el momento en que la señal vuelve.
Ninguna cuenta que no pueda dejar, ningún dato tomado como rehén. El núcleo es suyo, los registros son suyos, y el ingeniero que la construyó es quien responde.
Cuatro cifras de una app construida para durar.
El oficio de una app seria es un núcleo que el compilador vigila, que sigue
funcionando sin señal, y que corre en cada terreno desde una sola fuente de verdad.
El código permanece en inglés — la lengua universal de la ingeniería.
// 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.
Por qué una app construida para su terreno vence a un producto remodelado para encajar.
Un producto remodelado no puede estar hecho para su terreno — se creó antes de que su terreno existiera. Una app solo en línea no puede ganarse la confianza donde la señal muere — la espera viene incorporada. Por eso escribimos un solo núcleo en Rust, lo vigilamos con el compilador y lo firmamos nosotros mismos — y por eso cotizamos lo que medimos, no un precio de estante.
Antes de escribir una línea, cómo se guarda su trabajo. Esta parte no es negociable.
Un NDA es aquí lo habitual, no un extra. Lo que comparte lo lee un solo ingeniero y nadie más — nada se vende, se comparte ni se transfiere.
Las credenciales y los registros permanecen en su casa, bajo el mínimo privilegio necesario. No guardamos ninguna copia que no necesitemos, y nada sale de su alcance sin su palabra.
Lo que corre en su casa es suyo para leer y auditar — ninguna caja negra que deba confiar sin ver. La sala de máquinas sigue siendo nuestra; lo que usted opera es suyo.
Dos líneas — el terreno donde opera, y el trabajo que debe llevar. Las leemos nosotros mismos y respondemos nosotros mismos.
Ya está en una pantalla en Zúrich — no en una cola, no en un ticket. El ingeniero que construiría esto lo lee, y responde él mismo.
·