Reactive MOLAP · LLVM-compiled · SQL-native

Declarative data models,
designed for the
agentic era.

psimulang is a block-structured language for dimensional data modelling and reporting. Declare dimensions, rules, and interactive reports — the Polytope engine tracks every dependency and keeps every result live. Designed so humans and language models write it with equal fluency.

sales.pml
// Dimensions describe the shape of your data
DIMENSION Region
    FIELD "North America" | FIELD Europe | FIELD "Asia Pacific"
    FIELD "All Regions" = SUM "North America";Europe;"Asia Pacific"
END DIMENSION

ORTHO Sales
    DIMENSIONS Region, Product, Quarter
END ORTHO

// Rules recompute automatically when their inputs change
RULE Margin (Product.*, Measure.Net)
    ON Sales
    Net = Revenue - Cost
END RULE

REACTIVE MOLAP

Dependency-tracked recompute — incremental, ordered, always consistent.

AI-READABLE SYNTAX

Block-structured and explicit, built to be written by humans and LLMs alike.

NATIVE + SQL

LLVM-compiled for interactive speed; emits SQL to push work to your database.

The language

A model you can read.

psimulang gives you a small vocabulary of declarative building blocks. You describe what the data is and how it relates — Polytope works out when and how to compute it.

DIMENSION

A named axis with members and built-in aggregation — “All Regions” sums each region for free.

ORTHO

A multidimensional array spanning several dimensions. Your cube of data.

RULE

A computed field with conditional logic. The engine decides when it must re-run.

MODEL

Binds rules to orthos so an entire surface recalculates as one coherent step.

REACTIVE UPDATES

Automatic dependency tracking and incremental computation — only what changed, in order.

ATOMIC SURFACES

Readers always see a consistent snapshot, never a half-updated result.

The engine

Change one input.
The right things recompute.

Polytope builds a dependency graph from your rules. Edit a cell, swap a source, or load fresh data, and it recomputes exactly what's affected — in dependency order, then publishes the result as a single atomic surface.

  • 01

    Declare dimensions, orthos and rules — no wiring, no manual recompute order.

  • 02

    Depend — the engine derives the graph and tracks every input each rule touches.

  • 03

    Recompute incrementally on change, and reveal a consistent snapshot — never a partial one.

dashboard.pml
// A report is just another view of the model
REPORT Dashboard
    TITLE "Q4 Performance"
    TABLE "Regional Margin"
        SOURCE ORTHO Sales
        COLUMNS Region   HEADINGS <BOLD, COLOR blue>
        ROWS Product     FIELDS <CURRENCY "usd", FIXED 2>
    END TABLE
END REPORT

The same rules feed interactive reports — when the numbers move, the report moves with them.

Why it’s different

Built in Haskell. Compiled by LLVM.

Underneath the declarative surface is a serious engine: a transactional, dependency-tracked reactive core, native code generation through LLVM, and a SQL backend that can hand heavy computation to your database. The block syntax isn't just tidy — it's designed so language models can read, write, and repair models, with semantic hints when something doesn't compile.

~110K lines of Haskell LLVM-compiled Reactive MOLAP core Generates SQL Browser-based IDE CLI · REPL · TUI · Web

Interactive or compiled

JIT through LLVM for a live REPL and browser IDE, or generate a native executable from the same source.

Pushes down to SQL

Load from and compute against your database. Polytope generates SQL so big data never has to leave the warehouse.

Made for agents

Explicit, block-structured syntax that LLMs generate reliably — with compiler feedback that guides them when they don't.

Describe your world once.
Understand it deeply.

If you build analytical models, data products, or simulation environments — or you want a semantic layer that's a genuine product asset rather than a reporting pipeline — psimulang is worth a conversation.