l>

[ 00 ] a new runtime for the k family

l. a new runtime for k and q

l is a new runtime for k4, q, and qSQL code. It is a fast database and array language interpreter most commonly used on Wall Street. l has compressed vectors, SIMD, and automatic parallelism by default and runs existing k4/q/qSQL without modification.

k4 · q · qSQL transparent SIMD transparent compression auto-parallel
l · repl

the q/k/qSQL you already have, just faster

l>sum 1 2 3 4 5 6  21

modern HPC runtime

0.02 ms

SIMD reduction · scalar syntax

[ 01 ] what is l

same language. new engine.

The K and Q languages are array programming languages that offer an elegant syntax for high performance operations. In K/Q arrays are the unit of thought. l keeps those languages unchanged but adds transparent compressed vectors as the unit of execution: primitives run directly compressed structures so the full array is never rebuilt. Modern hardware starves for bandwidth long before it runs short of compute — so moving fewer bytes helps make L fast.

[ 01A ] compatible

k4, q, qSQL. unchanged.

run the syntax, idioms, and K4/q code you already have. l provides full compatibilty for tables, dicts , partitions and splays out of the box.

  • k4 syntax compatibility
  • native q and qSQL support
  • optimized columnar tables
  • zero code rewrites

[ 01B ] compressed

every vector. all the time.

data stays compressed at rest, in memory, and in transit. primitives run directly on the compressed vectors, so less data moves.

  • end-to-end column compression
  • direct execution without decoding
  • optimized cache capacity
  • uniform bytes at every layer

[ 01C ] transparent

SIMD, threads, offload.

the runtime picks the execution path—scalar, SIMD, threaded, or offloaded—with no annotations. you write sum x; l does the rest.

  • NEON vectorization on Apple Silicon
  • AVX-512 support on x86
  • GPU and NPU hardware offloading
  • unified binary for all targets

[ 02A ] in practice

same code, faster.

Fully qSQL compatible database including all joins and partition logic. Same legendary speed.

qSQL over compressed columns
// 86.5M-row analytics table - single CPUl> count AN_pageView86585107jl> select sum isBot, count i, avg isBot by date.month from AN_pageViewmonth   isBot   cnt       botRate
2024.05 29404   1634214   0.01799275
2024.06 49596   1495228   0.03316952
2024.07 194442  2812446   0.06913626

single CPU · no decode pass

86.5M rows

Read the essay

[ 02B ] the same primitives, faster

one line. every core.

L implements automatic SIMD and threading for operations on vectors. L intelligently threads when vector lengths demand it - small vectors are SIMD , large are SIMD+threaded.

same primitive, wider plan
l> avg 1 2 3 4 5 63.5// -> fsum (SIMD reduction) -> / countl> avg 1 2 3 4 ... 999999// worker0: sum x[0..hi0]// worker1: sum x[hi0..hi1]// worker2: sum x[hi1..hi2]// ...// sum = s0 + s1 + s2 + ...// avg = sum / n499999.5l> remoteLinux:hopen `:10.0.0.1:8080connected

SIMD reduction · thread fan-out · remote execution

one expression

Read the essay

[ 03 ] anonymous mail group

a plain-text list for people building with l.

in the spirit of classic technical mailing lists: notes, benchmarks, design questions, release logs. no profiles, no directories.

join with email only

Email is for delivery only. Replies are anonymous.