Typed table pipelines, from REPL to native code

How a program is shaped

Everything is a table flowing through a pipeline

An Ibex program is a handful of let bindings. Each one names a table and the steps applied to it. There are no loops or mutable variables — you describe the transformation you want and Ibex runs it.

// Keep the busy rows, then three columns
prices[
    filter volume > 1000,
    select { symbol, price, volume }
];

// Name a result and reuse it
let active = prices[filter volume > 1000];
active[select { symbol, price }];

R integration

Keep dplyr syntax; execute supported work in Ibex

The ibex package provides a lazy ibex_tbl. Supported verbs build an immutable Ibex plan, show_query() reveals the generated source, and collect() returns a tibble through Arrow C Data.

library(dplyr)
library(ibex)

query <- ibex_tbl(trades, fallback = "error") |>
  filter(price > 10) |>
  mutate(notional = price * size) |>
  group_by(symbol) |>
  summarise(total = sum(notional), .groups = "drop") |>
  arrange(desc(total))

show_query(query)
result <- collect(query)

Reading the syntax

Three kinds of bracket, one job each

Ibex uses square brackets, braces, and parentheses for three distinct things. Knowing which is which is most of what it takes to read any snippet.

Comma-separated lists may end with a trailing comma, so multi-line calls and field lists stay easy to edit: columns(symbol, price,).

A worked example

One pipeline, start to finish

A common task — collapse tick data into daily bars per symbol — shows how the pieces fit together.

let bars = ticks[
    select {
        open  = first(price),
        high  = max(price),
        low   = min(price),
        close = last(price),
        vol   = sum(size)
    },
    by symbol,
    order symbol
];

The vocabulary

The core clauses

These drop inside [ ] and compose in any sensible order. The function reference and cheat sheet have the rest.

Outside the pipelines are a few top-level forms: let bindings, import to load a plugin, fn / extern fn for reusable functions and data sources, and Table { … } to build a table from literals.

Conditional values

First-match case

Use case in any expression position. Conditions are considered in order; the selector form is shorthand for equality checks, and else is required.

let direction = case side {
    "BUY"  => 1,
    "SELL" => -1,
    else   => NULL
};

Install & run

Get Ibex on your machine

A prebuilt release is the quickest start. Build from source if you want the latest commits or a binary for your own platform.

# Unpack the archive for your platform, then:
./ibex --plugin-path ./plugins

# Linux/macOS with Clang or GCC
cmake -B build-release -G Ninja \
  -DCMAKE_C_COMPILER=clang \
  -DCMAKE_CXX_COMPILER=clang++ \
  -DCMAKE_BUILD_TYPE=Release
cmake --build build-release

# Windows, from a Developer PowerShell
cmake -B build-release -DCMAKE_BUILD_TYPE=Release
cmake --build build-release --config Release

./ibex --plugin-path ./plugins   # from source: ./build-release/tools/ibex --plugin-path ./build-release/tools

import "csv";
let prices = read_csv("prices.csv");

// Five most-traded symbols by total volume
prices[
    select { traded = sum(volume) }, by symbol,
    order { traded desc },
    head 5
];

Where to go next

Keep going