Runtime-driven application infrastructure
Mint is a runtime engine that interprets application schemas — screens, workflows, state, and data bindings — so your team can update production behavior in real time. Design visually or write schemas by hand; the runtime handles instant native rendering and live delivery.
The problem
A button label change. A workflow tweak. A new onboarding step. Each one triggers the same pipeline: code change → PR → build → test → deploy → validate. Most of these aren't code problems. They're configuration problems trapped in code.
Every single one required a code commit, a pull request, manual QA, a deployment pipeline run, and cross-team coordination. That's dozens of developer hours and CPU cycles spent on updates that contained zero new engineering logic.
Text changes require full CI/CD runs. Teams wait hours to validate what should take seconds.
Layout, logic, and content ship together. Changing a workflow means redeploying the frontend.
iOS, Android, and web each need separate deploys synced manually. Drift is inevitable.
The conversation that started it (Use headphones for clear audio)
How it works
Your application is defined as a structured schema — screens, components, data bindings, workflows, navigation. The mint runtime interprets it on every platform, for every user. Update the schema, and every connected client reflects the change in milliseconds.
Describe screens, components, state, actions, and data bindings as declarative JSON. Use the visual editor to author it, or write it by hand — the runtime doesn't care.
Push your schema to the mint runtime. No build step. No bundling. No deploy pipeline. The runtime is always listening.
The engine resolves components, executes workflows, binds data, manages state, and renders the application dynamically on each client.
Every connected client receives the update. iOS, Android, web — simultaneously. No app store review. No downtime. Sub-50ms propagation.
Platform
Screens defined as schemas, resolved at runtime. Update layouts and components without touching client code.
Multi-step workflows — approvals, conditional logic, API calls — as configurable pipelines executed server-side.
Components bound directly to data sources. The runtime handles queries, pagination, filtering, and subscriptions.
Schema updates propagate to all connected clients in real time. Rollback to any previous version in one click.
Single schema renders natively across iOS, Android, and web. One source of truth, consistent behavior everywhere.
Application state — forms, sessions, navigation — managed by the runtime with persistence, sync, and rollback built in.
A Figma-like editor for designing schemas visually. Frames become screens. Shapes become components. Everything is configurable.
Export the schema as production source code — React, Next.js, Vue, Svelte, React Native, or Flutter. You own the output.
For developers
Mint doesn't replace your engineering team. It separates what changes frequently (screens, workflows, content) from what doesn't (component implementations, business logic, infrastructure).
Register React, Flutter, SwiftUI, or Compose components. The runtime resolves schema types to your implementations.
Use your existing IDE, git, CI pipeline, and testing framework. Schemas are JSON — version them, diff them, review them.
Schemas validate against TypeScript-generated types. Mismatches surface at authoring time, not in production.
Any component can break out of the schema layer and run native code. The runtime is an accelerator, not a cage.
FAQ
No. Mint is a runtime engine. The visual editor is one way to author schemas — you can also write them by hand. The core product is the runtime that interprets those schemas across platforms, handles state, executes workflows, and delivers updates without redeployment.
Those are app builders — they generate or host applications. Mint is infrastructure. Your application runs on your stack, with your components, in your deployment. The runtime sits alongside your code and handles the parts that change frequently. You control everything else.
Instead of compiling configuration into static code that needs redeployment, the runtime interprets a schema at execution time. When the schema changes, the application changes — without a new build, without a new deploy, without an app store review.
Yes. The visual editor exports production code to React, Next.js, Vue, Svelte, React Native (Expo), or Flutter. Full project scaffolds with routing, dependencies, and config. You can commit it to git and keep building on it.
You define tables visually — column names, types, constraints, relations. Mint generates the PostgreSQL schema and API routes. Your application talks to a real database with proper migrations, not a mock.
A lightweight daemon polls the server every 2 seconds. When you publish a schema update, it downloads the changed files and writes them to disk. Your dev server's hot reload picks up the changes. In production, the runtime delivers updates directly — no files involved.
The client SDK caches the last-known schema locally. The application continues operating. When connectivity is restored, the runtime syncs the latest version automatically. No user-visible interruption.
Join the waitlist. We'll let you in when your spot opens.