The Vantage framework
Under Vantage UI runs a compiled Rust data engine. Scroll — each layer lifts away until you reach the query builder at the core. Every layer swaps.
Open an existing app with Vantage UI — or ask an AI agent to build a custom one from your data source using CRUD, forms and lists and dashboard. Forever free.
Runs on macOS & Linux today; Windows builds are delivered for enterprise customers.
Need widgets the standard packaging doesn't ship — dashboards, specialised graphs, bespoke controls? We extend Vantage UI with custom UI elements built for your workflows.
A dedicated build only your organisation runs — the same engine underneath, a richer surface on top.
Swap the console for your own shell. vantage-ui-adapters embeds the engine into your UI framework; api-adapters exposes it as REST and live-streaming endpoints.
A thin layer of hand-written Rust wires it up — the engine underneath stays identical.
Keep your frontend. Point React — or anything else — at the streaming API endpoints and consume the same typed, cached, reactive data.
You own the UI code; Vantage owns the data path behind it.
A live viewport onto a fragment of your data. A Scenery subscribes and streams every change to the elements bound to it — sort, page and filter are part of the viewport itself.
How data flows in is a Lens strategy. The on-device default just works.
Rehome the Lens onto your API tier: sceneries fetch through your own service, with pre-warmed caches tuned for a large number of active viewports.
You implement the Lens transport in Rust; every scenery keeps the same contract.
Stream scenery diffs over WebSocket — the same reactive contract, pushed across the wire to remote clients in real time.
Push, not poll: your Rust service forwards the diff stream; screens stay live everywhere.
A high-performance local cache that keeps your working set close — reads come back in microseconds, refresh strategy is yours to script.
Ships as an ephemeral memory + disk cache. When the network gets flaky, the screen above it never blanks.
Point the Diorama at a cache your infrastructure already runs — shared between instances, surviving restarts, warmed by your own pipelines.
A custom integration written in Rust against the cache contract.
One handle with the same read and write surface over every backend. SQL dialects, SurrealDB, MongoDB, REST and GraphQL APIs, AWS, CSV, CLI tools — the full list lives on the features page.
Vista is capability-aware: it exploits what your data server can do and compensates for what it can't.
Anything can become a Vista. Implement the DataSource contract for your internal store, private queue or vendor API — and every layer above gains it instantly.
This is exactly what our dedicated commercial builds add for partners.
Business entities described declaratively through Vantage UI — columns, relations, computed expressions — in YAML and Rhai your coding agent is happy to write for you.
Change a model without shipping a binary; it all lives in git next to everything else.
Promote entities to real Rust types — compile-time checked columns, relations and subqueries. Refactor a large codebase and the compiler walks every use with you.
Built for type safety and robustness where it matters most.
A multi-dialect, composable query builder at the very bottom. One expression model that renders to SQL dialects, SurrealQL and more — nested, joined and aggregated without string glue.
Scripted straight from Vantage UI in Rhai: joins, aggregates, drill-downs — no recompile.
Go below the scripts: hand-craft queries in Rust, integrate stored procedures, or wrap a custom API as an expression — and every layer above can use it.
The bedrock is open; this is where dedicated builds go deepest.
You have selected custom components — we can assemble this stack for your organisation:
| # | Layer | Component | Status |
|---|
Custom builds, training and support live on the enterprise page. Curious about the internals first? The book has them.