v3.19.1

HeliosDB Nano

The database that replaces your entire stack. HeliosDB Nano packs PostgreSQL + MySQL wire protocols, native vector search, database branching, time-travel queries, and AES-256 encryption into a 47 MB binary that uses 30 MB of RAM — while MySQL alone needs 570 MB and 400 MB RAM without any of those features.

Built in Rust for AI-powered applications, edge deployments, WordPress/CMS platforms, and any modern app that needs more than just SQL. Every feature in Nano is also available in Lite and Full, making it easy to start small and scale up.

47 MB Docker Image

~30 MB RAM Usage

10ms Startup Time

25 Use Cases

Rust

// Three lines to a working database
let db = HeliosDB::open("myapp.db")?;

db.execute("CREATE TABLE docs (
    id SERIAL PRIMARY KEY,
    content TEXT,
    embedding VECTOR(768)
)")?;

// Semantic search in one query
let results = db.query("
    SELECT content, embedding <=> $1 AS dist
    FROM docs ORDER BY dist LIMIT 10
", &[&query_vec])?;

Native Vector Search

HeliosDB Nano includes built-in vector search powered by HNSW indexing with Product Quantization compression. No extensions required — vector types and operators are first-class citizens in the SQL engine.

HNSW indexing with configurable M and ef_construction parameters
384x compression via Product Quantization (PQ)
1K-5K queries/sec on standard hardware
Cosine similarity, L2 distance, and inner product metrics
Works with any embedding model (OpenAI, Cohere, HuggingFace)

SQL

-- Create a table with vector column
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    title TEXT,
    content TEXT,
    embedding VECTOR(768)
);

-- Create HNSW index with PQ compression
CREATE INDEX idx_docs_embedding
ON documents USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 200);

-- Semantic similarity search
SELECT title, content,
       embedding <=> $query_vec AS distance
FROM documents
ORDER BY distance
LIMIT 10;

Database Branching

HeliosDB is the only SQL database with Git-like branching at the storage layer. Create zero-cost copy-on-write branches for schema testing, A/B experiments, and safe migrations — without duplicating data.

Zero-cost copy-on-write branch creation
CREATE BRANCH, SWITCH BRANCH, MERGE BRANCH SQL syntax
Branch from any point in time
Schema testing without affecting production
A/B experiment isolation

SQL

-- Create a branch for schema testing
CREATE BRANCH feature_auth
FROM main;

-- Switch to the new branch
SWITCH BRANCH feature_auth;

-- Make changes safely
ALTER TABLE users
ADD COLUMN role TEXT DEFAULT 'user';

-- Test the changes...
INSERT INTO users (name, role)
VALUES ('admin', 'superuser');

-- Merge back when satisfied
SWITCH BRANCH main;
MERGE BRANCH feature_auth
INTO main;

Time-Travel Queries

Query any point in your database's history using the AS OF syntax. Time-travel enables audit compliance, production debugging, and data recovery without restoring from backups.

AS OF TIMESTAMP syntax for point-in-time queries
AS OF VERSION for exact version access
Configurable retention periods (7 days default)
Audit trail and compliance reporting
Instant data recovery without backup restores

SQL

-- Query data as it existed yesterday
SELECT * FROM orders
AS OF TIMESTAMP '2026-02-05 14:30:00';

-- Compare current vs. historical data
SELECT
    current.balance,
    historical.balance AS prev_balance,
    current.balance - historical.balance AS delta
FROM accounts current
JOIN accounts AS OF VERSION 42 historical
    ON current.id = historical.id;

-- Recover accidentally deleted data
INSERT INTO users
SELECT * FROM users
AS OF TIMESTAMP '2026-02-05 09:00:00'
WHERE id = 1234;

Enterprise Security

HeliosDB Nano ships with enterprise-grade security features built in, not bolted on. From transparent data encryption to zero-knowledge encryption, your data is protected at every level.

Transparent Data Encryption (TDE) with AES-256-GCM
Zero-Knowledge Encryption (ZKE) with client-side keys
FIPS 140-3 compliance mode
Row-Level Security (RLS) for multi-tenancy
Tamper-proof audit logging with cryptographic checksums

SQL

-- Enable transparent data encryption
ALTER DATABASE myapp
SET encryption = 'AES-256-GCM';

-- Enable zero-knowledge encryption
ALTER TABLE sensitive_data
SET encryption_mode = 'ZKE';

-- Row-Level Security for multi-tenancy
CREATE POLICY tenant_isolation
ON orders
FOR ALL
USING (tenant_id = current_setting('app.tenant_id'));

-- FIPS 140-3 compliance (all tiers)
-- Enabled via compile-time feature flag
-- to avoid runtime performance impact
cargo build --features fips --release

PostgreSQL Compatibility

HeliosDB Nano achieves 95%+ SQL compatibility with PostgreSQL, including full wire protocol support. Use your existing tools, ORMs, and workflows without changes.

95%+ PostgreSQL SQL syntax compatibility
Full PostgreSQL wire protocol support
Works with psql, DBeaver, pgAdmin, DataGrip
ORM support: SQLAlchemy, Diesel, Prisma, SQLx, GORM
Oracle wire protocol compatibility
JSONB document type with GIN indexes

SQL

-- Standard PostgreSQL syntax works
CREATE TABLE products (
    id SERIAL PRIMARY KEY,
    name TEXT NOT NULL,
    metadata JSONB,
    created_at TIMESTAMPTZ DEFAULT now()
);

-- JSONB queries with GIN indexing
CREATE INDEX idx_meta
ON products USING gin (metadata);

SELECT name, metadata->>>'category'
FROM products
WHERE metadata @> '{"active": true}';

-- Window functions, CTEs, all work
WITH ranked AS (
    SELECT *,
        ROW_NUMBER() OVER (
            PARTITION BY category
            ORDER BY sales DESC
        ) AS rank
    FROM products
)
SELECT * FROM ranked
WHERE rank <= 5;

MySQL Wire Protocol

HeliosDB Nano is the first embedded database to support both PostgreSQL and MySQL wire protocols natively. Connect with any MySQL client, driver, or ORM — no external middleware required — MySQL syntax is translated transparently.

Full MySQL v10 handshake with 5.7/8.0 compatibility modes
mysql_native_password and caching_sha2_password authentication
COM_QUERY, COM_STMT_PREPARE/EXECUTE for prepared statements
SHOW DATABASES, TABLES, COLUMNS, VARIABLES — full client compatibility
TLS encryption (STARTTLS) using the same certificates as PostgreSQL
Localhost-only binding by default for security (--mysql-listen)

Terminal

# Start with both PostgreSQL and MySQL protocols
$ heliosdb-nano start --data-dir ./mydata --mysql

# Connect with PostgreSQL client
$ psql -h 127.0.0.1 -p 5432

# Connect with MySQL client (same database!)
$ mysql -h 127.0.0.1 -P 3306

# Same data, same tables, any protocol
mysql> SELECT * FROM users;
+----+-------+-------------------+
| id | name  | email             |
+----+-------+-------------------+
|  1 | Alice | alice@example.com |
+----+-------+-------------------+

Built-in Backend-as-a-Service

HeliosDB Nano includes a complete BaaS layer — no Supabase, no Firebase, no external services required. Auth, REST API, Realtime subscriptions, and file storage are built into the same binary that runs your database.

REST API with 19 PostgREST-compatible filter operators (eq, like, in, gt, ...)
Built-in Auth: email/password signup, JWT sessions, token refresh
OAuth2: Google and GitHub login with PKCE and automatic user creation
Realtime WebSocket: subscribe to INSERT/UPDATE/DELETE on any table
Row-Level Security enforced on all REST endpoints via JWT claims
Argon2id password hashing, signed URLs, API key authentication
Swagger UI at /docs + OpenAPI 3.0 spec at /openapi.json — interactive API explorer built in

Terminal

# REST API — zero config, works out of the box
$ curl localhost:8080/rest/v1/users?role=eq.admin&select=id,name

# Auth — built-in signup and JWT
$ curl -X POST localhost:8080/auth/v1/signup \
  -d '{"email":"alice@example.com","password":"s3cret"}'

# OAuth — redirect to Google login
$ curl localhost:8080/auth/v1/authorize?provider=google

# Realtime — WebSocket subscription
wscat -c ws://localhost:8080/realtime/v1/websocket
> {"event":"phx_join","topic":"realtime:public:orders"}

v3.19.1

BM25 + Vector Hybrid Search

HeliosDB Nano now combines keyword search (BM25 scoring) with vector similarity in a single query. Reciprocal Rank Fusion (RRF) and Maximal Marginal Relevance (MMR) merge both result sets — no Elasticsearch, no external search service.

BM25 full-text scoring — TF-IDF based relevance ranking with configurable k1 and b parameters, built into the SQL engine.
Hybrid search — Combine WHERE content MATCH 'query' (keyword) with embedding <=> $vec (semantic) in one query.
RRF / MMR fusion — Reciprocal Rank Fusion merges ranked lists. MMR maximizes diversity in results. Both available as SQL functions.
Replaces Elasticsearch — Full-text search + vector search + SQL in one 47 MB binary. No cluster, no Java, no separate index.
Compiled query plans — PREPARE COMPILED pre-optimizes hot-path queries. Cached execution plans skip planning overhead on repeated calls.

SQL

-- Keyword search (BM25)
SELECT title, bm25_score(content, 'database')
FROM articles
ORDER BY bm25_score DESC LIMIT 10;

-- Hybrid: keyword + vector with RRF
SELECT title,
  rrf(
    bm25_score(content, 'database scaling'),
    1.0 - (embedding <=> $query_vec)
  ) AS score
FROM articles
ORDER BY score DESC LIMIT 10;

-- MMR for diverse results
SELECT * FROM mmr(
  'articles', 'embedding',
  $query_vec, 10, 0.7
);

v3.19.1

Native Graph Queries

Query graph relationships on your relational data without a separate graph database. HeliosDB Nano v3.19.1 adds native adjacency list storage and graph traversal functions — SQL + Vector + Graph + Full-Text in one binary.

Graph adjacency lists — Store and query relationships directly. No separate graph engine needed.
Path traversal — Find shortest paths, connected components, and neighborhood queries via SQL functions.
Multi-model in one binary — Relational SQL + HNSW vector search + BM25 full-text + graph traversal. No other embedded database offers all four.
RAG + Knowledge Graphs — Combine semantic search with graph structure for GraphRAG applications without additional infrastructure.

SQL

-- Create graph edges
CREATE TABLE edges (
  src INT, dst INT,
  rel TEXT, weight FLOAT
);

-- Find neighbors
SELECT dst, rel, weight
FROM graph_neighbors('edges', 42);

-- Shortest path
SELECT * FROM graph_shortest_path(
  'edges', 1, 99
);

-- GraphRAG: semantic + structure
SELECT n.title, n.embedding <=> $q
FROM graph_neighbors('edges', 42) g
JOIN nodes n ON n.id = g.dst
ORDER BY n.embedding <=> $q
LIMIT 5;

v3.15–v3.19 · AI-Native Retrieval

Code-Graph — Your Source as a Queryable Database

Most code-search tools live outside the database — bolt-ons that scan, index, and re-index your repo with their own storage. HeliosDB Nano makes the AST a first-class table. CREATE EXTENSION hdb_code; CREATE AST INDEX ON src/, and your codebase becomes queryable in SQL. LSP-style queries push down through the same FilteredScan path that bloom-filters and zone-maps already accelerate.

SQL-callable LSP — lsp_definition, lsp_references, lsp_call_hierarchy, lsp_hover, lsp_document_symbols, helios_lsp_rename_preview / helios_lsp_rename_apply. The last two land write-side refactors with sha256 conflict checking.
Multi-language — Rust, Python, TypeScript, TSX, JavaScript, Go, Markdown, SQL out of the box, plus a runtime grammar registry (register_grammar + register_extractor) for plugging in any tree-sitter grammar.
Time-travel + branch on every call — ON BRANCH '<name>' per-call override and AS OF combine in either order. RAII branch guard restores state on every early-return path.
Auto-reparse + git-hook CLI — tree stays current as you commit. hdb_code.pause() / resume() for migrations.
In-process embeddings — build with --features code-embed and Nano embeds locally with fastembed-rs + BGESmallENV15 (384-dim, ~30 MB model cache, no on-disk impact on the binary). External HttpEmbedder remains an option.
Diff helpers — helios_lsp_references_diff, helios_lsp_body_diff, helios_ast_diff. Accept any AS OF ref: {"now": true}, {"commit": "sha"}, {"timestamp": "iso"}.

SQL

-- Index your repo as a queryable AST
CREATE EXTENSION hdb_code;
CREATE AST INDEX ON repo (path, lang, content);

-- Where is this function defined?
SELECT path, line FROM lsp_definition('execute_query');

-- Time-travel + branch on the same call (v3.19)
SELECT * FROM lsp_definition('execute_query')
  ON BRANCH 'feat/refactor'
  AS OF TIMESTAMP '2026-04-15T00:00:00Z';

-- Rename refactor with conflict check (v3.19)
SELECT * FROM helios_lsp_rename_preview(
  'old_name', 'new_name'
);
SELECT * FROM helios_lsp_rename_apply(
  'old_name', 'new_name',
  dry_run := false
);

-- Diff helpers
SELECT * FROM helios_lsp_references_diff(
  'main', 'feat/refactor'
);

-- Languages registered (system view, v3.19)
SELECT name, source FROM hdb_code_languages;

v3.17–v3.19 · AI-Native Retrieval

Graph-RAG — Grounded Retrieval in SQL

RAG pipelines glue together a vector store, a graph database, an entity linker, and a re-ranker — four services to deploy and keep in sync. HeliosDB Nano collapses them into one engine. WITH CONTEXT is a SQL clause; _hdb_graph.nodes and _hdb_graph.edges are queryable tables; entity linking and auto-projection happen on insert.

Cross-modal graph — code symbols, doc paragraphs, email threads, and issue comments live in the same node/edge tables and join naturally.
Centrality re-ranking + vector prefilter — (1−α)·distance − α·centrality. Prefilter-aware HNSW wrapper over-fetches candidates, applies row-level prefilters, then re-scores.
Semantic-Merkle invalidation — CREATE SEMANTIC HASH INDEX exposes subtree hashing at the SQL layer. Only re-embed what changed.
Six ingestion adapters — graph_rag_ingest_docs, _email, _issues, _qa — plus Docling-backed PDF / Office / audio / image (v3.19).
Vector-similar entity linker (v3.19) — graph_rag_link_vector emits MENTIONS edges with weight = similarity; threshold-gated cosine top-k.
Acceptance benchmark — 100-query mean of 62 ms on a 10k-node fixture (target was 500 ms); entity-linker precision 100% on hand-labelled fixture (target 80%).

SQL + ingestion

-- Ingest a PDF, an Office doc, audio, an image (v3.19)
SELECT graph_rag_ingest_pdf('/docs/handbook.pdf');
SELECT graph_rag_ingest_office('/contracts/2026-Q1.docx');
SELECT graph_rag_ingest_audio('/calls/standup.m4a');
SELECT graph_rag_ingest_image('/diagrams/topology.png');

-- Ground an LLM query with subgraph context
SELECT answer
FROM ask_llm('What changed in the auth flow last quarter?')
WITH CONTEXT (
    seed_text   = 'auth flow',
    seed_kinds  = ['function', 'doc'],
    edge_kinds  = ['IMPORTS', 'REFERENCES', 'MENTIONS'],
    hops        = 3,
    rerank      = 'centrality'
);

-- Incremental re-embed via semantic-Merkle (v3.19)
CREATE SEMANTIC HASH INDEX IF NOT EXISTS
  graph_rag_chunks_hash ON _hdb_graph.nodes;

v3.18–v3.19 · AI-Native Retrieval

Native MCP Server — Drop-In for Coding Agents

Every modern coding agent — Claude Code, Cursor, Continue, Codex, Aider — speaks Model Context Protocol. HeliosDB Nano speaks it natively. No wrapper process, no glue server, no shell-out. Tool discovery (tools/list), execution (tools/call), and a JSON-RPC 2.0 handshake on three transports.

Three transports — POST /mcp (HTTP JSON-RPC), /mcp/ws (WebSocket), /mcp/sse (Server-Sent Events). Plus stdio for sandboxed agents.
Hardened defaults — JWT auth, Unix-socket transport for sandboxed agents, public-bind opt-in only.
Auto-registered tool catalogue — mcp_tool! macro registers via the inventory crate. BM25, hybrid search, graph operations, and helios_graphrag_search surface automatically.
Streaming progress (v3.19) — notifications/progress messages flow over WS and stdio when the client opts in via _meta.progressToken. helios_graphrag_search emits "seeding" and "n hits" events for live UX.
Single-shot discovery (v3.19) — tools/list?verbose=true, helios/info JSON-RPC method, GET /mcp/info route. One round-trip for serverInfo + capabilities + verbose tool catalogue + resource list.
HTTP POST + SSE pairing (v3.19) — process-static session table keyed by Mcp-Session-Id. POSTs paired with an open SSE channel get progress events forwarded while the POST returns the final response.

MCP transports

# Discover tools (v3.19 verbose)
curl -X POST http://localhost:8080/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"tools/list",
       "params":{"verbose":true},"id":1}'

# helios/info: one-shot discovery
GET http://localhost:8080/mcp/info

# Streaming progress over WebSocket (v3.19)
ws://localhost:8080/mcp/ws
> {"jsonrpc":"2.0","method":"tools/call",
   "params":{"name":"helios_graphrag_search",
             "arguments":{"seed_text":"auth flow"},
             "_meta":{"progressToken":42}},"id":2}
< notifications/progress {"token":42, "message":"seeding"}
< notifications/progress {"token":42, "message":"127 hits"}
< tools/call response <final>

# Or via Claude Code / Cursor MCP config
{
  "mcpServers": {
    "heliosdb-nano": {
      "url": "http://localhost:8080/mcp",
      "auth": {"type":"bearer","token":"$HDB_TOKEN"}
    }
  }
}

v3.19 Acceptance Benchmarks

Defensible Numbers

First measured numbers for the AI-retrieval pitch. Single-machine, release build, criterion methodology.

Workload	Target	Measured
`WITH CONTEXT` mean (10k-node fixture, 100 queries)	≤ 500 ms	62 ms
Entity linker precision (hand-labelled fixture)	≥ 80 %	100 %

Source: tests/with_context_bench.rs, tests/linker_precision.rs. All-features release build (35.0 MiB).

Game Changer

WordPress Without a Database Server

WordPress powers 43% of the web. Every installation requires a separate MySQL server — until now. HeliosDB Nano v3.19.1 runs WordPress 100% natively: 37/37 tests pass, zero workarounds, no db.php required. The first embedded database to achieve this.

Zero-Server WordPress

Deploy WordPress as a single container with one process. No separate MySQL instance, no credentials, no server coordination. Just PHP and a single database file.

Branching for Staging

CREATE BRANCH staging — instant copy-on-write clone for testing plugins and themes. No mysqldump, no restore, no downtime. Merge or discard when done.

Time-Travel Undo

SELECT * FROM wp_posts AS OF TIMESTAMP '2024-01-01' — recover any deleted post, page, or setting without backups.

Semantic Content Search

Native HNSW vector search means WordPress can do semantic search without Elasticsearch or Algolia. Find content by meaning, not just keywords.

Encryption at Rest

AES-256-GCM TDE with zero WordPress plugin changes. Every shared hosting customer gets database encryption automatically. GDPR compliance built in.

Single-File Backup

Just copy mysite.helio. No mysqldump, no credentials, no server coordination. Atomic, consistent, instant backup and restore.

Polyglot Protocol

One Database, Every Driver

HeliosDB Nano is the only database where you can connect with psql, mysql, and the embedded Rust API to the same data simultaneously. This isn't protocol emulation — it's native wire protocol support for both PostgreSQL and MySQL.

Migration without migration — Switch from MySQL to PostgreSQL (or vice versa) by changing the connection string. No schema rewrite, no data export.
Mixed-stack teams — Python team uses psycopg2, PHP team uses mysqli, Rust service uses the embedded API. Same tables, same transactions.
CMS ecosystem — WordPress, Drupal, Joomla, Laravel, Symfony, Rails, Django — any framework that speaks MySQL or PostgreSQL connects natively.
Edge PHP — First embedded MySQL-compatible engine for serverless PHP on Cloudflare Workers, Vercel Edge, and Lambda@Edge.

Same Data, Three Protocols

# Connect via PostgreSQL
$ psql -h localhost -p 5432
=> SELECT * FROM users;

# Connect via MySQL (same data!)
$ mysql -h 127.0.0.1 -P 3307
> SELECT * FROM users;

# Connect via embedded Rust API
let db = EmbeddedDatabase::new("mydata");
let rows = db.query("SELECT * FROM users")?;

# All three see the same tables,
# same rows, same transactions.
# Switch drivers without migrating data.

Ecosystem

Every Framework, One Database

WordPress is the biggest prize, but the same polyglot value applies to every MySQL or PostgreSQL framework.

Framework	Protocol	HeliosDB Nano
WordPress / Drupal / Joomla	MySQL	✓ Native
Laravel / Symfony (PHP)	MySQL / PG	✓ Both
Ruby on Rails	MySQL / PG	✓ Both
Django (Python)	MySQL / PG	✓ Both
Express / Fastify (Node.js)	PG / MySQL	✓ Both
Rust (SQLx / Diesel)	PG / Embedded	✓ All 3

Why Switch

12x Smaller. Infinitely More Capable.

MySQL gives you SQL in a 570 MB image. HeliosDB Nano gives you SQL + vector search + branching + time-travel + encryption in 47 MB — with native MySQL and PostgreSQL protocol support. WordPress runs 100% natively: 37/37 tests pass, zero workarounds.

47 MB Docker image vs MySQL's 570 MB — 12x smaller
~30 MB RAM vs MySQL's ~400 MB — 13x less memory
10ms startup vs MySQL's 5-10 seconds — 500x faster cold start
WordPress 37/37 PASS — Admin, REST API, login, content CRUD, tags, categories. No db.php, no PHP workarounds, standard wpdb.
30+ MySQL translations — ON CONFLICT, comma-joins, SHOW commands, backtick stripping, date functions, type coercion — all built in.

First embedded database to run WordPress natively — PostgreSQL, MySQL, and SQLite compatible from a single binary. Verified on Nano v3.19.1.

Nano vs MySQL vs MariaDB

# Resource Comparison

Docker Image
  HeliosDB Nano   47 MB
  MariaDB         400 MB
  MySQL 8.0       570 MB

RAM Usage
  HeliosDB Nano   ~30 MB
  MariaDB         ~300 MB
  MySQL 8.0       ~400 MB

Startup Time
  HeliosDB Nano   10ms
  MariaDB         3-5s
  MySQL 8.0       5-10s

Embedded Mode
  HeliosDB Nano   Yes
  MariaDB         No
  MySQL 8.0       No

Vector Search
  HeliosDB Nano   Native HNSW
  MariaDB         No
  MySQL 8.0       Plugin

Encryption (AES-256)
  HeliosDB Nano   Built-in
  MariaDB         Plugin
  MySQL 8.0       Enterprise only

Flexible Deployment Modes

HeliosDB Nano supports four deployment modes to fit every use case. Start embedded in your application, switch to server mode for shared access, or use in-memory mode for blazing-fast testing.

Embedded: Link directly into your application, zero config
Server: Run as a standalone server with TCP connections
In-Memory: Full-speed ephemeral database for testing
Hybrid: In-memory with WAL persistence for crash recovery

Ready-to-use deploy templates for Docker Compose, Railway, Fly.io, and Render — all pre-configured with PostgreSQL + MySQL listeners.

Rust

use heliosdb::{HeliosDB, Config, Mode};

// Embedded mode - zero config
let db = HeliosDB::open("myapp.db")?;

// Server mode - shared access
let db = HeliosDB::builder()
    .mode(Mode::Server)
    .bind("0.0.0.0:5432")
    .max_connections(100)
    .build()?;

// In-memory mode - testing
let db = HeliosDB::builder()
    .mode(Mode::InMemory)
    .build()?;

// Hybrid mode - fast + durable
let db = HeliosDB::builder()
    .mode(Mode::Hybrid)
    .wal_path("./wal")
    .sync_interval_ms(100)
    .build()?;

Ideal For

Who is Nano For?

HeliosDB Nano is designed for developers who need a powerful, embedded database without the operational overhead of a full server deployment.

Desktop Applications

Embed a full-featured database directly in desktop apps with zero installation. Ship a single binary with built-in vector search and branching.

Mobile & IoT

Run on edge devices, IoT sensors, and mobile platforms. The 50 MB binary footprint fits where others can't, with offline-first capability.

AI Prototypes

Build RAG pipelines, semantic search, and AI agent memory with zero infrastructure. Native vector search means no extension juggling.

Single-Server Deployments

Run production workloads on a single server with MVCC, WAL, crash recovery, and enterprise encryption. No cluster overhead required.

WordPress & CMS

Drop-in embedded MySQL replacement for WordPress, Drupal, Joomla, and any PHP CMS. Zero database server, single-file deployment, native MySQL wire protocol.

HeliosDB Nano

HeliosDB Nano

Native Vector Search

Database Branching

Time-Travel Queries

Enterprise Security

PostgreSQL Compatibility

MySQL Wire Protocol

Built-in Backend-as-a-Service

BM25 + Vector Hybrid Search

Native Graph Queries

Code-Graph — Your Source as a Queryable Database

Graph-RAG — Grounded Retrieval in SQL

Native MCP Server — Drop-In for Coding Agents

Defensible Numbers

WordPress Without a Database Server

Zero-Server WordPress

Branching for Staging

Time-Travel Undo

Semantic Content Search

Encryption at Rest

Single-File Backup

One Database, Every Driver

Every Framework, One Database

12x Smaller. Infinitely More Capable.

Flexible Deployment Modes

Who is Nano For?

Desktop Applications

Mobile & IoT

AI Prototypes

Single-Server Deployments

WordPress & CMS

Get Started with Nano