The Vantage framework

# One engine. Six layers.
Cut it open.

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.

Layer 00 · Presentation

## Vantage UI

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.

Free Built into Vantage UI One-click download YAML + Rhai

## Vantage custom UI

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.

Built by our team Custom widgets Dedicated build

## UI & API adapters

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.

Requires Coding vantage-ui-adapters api-adapters

## React + your code

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.

Requires Coding Your frontend Live endpoints

Swap this layer

Layer 01 · Reactive viewport

## Scenery

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.

Built into Vantage UI Streams changes Virtualised paging

## Lens · API adapter

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.

Requires Coding Server-side Lens Pre-warmed

## Lens · WebSocket

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.

Requires Coding Live diffs Push, not poll

Swap this layer

Layer 02 · Local cache

## Diorama

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.

Built into Vantage UI Latency collapsed Memory + disk

## External cache

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.

Requires Coding Shared cache Survives restarts

Swap this layer

Layer 03 · Universal interface

## Vista

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](https://vantage-ui.com/features/).

Vista is capability-aware: it exploits what your data server can do and compensates for what it can't.

Built into Vantage UI 12+ backends Capability-aware

## Custom DataSource

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.

Requires Coding DataSource trait One handle

Swap this layer

Layer 04 · Business logic

## Entity Tables

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.

Built into Vantage UI AI-written Declarative

## Custom entity models

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.

Requires Coding Typed columns Relations & subqueries

Swap this layer

Layer 05 · The core

## Query Builder

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.

Built into Vantage UI Multi-dialect Composable

## Custom queries

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.

Requires Coding Stored procedures Custom APIs

Swap this layer

## We can assemble the right stack for your organisation

You have selected custom components — we can assemble this stack for your organisation:

| # | Layer | Component | Status

[Discuss your stack with us](https://vantage-ui.com/solutions/enterprise/)

Custom builds, training and support live on the [enterprise page](https://vantage-ui.com/solutions/enterprise/). Curious about the internals first? The [book](https://vantage-ui.com/book/) has them.
