Keep the language.
Rethink the runtime.
A modern execution engine for k4, q and qSQL. Built around the way today’s machines work, from wide instructions to the bytes moving through memory.
Modern hardware.
Familiar expressions.
Array languages already describe work in vectors. l brings the execution model closer to the CPU, the memory hierarchy, and the structure in your data.
SIMD
Vector primitives use wide CPU instructions. Your array expression stays at the level of the problem.
Automatic parallelism
Small arrays stay on a single core. Larger operations can spread across threads as the work justifies it.
Fusion
Compatible operations share a pipeline, reducing temporary allocations and repeated trips through memory.
Compression
Encoding-aware primitives work on compact data where supported, materializing values when needed.
SIMD
More work per instruction.
A vector expression already describes work on many values. l’s primitives can map that work to wide CPU instructions, applying the same operation across multiple lanes.
The runtime selects a suitable path for the operation, physical layout, and available hardware. You keep writing the array expression.
Inside the vectorized engineAutomatic parallelism
Let the workload
set the scale.
Small arrays stay on a single-core path. Larger supported operations can split across worker threads as the work becomes large enough to justify it.
The runtime makes that decision from the size, shape, and cost of the operation. It divides the work and combines partial results where supported. Your expression stays the same.
Parallelism by defaultFusion
Skip the intermediate.
Compatible primitives can share a traversal. Intermediate values flow directly into the next operation, reducing temporary arrays and repeated memory traffic.
In sum sqrt x, the reduction can consume square-rooted values as they arrive. The runtime connects the operations while you express the calculation.
Compute on compressed
Move fewer bytes.
Get the same answer.
Repeated values carry structure. Instead of expanding every value, an encoding-aware reduction can use that structure directly.
Here, sum x becomes a calculation over three value-and-count records. The expression and the result stay the same.
A drop-in replacement
Replace the runtime.
Keep the code.
Designed to run your existing K, q and qSQL workloads. Keep the expressions, queries and application logic you already use, with a modern execution engine underneath.
/ Your existing q and qSQL
t:([]sym:`A`B`A;size:10 20 30) select sum size by sym from t
/ Run it with l
$l analytics.q -p 5001Run your script and expose it to applications over IPC.
Language SDKs
Connect the rest of your stack.
Use l from other languages. Send expressions or queries over IPC and bring typed results back into your application.
Python
Send expressions and queries, and exchange typed values with Python.
Rust
Connect through the native Rust IPC client and work with typed K values.
TypeScript / Bun
Call q functions and run qSQL from TypeScript applications on Bun.
Working with columnar files? Explore Arrow and Parquet interop.
Start with the scripts, queries and datasets you use today. Compare results in your environment, then connect your applications through the SDKs.
Read the reasoning
Go beneath the surface.
The motivation
Why l.
Keep the language. Reimagine the implementation for the machines we use today.
Read moreThe execution model
Compute on compressed.
What changes when primitives can operate on the encoding itself.
Read moreThe hardware
Making every cycle count.
SIMD as a discipline: masks, memory traffic and the cost of moving data.
Read morel> Start with your own workload
Put the runtime
to the test.
The research preview is built for local evaluation, compatibility testing, and reproducible results. Bring a small, representative workload and see how it behaves.
Discuss your evaluationBuilt at L Labs