Ship a complete PostgreSQL database inside desktop and mobile software or a WASIX host. Keep data in an app-owned root and use it through a language SDK or, where supported, a local PostgreSQL endpoint.

An abstract layered PostgreSQL elephant sculpture representing the database embedded inside the application.

Language SDKs

  • Rust
  • Swift
  • Kotlin
  • React Native
  • TypeScript

Keep product data in one PostgreSQL model.

Relations, JSONB, geospatial queries, full-text search, and vectors can live in the same app-owned root.

Knowledge and creative tools

Relate documents, projects, revision history, metadata, and search in one model.

relations · JSONB · full-text search
Documents branch into revision history while staying connected to project metadata.

Field and mobile software

Keep records with the app and run spatial queries where the target ships PostGIS.

transactions · geography · recovery
A field location intersects nearby assets inside a PostGIS search radius.

Local retrieval

Store vectors beside source data and combine similarity with relational filters.

pgvector · indexes · structured filters
A query vector converges on the nearest documents after relational filtering.

Local data workbenches

Import, inspect, transform, and query complex datasets with PostgreSQL behavior.

SQL · types · extensions
Imported data moves through PostgreSQL tables into an inspected result set.

What ships with the app.

Oliphaunt packages PostgreSQL, its runtime, and verified extension builds for the target.

PostgreSQL 18 is the engine.

Ship PostgreSQL storage, SQL, types, transactions, indexes, WAL, and recovery inside an application-owned database root.

PostgreSQL SQL, relational storage, indexes, and write-ahead logging operate as one engine inside an application-owned boundary.

Native or WASIX.

Use native direct, broker, or server modes on supported platforms. For WASIX hosts, ship portable runtime assets with target-specific carriers.

Native and WASIX runtime families both carry a PostgreSQL 18 engine, with capabilities bounded by the selected target.
Nativedirect · broker · server
WASIXportable runtime assets
Compare target support

PostGIS and pgvector, in the app.

Add spatial data, vector search, full-text search, trigram indexes, crypto, UUIDv7, and more across native and WASIX targets.

Verified PostgreSQL extensions dock into the same embedded engine across supported target profiles.
  • PostGISspatial
  • pgvectorvectors
  • FTSsearch
  • pg_trgmmatching
  • pgcryptocrypto
  • UUIDv7identity

Target-verified extension builds

Browse verified extensions

Use PostgreSQL from your stack.

Open the root, create a schema, bind values, and read typed rows from Rust, Swift, Kotlin, React Native, or TypeScript.

Rustoliphaunt
use oliphaunt::Oliphaunt;async fn open_database() -> oliphaunt::Result<()> {    let db = Oliphaunt::builder()        .path(".oliphaunt")        .native_direct()        .open()        .await?;    db.execute(r#"        CREATE TABLE IF NOT EXISTS todos (            id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,            title text NOT NULL UNIQUE,            done boolean NOT NULL DEFAULT false        )    "#).await?;    db.query_params(        "INSERT INTO todos (title) VALUES ($1)          ON CONFLICT (title) DO UPDATE SET done = false",        ["Run the first product query"],    ).await?;    let todos = db        .query("SELECT title FROM todos WHERE NOT done ORDER BY id DESC LIMIT 20")        .await?;    let first_title = todos.get_text(0, "title")?;    db.close().await?;    Ok(())}

See the integration boundaries in code.

Four committed apps exercise native and WASIX paths through Tauri and Electron.

Tauri / Native

Rust SDK · app-owned root

Rust owns the Oliphaunt handle in application state.

Source

Tauri / WASIX

WASIX sidecar · SQLx

OliphauntServer exposes a local PostgreSQL URL to SQLx.

Source

Electron / Native

TypeScript SDK · native server

The TypeScript SDK runs native server mode in the main process.

Source

Electron / WASIX

WASIX sidecar · local endpoint

A Rust sidecar supplies a local PostgreSQL URL to the main process.

Source

Open an app-owned PostgreSQL root. Run the first product query.