vekdb — modern vector language and columnar database

Two halves, one engine

A language and a database, designed together.

vekdb gives you a high-level array language with first-class columnar tables, underpinned by a vectorized engine that spans streaming ingestion, in-memory analytics, and on-disk history — one query language, wherever the data lives. Modern surface syntax borrowed from the languages developers already reach for, over an array core in the lineage that pioneered vector computing.

[ ]

The vek language

An array-first language with modern syntax. Standard precedence, explicit parentheses, arrow lambdas, and method chaining — over a SIMD-accelerated vector engine.

≡

Columnar tables

Tables and dictionaries are values. Query with a SQL-like select, transform with functional primitives, and pass them anywhere a value can go.

∞

Streaming to history

Real-time data lands in memory for sub-millisecond queries, then rolls over to a partitioned on-disk store. Same vek query, whether the data is a microsecond or a decade old.

Inspired by rust python julia javascript haskell sql apl

The language

Familiar surface. Vectorized core.

Scalars broadcast over arrays, dicts, and entire tables. Arrays compose. Functions are values. Everything you write — from a one-line aggregation to a multi-stage pipeline — runs through the same vectorized engine that powers the database.

Left-to-right evaluation with standard operator precedence
Arrow lambdas, method chaining, and functional combinators
Map · fold · scan · filter — sequential and parallel variants
Strong, predictable types with automatic numeric promotion

vector primitives

// vectors broadcast naturally
xs = [1, 2, 3, 4, 5];
xs * 10 + 1          // → [11, 21, 31, 41, 51]

// method chaining over a functional core
xs.filter(x -> x > 2)
  .map(x -> x * x)
  .sum()                // → 50

// running aggregates, in one pass
returns.scan(+)         // cumulative returns
prices.deltas()           // first differences

// arrow lambdas, projections, composition
double = *(2,);
[1, 2, 3].map(double)  // → [2, 4, 6]

veksql

// tables are first-class values
trades = table{
  sym:   [`AAPL, `MSFT, `AAPL, `NVDA],
  price: [192.4, 415.0, 193.1, 882.9],
  size:  [100, 250, 180, 75]
};

// SQL-like select, but composable
select vwap: wsum(size, price) / sum(size),
       n:    count(i)
  by sym from trades
  where price > 100.0;

// asof join — built for time-series
asof([`sym, `time], trades, quotes);

The database

Columnar by default. SQL when you want it.

Build tables dynamically. Query them with a familiar select dialect that composes cleanly with the rest of the language. Group, aggregate, filter. Match across time. Persist to disk.

Cascading where clauses — selective filters first, automatically
Group-by aggregations with sum, avg, wavg, last, and more
Asof joins for time-series matching, with multi-key support
Array attributes (sorted, unique, parted, grouped) for constant-time and log-time lookups

Built to extend

Namespaces, plugins, and native FFI.

Organize code into namespaces. Import .vek files as modules. Call into shared libraries with explicit type signatures, or load native plugins that exchange vek values directly with the runtime.

First-class namespaces with selective imports and aliasing
Native plugin API for high-performance extensions
Typed C FFI — call any C-ABI function with one declaration

modules & ffi

// group definitions into namespaces
namespace stats {
  mean = x -> sum(x) / count(x);
  zscore = x -> {
    m = mean(x); (x - m) / dev(x)
  };
};

stats.zscore([10, 20, 30]);

// import vek files as modules
import "utils.vek" as u;
from "trade.vek" import vwap;

// typed C FFI — one declaration, native speed
import cfn "libm" as m {
  sqrt: (float) -> float,
  pow:  (float, float) -> float
};
m.pow(2.0, 10.0);        // → 1024.0

Why vekdb

Vectorized to the core. Syntax you can read.

A clean-room Rust implementation, drawing on decades of array-language engineering. Surface syntax familiar from Rust, Python, and Julia; an array core distilled into a small set of orthogonal primitives — composing into anything from one-off scripts to multi-terabyte analytical pipelines.

01 Engine

Vectorized to the metal

SIMD-accelerated primitives, columnar layout, and zero-copy memory mapping by default.

02 Agent-first

Token-efficient by design

Clear syntax and predictable semantics let agents generate accurate code with fewer tokens. A built-in MCP server lets them execute it directly.

03 Types

Rich and temporal

Dates, months, minutes, timespans, and nanosecond timestamps — first-class scalars and vectors, with full temporal arithmetic.

04 Query

Composable SQL

A familiar select that returns a value you can keep transforming.

05 Storage

Memory to disk

In-memory tables roll over to mmap-backed partitions. Queries span both, transparently.

06 Joins

Asof, natively

Time-series joins as a primitive, with multi-key support and group attributes.

07 Syntax

Predictable by design

Standard precedence, explicit calls, bracketed arrays. Drop-in pmap for parallel iteration without ceremony.

08 Extend

Plugins & FFI

Native plugin API and typed C FFI for everything the standard library doesn’t.

A vector language for serious data.