AetherScript

ToolsLanguageComputeReactive

Beta Works · surface still evolving · Works · surface still evolving

What it is

AetherScript (ÆS) is a purpose-built language for working with AetheriusDB’s coordinate-indexed data. It treats N-dimensional data as a first-class primitive, lets you address slices by their coordinate keys instead of searching for them, and supports a small set of reactive constructs for logic that fires when source data changes. It compiles to portable compute cells, so the same logic runs unchanged on the server, in a desktop shell, or inside a browser.

Why a new language at all? SQL is great for set-based work but is not expressive for reactive logic or for jumping directly to a coordinate. General-purpose languages can do anything but are not aware of the data fabric. AetherScript sits between the two: it understands the database’s geometry and lets you write the same code at every layer of your stack — so a business rule no longer needs one implementation in Python on the server, another in JavaScript in the browser, and a third in SQL in the database.

Why it matters

• Coordinate addressing — the @ operator jumps directly to the data you want, with no scan.
• Reactive blocks — on_change triggers run physically where the data lives.
• Compile once, run everywhere — one compiled cell deploys to server, desktop, and browser.
• Schema-aware types — the type checker validates every expression against the live catalog schema.

How you use it

The example below declares a measurable cube, addresses a slice by coordinate, and defines a reactive block that fires when sales cross a threshold.

// Illustrative AetherScript.

// Declare a cube with one measure and two dimensions.
CUBE Sales {
  Measure amount;
  Dim region;
  Dim time;
}

// Coordinate addressing: a direct memory jump, no search.
let val = Sales @ [region: 'North', time: 'Q1'];

// A reactive block runs physically wherever the data resides.
on_change(Sales) {
  if Sales.amount > 1_000_000 {
    notify_user("Sales threshold crossed!");
  }
}

// Hardware-hint annotations request specific execution.
@thirst(threads: MAX, target: GPU)
let pivot = Sales.reduce(sum).by([region, product]);

Deployed to the database, a cell acts as a server-side high-pass filter that scans a large dataset and returns a small result. Deployed to a desktop or browser, the same compiled cell runs interactively against the result already in local memory.

Key concepts

Concept	What it does
Cube	A declared multi-dimensional dataset — measures plus dimensions.
@ operator	Coordinate addressing. Resolves to a direct memory jump, not a scan.
on_change	A reactive block. Re-evaluates when its source data is mutated.
@thirst	A hardware hint — request threads or GPU acceleration for a block.
Cell	A compiled module that can be deployed to any layer of the stack.

flowchart LR
  S[ÆS source] --> K[Compiler<br/>type-checks vs catalog]
  K --> W[Compiled cell]
  W --> C[Server-side cell]
  W --> D[Desktop reactive routine]
  W --> B[Browser interactivity]

Tip

Keep cells small and composable. A cell that does one transformation is reusable across pipelines; a giant monolith cell is harder to test and slower to redeploy.

Fully specify coordinates for O(1) jumps

The @ operator requires a fully specified coordinate; partial keys turn into range scans, which are still efficient but no longer a direct jump. When you need both, write the coordinate path explicitly and let the planner handle the range case separately.

Isomorphic Toolchain →

The VS Code editor and compiler for AetherScript.

Compute →

How cells execute inside the engine.

Aether Term (REPL) →

Run AetherScript statements from the command line.

Quickstart →

SQL, vectors, and compute cells in one walkthrough.