Skip to content

More room for the next hypothesis.

Build signals, compare backtests and investigate execution with the same q/k array language. l puts column operations, numerical work and compression-aware execution underneath the research loop, so the next question stays close to the data.

01 / The workload

From a question to the next experiment.

  • Market observations
  • Research features
  • Positions & exposures

The research loop is the workload.

A useful hypothesis rarely arrives in one query. It takes repeated passes over instruments, dates, features and strategy outputs. When every pass expands columns or builds another intermediate dataset, the cost of iteration becomes part of the research decision.

Signal and feature research

Transform price, volume and derived columns into candidate signals. Group observations by instrument or research period and examine how relationships change across the universe.

  • Compare feature distributions across regimes
  • Inspect correlations and outlying observations

Backtesting and parameter studies

Build the array calculations behind a strategy simulation. Compare your strategy outputs across parameter choices, holding periods and transaction-cost assumptions.

  • Compare variants on the same observations
  • Trace a result back to its input rows

Execution and transaction costs

Analyze prepared trade-and-benchmark datasets to understand the gap between a research price and an achieved execution. Break results down by venue, size or market condition.

  • Study slippage and fill distributions
  • Compare costs across liquidity conditions

Portfolio and scenario analytics

Aggregate positions, calculate exposures and compare supplied scenario outputs. Move between a portfolio summary and the instruments contributing to it.

  • Attribute results by strategy or instrument
  • Inspect concentration and scenario sensitivity

02 / From data to analysis

A research panel you can keep questioning.

A typical signal investigation moves from a defined universe to a feature panel, then to comparisons that remain traceable to the observations.

  1. 01Source data

    Select the research universe

    Start with normalized observations and the identifiers, time ranges and reference fields your strategy requires.

    • Prices & volumes
    • Instrument identifiers
    • Research periods
  2. l>Compute with l

    Express the transformations

    Use qSQL filters and groups alongside vector arithmetic, correlations and reductions to construct a feature panel.

    • Filter & group
    • Transform columns
    • Calculate statistics
  3. 03Analytical result

    Compare the hypotheses

    Analyze the panel and your backtest outputs by instrument and period, then return a focused result to your research tools.

    • Feature panels
    • Variant comparisons
    • Attribution tables
Filter a research panel
/ Filter a research panel

l>r:([]sym:`A`B`A`B;signal:1 3 -1 5)

l>select avg signal by sym from r
sym| signal
---|-------
A  | 0
B  | 4

l>select from r where signal>0
sym signal
----------
A   1
B   3
B   5

l>exec sum signal from r
8j

l>

03 / Why l

The expression stays simple.
The layout does the work.

You write q/k. The runtime considers the physical representation of the data, choosing encoding-aware operations where supported and materializing values when needed.

Column work stays in the runtime
Filtering, grouping and reductions operate on vectors. Encoding-aware paths can use a compact representation where the data and primitive support it.
Keep the research tools around it
Use the Python IPC client for application integration and the Parquet library for flat research datasets. The analytical expressions remain in q/k.
Read the research

04 / Your first evaluation

Start with a result
you can verify.

Choose a representative research period, a small instrument universe and one feature or backtest calculation you already trust.

Available as a research preview for local evaluation.

Questions to answer with your sample

  1. Does the result match your reference, including nulls and numeric types?
  2. How do elapsed time and memory change as the universe grows?
  3. Which step dominates: loading, transformation or returning the result?

Your data. Your next question.

What would you test with more room to iterate?

Let’s talk