GEOM-db
One database engine that replaces your entire data stack — relational, graph, vector, time-series, document, geospatial, and more, with cross-modality queries and zero-rewrite migration.
GEOM-db
One database engine that replaces your entire data stack — relational, graph, vector, time-series, document, geospatial, and more, with cross-modality queries and zero-rewrite migration.
One Engine, Not a Stack
Relational, graph, vector, time-series, document, geospatial, columnar, and more — one engine, one query language, one transaction, one audit trail. No ETL between databases.
Zero-Rewrite Migration
Speaks PostgreSQL, MongoDB, Redis, Cypher, SPARQL, Cassandra CQL, Kafka, Elasticsearch, ClickHouse, and 50+ more wire protocols. Your existing tools and apps connect without a rewrite.
Cross-Modality Queries
Join a graph traversal to a vector search to a time-series range query in one SQL statement — with single-phase commit, unified WAL, and cross-modal foreign key enforcement.
Merkle Integrity
Every page carries structural hashes. Corruption is detectable in O(log n) and localizable in O(k log n). Server-grade data integrity on consumer hardware — no ECC required.
Polytemporal
Not bitemporal — N-dimensional temporal. System time, valid time, plus user-defined dimensions like authorization time and settlement time. Every event traced through its full temporal context.
Geometry and Topology Native
Manifolds, simplicial complexes, persistent homology, Betti numbers, Lie groups, fiber bundles — as first-class database objects with DDL, DML, and SQL query operators. No other database does this.
Most organizations run a Frankenstein data stack — PostgreSQL for relational data, Neo4j for graphs, Pinecone for vectors, InfluxDB for time-series, MongoDB for documents, Elasticsearch for search, Redis for cache, and a warehouse on top. Each has its own query language, its own migration path, its own scaling story, and its own bill. When you need to join a graph traversal to a vector search to a time-series range query, you build an ETL pipeline — and hope the data does not go stale between syncs.
GEOM-db is one database engine that handles 20+ data modalities natively: relational, graph, vector, temporal-causal, key-value, time-series, document, geospatial, columnar, wide-column, inverted index, event stream, and more. Cross-modality queries join a graph edge to a relational row to a vector embedding in a single SQL statement — with one transaction, one WAL, one MVCC snapshot, and one audit trail. And it speaks your existing database's wire protocol — PostgreSQL, MongoDB, Redis, Cypher, SPARQL, Cassandra CQL, Kafka — so your existing tools and applications connect without a rewrite.
Core Data Modalities
Every database vendor will tell you their product handles 'multi-model' workloads. What they mean is that you can store JSON in a relational database, or run graph queries with a plugin. GEOM-db means something different. Each modality is a first-class data model with its own storage format, its own query operators, its own index structures, and its own optimization path — but they all share one engine, one WAL, one MVCC snapshot, and one transaction boundary.
Full SQL with ACID transactions, MVCC, and Merkle integrity — not a SQL compatibility layer over a NoSQL engine. Standard B+ tree storage with columnar scans for analytical workloads. Foreign keys, constraints, triggers, stored procedures. PostgreSQL wire protocol compatible — your existing SQL tools, ORMs, and BI dashboards connect without modification.
Why Not Just Use PostgreSQL?
PostgreSQL + pgvector
PostgreSQL with the pgvector extension gives you vector search. But it does not give you HNSW with quantization, cross-modal foreign keys, or graph traversal in the same transaction. GEOM-db does — natively.
PostgreSQL + TimescaleDB
TimescaleDB gives you time-series in PostgreSQL. But it does not give you Kafka wire protocol, cross-modal joins to your graph data, or Merkle integrity on every page. GEOM-db does — natively.
PostgreSQL + PostGIS + Apache AGE
Stack three extensions and you have geospatial, graph, and relational. But each extension has its own indexing, its own query path, and its own failure mode. GEOM-db has one engine, one transaction, one snapshot.
Extended Data Modalities
Beyond the core five — relational, document, graph, vector, and time-series — GEOM-db handles the data models that most teams bolt on as separate systems. Each one is a first-class modality, not a plugin, with its own storage and query path.
Event streaming with Kafka wire protocol compatibility — topics, partitions, offsets, consumer groups, schema registry. Kafka, Pulsar, NATS JetStream, and Google PubSub wire compatible. When a stream event needs to update a relational record and trigger a graph traversal, it happens in one transaction — not across three systems with eventual consistency.
Specialized Data Modalities
For workloads that go beyond the standard data models — wide-column stores, columnar analytics, financial ledgers, and immutable audit trails. Each is a first-class modality with wire protocol compatibility to the tools your team already uses.
Wide-column storage with keyspaces, column families, cell timestamps, TTL, and tombstones. Cassandra CQL, HBase, Bigtable, and DynamoDB wire compatible. Your wide-column data and your relational data share the same transaction boundary — no separate Cassandra cluster.
Zero-Rewrite Migration
The hardest part of switching databases is not the data migration — it is the application rewrite. Every query, every client library, every ORM, every BI tool connection string, every DevOps script is written for your current database. GEOM-db speaks your database's wire protocol, so your existing tools connect without modification. You migrate the data, not the application.
GEOM-db speaks the PostgreSQL wire protocol. Your psql client, your SQLAlchemy ORM, your psycopg2 driver, your pgAdmin, your DBeaver connection — all work without modification. Your SQL queries work. Your stored procedures work (via Python/Julia server-side programmability). Your COPY commands work.
What you gain: Merkle integrity on every page, polytemporal tracking, cross-modality queries to graph and vector data, and HTAP without a separate warehouse. What you keep: every tool, every query, every connection string. The migration is a data export and import — not an application rewrite.
Cross-Modality Queries
The reason you run multiple databases is that no single database handles all your data models. The reason you build ETL pipelines is that the data in one database needs to be joined with data in another. GEOM-db eliminates the ETL pipeline — not by making one data model serve all purposes, but by making cross-modality queries native. A graph traversal, a vector search, a time-series range query, and a relational join execute as one plan, in one transaction, with one commit.
Find customers similar to Customer X who are connected to Company Y in the graph. In a traditional stack, this is a vector search in Pinecone, a graph traversal in Neo4j, and a join in application code — with three network round trips and no transactional guarantee.
In GEOM-db, this is one SQL statement. The vector search and the graph traversal execute as a unified plan — the HNSW index and the graph adjacency list are in the same engine, the same memory space, the same transaction. The result is exact, not eventually consistent.
Composable Database Architecture
Most multi-model databases are one engine with multiple query skins — a document database that also does SQL, or a relational database with a JSON column type. GEOM-db is composable in a fundamentally different way. Each modality is an independent component with its own storage profile, its own WAL class, its own MVCC semantics, its own index structures, and its own optimization path — but they share one engine, one transaction boundary, one WAL stream, and one MVCC snapshot. You compose modalities the way you compose microservices — except the composition is native, transactional, and enforced by the engine, not by application code.
Every modality — relational, graph, vector, time-series, document, geospatial, key-value, columnar, wide-column, event stream, financial, inverted index, blockchain, IoT, multimedia, ontology, RDF, cache — is an independent component. Each declares a ModalityStorageProfile: storage class (page-backed, segment-backed, SSTable-backed, mmap-backed, object-store-backed), WAL class, MVCC class, backup inclusion, encryption domain, spill policy, and exact-owner recheck requirements.
This is not a monolith with plugins. Each modality is a first-class engine citizen with its own DDL, DML, query operators, index types, and cost model entries. The optimizer composes execution plans across modalities — a graph traversal feeds its output into a vector similarity search, which feeds into a time-series range filter, all in one plan, one transaction, one commit. The composition is the architecture.
The Cost of Your Current Stack
Licenses
PostgreSQL is free. Neo4j Enterprise is not. Pinecone is not. Snowflake is not. Each database in your stack has its own pricing model, its own compute charges, and its own data transfer fees. GEOM-db is one license, one engine, one bill.
Operations
Each database needs a backup strategy, a monitoring dashboard, an on-call rotation, and an upgrade cycle. Six databases means six of each. GEOM-db means one of each — because it is one engine.
ETL Pipelines
Every pair of databases needs a data synchronization pipeline. Six databases means fifteen pipelines. Each pipeline has its own failure mode, its own latency, and its own stale data risk. GEOM-db has zero pipelines — because the data is already in one engine.
Migration Risk
GEOM-db speaks your existing database's wire protocol. Your tools, your queries, your ORMs connect without modification. The migration is a data import — not an application rewrite. Start with one modality, add more when ready.
Composable Integration
Composable does not mean you start from scratch. GEOM-db bridges to your existing data, lets you enable modalities incrementally, and federates with external systems — so you adopt at your pace, not in a big-bang migration.
Six bridging layers connect the relational SQL surface to the advanced modality world. B1: bootstrap advanced objects from SQL queries — CREATE SIMPLICIAL_COMPLEX FROM (SELECT ...), CREATE MANIFOLD FROM (SELECT ...), build HDC indexes from existing data. B2: augment tables with advanced column types — add HYPERVECTOR, MANIFOLD_POINT, PERSISTENCE_DIAGRAM columns to existing tables. B3: hybrid DML — INSERT with vector and geometry constructors, UPDATE with HDC operations, MERGE for streaming data.
B4: unified query language — hybrid predicates mixing relational, geometric, and HDC in one WHERE clause. B5: backend implementation — augmented system catalog, hybrid query planner with geometric and HDC access paths, wire protocol extensions. B6: federated materialized views with advanced indexes on foreign data. Migration is incremental: start with B1 on your existing data, add B2 columns when ready, use B4 queries when you need cross-modal joins.
Who Uses GEOM-db
DBA
One engine instead of six. PostgreSQL, MongoDB, Redis, and 60+ more wire protocols mean your existing tools connect without modification. Merkle integrity on every page. Snapshots in milliseconds. No ECC required.
Data Engineer
Cross-modality queries in one SQL statement — join a graph traversal to a vector search to a time-series range query with one transaction and one commit. No ETL pipeline. No eventual consistency. No stale dashboards.
ML Engineer
Vector similarity search with HNSW and quantization. Hyperdimensional computing with analogical reasoning in SQL. Your embeddings and your business data in one engine — no separate vector database to operate.
Platform Owner
One bill, one deployment, one upgrade cycle. Multi-tenant SaaS with per-tenant isolation and billing. Air-gapped for classified environments. Edge-constrained for industrial sites. Same binary, every deployment.
Merkle Integrity
Every database promises durability. Most deliver it with write-ahead logs and checksums. But when a page is corrupted by a hardware fault, a silent bit flip, or a storage controller bug, the checksum may not catch it — especially if the corruption happens in memory before the checksum is computed. GEOM-db uses a Merkle B+ tree as the foundation of its storage — not as a feature, but as the core data structure.
Every page carries a structural hash. Every parent node carries the hash of its children. Corruption is detectable in O(log n) — a single read verifies the entire path from root to leaf. And it works on consumer hardware — no ECC RAM required. The engine detects whether ECC is present and adjusts verification frequency automatically.
Polytemporal
Most databases are not temporal at all — the current state is the only state. Some are bitemporal — tracking when data was valid in the real world and when the database learned about it. GEOM-db is polytemporal — it supports N user-defined temporal dimensions.
For a financial transaction, you might track system time (when the database recorded it), valid time (when the transaction occurred), authorization time (when it was approved), and settlement time (when it cleared). For a supply chain event, you might track system time, valid time, departure time, and arrival time. Every dimension is queryable independently — and the temporal context is stored efficiently with a context-aware pattern that avoids per-row redundancy.
Geometry and Topology
No other database treats geometry and topology as first-class data models. GEOM-db does — manifolds, simplicial complexes, persistent homology, Betti numbers, Lie groups, and fiber bundles are database objects with DDL, DML, and SQL query operators. This is not a GIS extension — it is differential geometry and algebraic topology as native database capabilities.
Create manifolds with CREATE MANIFOLD — Euclidean, Riemannian, hyperbolic, spherical, Minkowski, or custom. Compute geodesic distances, curvature, parallel transport, exponential and logarithmic maps. Query with spatial operators like <-> (geodesic distance) and @> (containment).
3D asset ingestion — glTF, STL, OBJ, FBX, USD, STEP, IGES, PLY, IFC — automatically decomposed into queryable geometry primitives. A CAD model is a manifold with vertices and faces that can be queried, measured, and annotated. No separate CAD file server.
Deployment Freedom
GEOM-db runs wherever your data lives — from a Raspberry Pi to a 10,000-node Kubernetes cluster, from air-gapped classified networks to multi-tenant SaaS. The same binary, the same query language, the same wire protocols — scaled to your deployment.
Run GEOM-db on your own servers, your own Kubernetes cluster, or your own bare metal. Container-native with multi-arch builds (AMD64, ARM64, ARM v7). Helm charts with CRDs for cluster, backup, restore, and tenant management. Hardware detection at startup — CPU features, GPU, NUMA, NVMe, RDMA — with automatic tuning. Your data never leaves your network.
Enterprise Security
GEOM-db treats security as a storage-layer concern, not an application-layer afterthought. Row-level security with geometric predicates, column-level dynamic data masking, leakproof operator classification, and tamper-evident audit trails — all built into the engine.
Row-level security with spatial containment predicates — a user can only see rows within their geographic region. Column-level security with dynamic data masking. JWT, OAuth2, OIDC, API keys, mTLS client certificates. Per-tenant, per-role, per-column access control.
Leakproof operator classification — every predicate, operator, and function is classified as barrier-safe or barrier-unsafe. Non-leakproof functions cannot cross security barriers. Denied and missing targets are indistinguishable — existence is not leaked.
Database Internals
If you are a DBA, you do not care about 'digital transformation' or 'converged data platforms.' You care about transaction isolation, WAL throughput, page split frequency, cache hit ratio, vacuum timing, replication lag, and what happens when a disk fails at 3 AM. Here is what GEOM-db does under the hood.
A tiered storage engine — hot data in a Merkle B+ tree in memory, warm data on disk in an LSM tree, cold data in object storage. Pages adapt to your workload — small for transactional, large for analytical scans. The buffer pool is container-aware and auto-tunes to your available memory, so running in Kubernetes does not mean fighting over RAM.
Every page carries a structural hash — a Merkle tree. Corruption is detected on read, not after a customer notices a wrong number. The engine detects whether your hardware has ECC memory and adjusts verification frequency accordingly — aggressive on consumer hardware, relaxed on server hardware. The overhead is negligible — a fraction of a percent of CPU.
Snapshots are instant — no copy-on-write, no page table manipulation, no fork. Snapshot a terabyte database in milliseconds. Works in containers, on Windows, on bare metal — because the snapshot is a version marker, not a process fork.
Operations and Recovery
A database is not just a storage engine and a query planner. It is also the thing that keeps your data safe when hardware fails, that lets you tune performance without a PhD, that tells you what is slow, and that recovers gracefully at 3 AM. Here is how GEOM-db handles the operational side.
Consensus-based replication means your data is safely stored on multiple nodes before a transaction is committed. No external orchestrators, no split-brain, no manual failover scripts. When a primary node fails, the cluster elects a new one automatically — your application reconnects and keeps running.
Replication modes let you trade latency for durability per workload. Synchronous for financial data where every write must be confirmed by a majority. Asynchronous for analytics where throughput matters more. Rolling upgrades with zero downtime — patch one node at a time while the cluster stays live.
Per-tenant point-in-time recovery means you can restore a single customer's data without taking the database down. Cross-region backup replication means your disaster recovery site is always current. Encryption at rest with your key manager — AWS KMS, HashiCorp Vault, or your own HSM.
Developer Experience
A database is only as good as its developer experience. GEOM-db provides 13 language SDKs, 65+ dialect parsers, a CLI with tab completion, an admin console with visualization, IDE integration, and an import/export registry supporting 80+ formats — from GraphML to Parquet to DICOM to ROS bags.
13 language SDKs: Rust, Python, TypeScript, Java, Go, C#, C++, Ruby, PHP, Elixir, Swift, Kotlin, Scala. Async-first with sync convenience. NumPy and Pandas integration in Python, serde in Rust, Float32Array in TypeScript. Schema-aware code generation. OTel trace propagation. Structured error types per wire protocol.
Every operation is available through SQL, CLI, SDK, REST, and gRPC — with enforced parity across all surfaces. The same operation produces the same result regardless of which interface you use.
20+ Modalities, One Engine
Every data model is a first-class modality — not a plugin, not a compatibility layer. All share one transaction boundary. Relational, document, graph, vector, time-series, event stream, geospatial, 3D, key-value, cache, wide-column, columnar, financial, and blockchain — all native.
Cross-modality queries join a SQL table to a graph traversal to a vector search in one statement. No ETL. No pipeline. No stale data.
Wire Protocol Compatibility
Your existing tools connect without modification. PostgreSQL, MongoDB, Redis, Cypher, SPARQL, CQL, Kafka, Elasticsearch, ClickHouse, and Snowflake — all speak their native wire protocols to GEOM-db.
No driver changes. No query rewrites. Point your existing application at GEOM-db and it just works.
The Cost of Cross-Modality Queries Without GEOM-db
Every pair of databases needs an ETL pipeline. More databases means more pipelines, more stale data, more failure modes. One GEOM-db engine replaces them all.
When your data lives in one engine, cross-modality queries are a single statement. When it lives in six, every join is a pipeline that breaks.
One Database Does Not Mean One Blunt Data Model
Rows, graphs, vectors, events, geometry, time series and documents answer different questions. Forcing them through one fashionable abstraction does not simplify the system; it moves complexity into application code where consistency, history and recovery become harder to prove. GEOM-db keeps each modality native while giving them a shared transaction, identity, policy and evidence contract.
A similarity result can be joined to the exact record that grounds it. A spatial change can be read beside the event stream and asset history that produced it. Teams query the problem they actually have instead of maintaining a small federation of databases and hoping their timestamps agree.
Native Meaning
Each modality keeps the types, operators and indexes required for correct work rather than collapsing into a least-common-denominator document.
Shared Commit
Cross-modal reads and writes operate against declared transaction and snapshot contracts, not application-side timing guesses.
Visible Limits
Unsupported semantics, incomplete compatibility and approximate results fail or disclose their bounds instead of quietly pretending to be exact.
Migration Is Proven Workload by Workload
Accepting a familiar query is easy. Preserving its types, transactions, errors, recovery behaviour, performance envelope and operational tooling is the real migration. GEOM-db treats wire protocols and language compatibility as evidence-bearing contracts, so teams can move bounded workloads without confusing parser coverage for production parity.
That makes modernization reversible and inspectable. Existing applications can keep their drivers while each retired source earns its cutover through replay, conformance, shadow traffic, recovery and workload-specific acceptance.
The Database Must Survive the Real Operating Environment
A database is not ready because it answered a benchmark query. It is ready when committed state survives failure, operators can distinguish listening from healthy, tenants remain isolated, backups restore, upgrades preserve meaning, and disconnected sites rejoin without inventing history.
GEOM-db carries those obligations across data centre, sovereign, edge and air-gapped profiles. Performance matters, but speed without recoverability, compatibility and evidence is merely a faster way to produce an incident.
Search can change without breaking the meaning of the result
A new embedding model can make search better and still make yesterday's vectors incompatible. GEOM-db follows the source record through backfill, index construction, shadow queries and cutover, so the team can see which population is covered and which answers changed before retiring the previous generation.
Progressive vector retrieval, quantized indexes, filtered search, vector joins and reranking become choices with visible model, error and workload evidence. A smaller representation or faster candidate path earns its place through the result it can support.
A graph can carry more than pairs of connected records
An engineering assembly, exposure network or orbital dependency can span ordinary edges, higher-order relationships, geometry, time and compact semantic signatures. GEOM-db lets those structures meet in a native query while each retains the exact evidence needed to interpret it.
A graph can reveal the dependency path. Geometry establishes whether objects intersect. Topology establishes the structural property. HDC can narrow the candidate population. Keeping those contributions honest makes the combined answer useful instead of merely impressive.
The upgrade is finished when the work is reconciled
Stopping a database process is easy. Accounting for in-flight commits, stream positions, index generations, topology checkpoints and interrupted migrations is the actual operational job. GEOM-db drains each participant to a declared durable frontier and recovers unresolved decisions before accepting new work.
Operators can follow that work through Studio, CLI and the administration API. A green listener cannot conceal a database that has not recovered its committed state.
Database administration should explain the consequence before the click
A schema diff is valuable only when the operator can see the affected objects, privileges, data and running work. GEOM-db's Studio brings modeling, object browsing, polytemporal inspection, migration review and diagnostics onto the same contracts used by automated clients.
Connection identity remains explicit: the person who signed in, the database principal they may act as and the tenant they may access can be inspected and revoked separately. Familiar enterprise login does not quietly become unrestricted database access.
Follow one asset through its different data representations
The same asset can appear as an exact record, a similarity candidate, a graph relationship and an observation at a particular time. GEOM-db brings those contributions into one answer while retaining what each representation actually establishes.
Use-Case Surfaces
- Replace Your Data StackOne engine replaces PostgreSQL, Neo4j, Pinecone, InfluxDB, MongoDB, Elasticsearch, Redis, and your warehouse — with cross-modality queries and zero ETL.
- Zero-Rewrite Database MigrationMigrate from PostgreSQL, MongoDB, Redis, Cassandra, ClickHouse, or 60+ other databases without rewriting your applications — wire protocol compatibility.
- Cross-Modality AnalyticsJoin graph traversals, vector searches, time-series range queries, and relational data in one SQL statement — with one transaction and one commit.
- 3D and Engineering DataStore CAD models, BOMs, quality records, and sensor data in one engine — with native 3D geometry, graph relationships, and time-series telemetry.
- Financial and AuditDouble-entry ledger, polytemporal audit trails, Merkle integrity, and immutable append-only ledger — for financial services and regulatory compliance.
- Multi-Tenant SaaSBuild a database SaaS with per-tenant isolation, resource quotas, usage metering, billing hooks, and point-in-time recovery — without building the database.
Stop Building ETL. Start Querying.
The data infrastructure industry sells you pieces. A relational database for your business data. A graph database for your relationships. A vector database for your embeddings. A time-series database for your metrics. A search engine for your text. A cache for your hot data. A warehouse for your analytics. Each has its own query language, its own scaling story, its own failure mode, and its own bill. And between each pair, you build an ETL pipeline — a fragile, eventually consistent data synchronization job that breaks when the schema changes and goes stale when the pipeline lags.
GEOM-db takes a different position. The data was never separate — your tools made it separate. A customer record, the graph of their relationships, the vector of their preferences, and the time-series of their interactions are all data about the same entity. They belong in the same engine, the same transaction, the same query. When you join a graph traversal to a vector search to a time-series range query, the result is exact — not eventually consistent, not stale, not a dashboard refresh away from reality.
That is what GEOM-db is. Not another database to add to your stack. A replacement for the stack itself.
Proof points
- 20+ modalities in one engine with cross-modality queries, single WAL, and unified MVCC.
- 65+ wire protocol emulations — PostgreSQL, MongoDB, Redis, Cypher, SPARQL, Kafka, and 50+ more.
- Merkle integrity on every page — corruption detectable in O(log n), no ECC required.
Objections answered
- GEOM-db is not a PostgreSQL plugin or a Redis wrapper — it is a ground-up multi-modal engine.
- GEOM-db does not require GPU acceleration — Tier 0 CPU is the complete product.
- GEOM-db is not SaaS-only — self-hosted, air-gapped, and edge are first-class deployment modes.
Operator relevance: A platform owner can replace database sprawl with one engine while keeping every existing tool, client, and query — the migration is data, not application rewrite.
Core Commitments
- RuntimeRust engine, Zig I/O, CUDA/HIP GPU acceleration
- Modalities20+ (relational, graph, vector, temporal-causal, KV, time-series, document, GIS, columnar, wide-column, inverted index, event stream, financial, blockchain, multimedia, IoT, ontology, RDF, cache)
- Wire ProtocolsPostgreSQL, MySQL, MongoDB, Redis RESP3, Cypher/Bolt, SPARQL, Cassandra CQL, Kafka, Elasticsearch, ClickHouse, Snowflake, BigQuery, and 50+ more
- Dialect Parsers65+ — MySQL, PostgreSQL, Oracle, SQL Server, MongoDB, Cypher, SPARQL, Gremlin, CQL, InfluxQL, Pinecone, ClickHouse, Snowflake, Databricks
- Storage EngineMerkle B+ tree (hot), LSM-tree (warm), S3 (cold) — adaptive page sizes 4KB-2MB
- Transaction IsolationSnapshot isolation (default), serializable via predicate lock tracking, full ACID with MVCC
- WALProtobuf-encoded, AES-256-GCM FIPS mode, group commit, 50K+ TPS per node, deterministic recovery
- Index TypesB+ tree, HNSW (vector), R-tree (GIS), k-d tree, CSR (graph), inverted (Tantivy), LSM, radix, bloom filter, zone maps
- ReplicationRaft consensus — SYNC/ASYNC/STRICT_SYNC per modality, automatic failover, no external Patroni
- Cross-ModalityJoin graph + relational + vector + time-series in one SQL statement with single-phase commit
- Merkle IntegrityEvery page carries CRC32C hash — corruption in O(log n), 0.1% overhead, no ECC required
- PolytemporalN-dimensional temporal — system, valid, plus user-defined dimensions with context-aware storage
- HTAPLock-free transactional paths and SIMD/JIT analytical paths over shared MVCC snapshots
- Vacuum and MaintenanceCross-modality VACUUM, CLUSTER for geometric locality, ANALYZE for all object types, autovacuum per modality
- Configuration~200 parameters, 3 deployment profiles (basic/integrity/full), SETUP INTERACTIVE with hardware detection
- ObservabilityPrometheus, OpenTelemetry, eBPF, geom_stat_* views, slow query log, auto-explain
- Crash RecoveryWAL replay, SIGBUS handler, TMR with Merkle auto-repair, per-tenant PITR, dry run mode
- GeometryManifolds, geodesics, curvature, Lie groups, fiber bundles as first-class database objects
- TopologySimplicial complexes, persistent homology, Betti numbers, Wasserstein distance in SQL
- HDCHyperdimensional computing — bind, bundle, permute, similarity, analogical reasoning in SQL
- SDKs13 languages (Rust, Python, TypeScript, Java, Go, C#, C++, Ruby, PHP, Elixir, Swift, Kotlin, Scala)
- Import/Export80+ formats including Parquet, Iceberg, Arrow, DICOM, HDF5, LIDAR, ROS bags, FHIR, GraphML
- Performance50K+ TPS per node, 12 PB/s logical throughput target, 32x-96x vector compression
- DeploymentSingle-node, clustered, multi-tenant SaaS, air-gapped FIPS, edge embedded — same binary
Storage and Transactions
- Storage EngineMerkle B+ tree, LSM-tree, S3 — adaptive page sizes, forkless O(1) snapshots
- Transaction IsolationSnapshot isolation default, serializable available, full ACID with MVCC
- WALProtobuf, AES-256-GCM FIPS, 50K+ TPS, deterministic crash recovery
- ReplicationRaft consensus, SYNC/ASYNC/STRICT_SYNC, automatic failover, per-tenant PITR
Query and Indexing
- OptimizerCost-based with calibrated costs for every modality, predicate pushdown, column pruning
- ExecutorMorsel-driven parallelism, LLVM JIT, SIMD/AVX-512, GPU dispatch via cost crossover
- Index TypesB+ tree, HNSW, R-tree, k-d, CSR, inverted, LSM, radix, bloom, zone maps
- EXPLAINFull plan with geometric, topological, and HDC access paths, Merkle nodes, CRDT state
Maintenance and Observability
- VACUUMCross-modality version chain cleanup, autovacuum per modality
- Configuration~200 parameters, 3 profiles, SETUP INTERACTIVE with hardware auto-detection
- MonitoringPrometheus, OpenTelemetry, eBPF, geom_stat_* views, slow query log, auto-explain
- Crash RecoverySIGBUS handler, TMR with Merkle auto-repair, dry run mode