TypeScript-only · cross-platform

Write your app once.
Ship it native on mobile, web, and desktop.

One TypeScript codebase, compiled to real native UI on mobile, web, and desktop. The data layer is built in — local-first storage and REST behind a single model, so you never hand-write a fetch or a line of SQL.

iOS · Android Web macOS · Windows · Linux
models/todo.ts 
import { Model, registerModel, DbGateway } from '@sublime-ui/framework';

export class Todo extends Model {
  protected static resource = '/todos';
  declare id:    string;
  declare title: string;
  declare done:  boolean;
}

// persisted to the local DB, reactive everywhere
registerModel(Todo, DbGateway);
Why Sublime UI

One model in. Native apps out — with the types intact.

One model, many platforms

Define your data and logic once. Sublime UI projects it onto every platform you target — no per-platform rewrites.

Platform-native UI

Shared building blocks render as real MUI on web and Paper on mobile — actual native components, not a webview.

Compile-time, not runtime

Navigation and the native bridge are generated with full types. Errors surface in your editor, not in production.

A CLI that scaffolds it all

One command sets up the workspace, platforms, and tooling. Add a model, get screens and routes wired in automatically.

Agnostic data layer

Your model talks to a Gateway — never to fetch() or SQL.

Pick a backend per model — a local database or a REST API. The model API is identical either way: Sublime UI makes the RESTful calls and opens the database connections for you, typed end to end. You write models, not plumbing.

Swap DB ↔ REST — your screens don't change
Automatic RESTful calls & DB connections
Reactive reads, offline-first writes
app/data.ts 
// local-first → IndexedDB (web) · SQLite (native)
registerModel(Todo, DbGateway);

// REST API → GET / POST / PUT / DELETE
registerModel(Post, HttpGateway);

// same model API either way:
const posts = Post.rxAll();          // reactive
await Post.make({ title }).save(); // no fetch
One codebase

One source. Three real builds.

The same project compiles to a genuinely native app on every target — no forks, no per-platform repos, no rewrite. Build them all from one command line.

Mobile
$ sublime build → Android APK / AAB · iOS
Web
$ npm run build:web → static bundle (Vite)
Desktop
$ sublime desktop:build → macOS · Windows · Linux
Native bridge

Reach the OS through one secure channel.

Call into Node and native OS capabilities — printers, filesystem, hardware — with a single typed hook. Every call crosses one audited, permission-scoped bridge. No ad-hoc native modules, no leaky globals.

printer filesystem camera notifications
receipts/print.ts 
const printer = useNative('printer');

await printer.print({
  template: 'receipt',
  order,
});
// typed end-to-end, OS-side
// runs over the secure bridge
The packages

Focused packages. One coherent system.

@sublime-ui/framework Models, gateways, state, and the compile-time core that ties every platform together.
@sublime-ui/library The tokens-first design system — real MUI on web, React Native Paper on mobile.
@sublime-ui/ui Cross-platform navigation (storybook → React Navigation / react-router) and layout primitives.
@sublime-ui/storage Local-first persistence — IndexedDB on web, SQLite on desktop & mobile, behind one Gateway.
@sublime-ui/desktop Native desktop shells for macOS, Windows, and Linux with the same codebase.
@sublime-ui/devkit The CLI, codegen, and dev server that scaffold and build the whole workspace.

Build once · ship everywhere.

Spin up a fully-wired cross-platform workspace in one command.

$ npm create @sublime-ui/app