Spark
Sign In
Tool

Build multidimensional financial models without spreadsheets

Alpha-stage multidimensional modeling engine representing financial models as dimensions, cubes, and rules, not spreadsheet cells.

Get from source
Works with pythongithub
github
Own this? Claim it
91
Spark score
out of 100
Updated 10 days ago
Source checked Sep 10, 2026
Version 0.1.1-alpha.1
Add to Favorites

Why it matters

Replace fragile spreadsheet-based financial and operational models with a structured modeling engine that separates business logic from layout, making large models easier to audit, extend, test, and maintain as they grow.

Outcomes

What it gets done

01

Define dimensions, cubes, groups, and hierarchies to structure financial data semantically instead of by cell location

02

Write calculation rules that express business relationships independent of spreadsheet coordinates or copied formulas

03

Project model data into multiple views and grids without duplicating underlying logic or structure

04

Run models through GUI, TUI, REPL, or headless runtime with a unified command interface and message bus architecture

Source

Get it from source

Spark does not host a copy of it.

Open source

Reports

Agent outcome reports

No reports yet

Overview

Om Core

OM Core is an alpha-stage, open-source multidimensional modeling engine that represents financial and operational models as dimensions, cubes, and rules rather than spreadsheet cells, with grids as projections of the model. Use it to build a rules-based financial model where business logic lives in semantic relationships instead of spreadsheet formulas; it is alpha software, so APIs and file formats may still change.

What it does

OM Core is an open-source, alpha-stage reference implementation of a multidimensional modeling engine for structured financial, operational, and analytical models. Instead of treating a spreadsheet grid as the model itself, it represents the model as dimensions, cubes, groups, and rules, with grids and views acting only as projections of that underlying model.

When to use - and when NOT to

Use it when you want to build a financial or operational model where business relationships, like gross margin derived from revenue and cost, are expressed as rules over semantic model addresses, not spreadsheet cell coordinates or copied formulas - separating model structure, business logic, and presentation instead of mixing them the way spreadsheets do. It is explicitly alpha software: APIs, command names, file formats, GUI behavior, and module boundaries may change before a 1.0 release, so it is not yet suited for production-critical modeling work.

Inputs and outputs

The model is built from dimensions (business axes like Time, Account, Region, Product, Scenario, or Line Item), cubes (data stored over one or more dimensions), groups and hierarchies (structured collections and rollups), and rules (calculations expressed over those semantic addresses). A minimal script defines dimensions and cubes in a small, readable text syntax; the built-in help command (om> help, om> help rule, om> help calc) documents commands and topics interactively at the shell. Views, grids and interfaces, are used to inspect and interact with the model without becoming the source of truth themselves.

Integrations

OM Core currently runs from source and manages its own Python environment with uv; the repository bundles the modeling engine plus its command, REPL, GUI/TUI, runtime, timeline, scripting, plugin, and storage-adapter layers as one alpha application stack. It can be started in GUI, TUI, headless-runtime, or REPL-only modes via start.sh/start.ps1 flags, and the first run automatically creates a .venv and installs dependencies from uv.lock. The repository's .om/ directory is intentionally committed rather than treated as a cache: it holds default application configuration, including toolbar settings the current alpha build depends on, and should not be deleted unless the configuration system has been changed to load those defaults from elsewhere.

Who it's for

Financial and operational analysts and modelers who want a rules-based, spreadsheet-alternative modeling engine where business logic lives in semantic relationships rather than cell references, and are comfortable running alpha-stage software directly from a source checkout on Linux, macOS, or Windows.

Source README
📈 All-time tracked views
358		 📥 All-time tracked clones
951		 ⭐ Current stars
17		 🍴 Current forks
5
🧬 All-time commits
68		 ⬇️ Tracked release downloads
0		 👀 Watchers
1		 🩺 Traffic history
complete
Repository created: 2026-06-29 · Traffic retained from: 2026-07-29 · Updated: 2026-09-10T04:51:39Z

Traffic retention: GitHub itself exposes only its most recent 14 days of repository views/clones. This repository permanently retains every daily bucket collected from 2026-07-29 onward, so these cumulative traffic totals keep growing and never roll off.

All-time tracked traffic

Daily traffic

Repository history

Referral sources

GitHub exposes only the top 10 referral sources for its rolling 14-day window. Every returned source/window is permanently archived. Overlapping windows are not summed because that would double-count visits. Data: stats/daily.csv · Sources now: stats/referrers-latest.csv · All sources ever observed: stats/referrers-ever.csv · Source-window archive: stats/referrers-windows.csv · Release-asset ledger: stats/release-assets.json · Raw polls: stats/polls.jsonl

OM Core

OM Core is an open-source reference implementation of a multidimensional
modeling engine for structured financial, operational, and analytical models.

Instead of treating the spreadsheet grid as the model, OM Core represents the
model using dimensions, cubes, groups, and rules. Grids and views are
projections of that model, not the source of truth.

Alpha software: OM Core is under active development. APIs, command names, file
formats, GUI behavior, and module boundaries may change before v1.0.

OM Core overview video

Documentation

The main documentation site is here:

https://cloudcell.github.io/om-docs/

Start with:

Core idea

Most spreadsheet models mix several things together:

  • model structure
  • business logic
  • layout
  • presentation
  • calculation flow
  • user interaction

OM Core separates these concerns.

The model is built from:

  • Dimensions - business axes such as Time, Account, Region, Product,
    Scenario, or Line Item.
  • Cubes - data stored over one or more dimensions.
  • Groups and hierarchies - structured collections and rollups.
  • Rules - calculations expressed over semantic model addresses instead of
    spreadsheet coordinates.
  • Views - grids and interfaces for inspecting and interacting with the
    model.

A rule should describe the business relationship, not the cell location. For
example, a model should be able to express a relationship such as gross margin
being derived from revenue and cost without making that relationship depend on a
particular row, column, or copied formula.

Repository scope

This repository currently contains the full alpha application stack required to
run OM Core.

That includes the modeling engine and supporting command, REPL, GUI/TUI,
runtime, timeline, scripting, plugin, storage-adapter, examples, and test
layers.

Some modules are internal implementation layers. They are included because the
current alpha application depends on them. They should not yet be treated as
stable public extension APIs.

Repository configuration

The .om/ directory is intentionally committed.

It contains default OM Core application configuration, including toolbar
settings required by the current alpha application. It is not a temporary cache
directory or private local state.

Do not delete .om/ unless the application configuration system has been
changed to load these defaults from another documented location.

Installation

OM Core currently runs from source.

Linux / macOS

git clone https://github.com/cloudcell/om-core.git
cd om-core
./start.sh

Windows

Use PowerShell:

git clone https://github.com/cloudcell/om-core.git
cd om-core
.\start.ps1

./start.sh or .\start.ps1 starts the GUI and asks whether to open a TUI in a
separate terminal.

OM Core uses uv to manage its Python environment.
Install uv, then run uv sync in the project root to create .venv and install
dependencies. After that, the start scripts and test scripts use uv run
automatically.

You can also start specific runtime modes:

# Linux / macOS
./start.sh --gui       # graphical interface only
./start.sh --tui       # terminal interface in the current terminal
./start.sh --runtime   # headless runtime only
./start.sh --repl      # REPL command shell in the current terminal

# Windows
.\start.ps1 --gui       # graphical interface only
.\start.ps1 --tui       # terminal interface in the current terminal
.\start.ps1 --runtime   # headless runtime only
.\start.ps1 --repl      # REPL command shell in the current terminal

For more detail, see the installation guide:

https://cloudcell.github.io/om-docs/start/installation/

Quickstart

Running ./start.sh (Linux / macOS) or .\start.ps1 (Windows) launches the GUI.
You will be prompted to open a TUI in a separate terminal; accepting the default
(Y) gives you a command shell alongside the GUI, as shown below.

Note: The first time you run ./start.sh or .\start.ps1, uv will create
a Python virtual environment in the project folder (.venv) and install
dependencies from uv.lock.

After starting OM Core, try the built-in help command:

om> help

You can ask for help on specific topics:

om> help rule
om> help calc

A minimal OM Core script looks like this:

# Dimensions
dim Month Jan Feb Mar

# Cube
cube Sales Month

# View
view SalesView = Sales::Month

# Rules
rule Sales::Month.Jan = 100
rule Sales::Month.Feb = Sales::Month.Jan * 1.1
rule Sales::Month.Mar = Sales::Month.Feb * 1.1

# Calculate
calc

Save that as hello.openm, then source it from the REPL or TUI:

om> source hello.openm

For the full walkthrough, see:

https://cloudcell.github.io/om-docs/start/quickstart/

Testing

Run the test suite with the platform-specific script:

# Linux / macOS
./test.sh

# Windows
.\test.ps1

Architecture

OM Core is split into a session-scoped runtime layer, a command/query service
layer, and multiple clients. The engine owns the canonical workspace state; the
GUI, TUI, REPL, and CLI are clients that communicate through the message bus.

Why not just spreadsheets?

Spreadsheets are fast and flexible, but large models often become fragile
because business logic is encoded in cell addresses, copied formulas, linked
tabs, and implicit layout conventions.

OM Core uses a different level of abstraction. It makes the model explicit:
dimensions describe the axes, cubes hold values, groups organize structure,
rules define calculations, and views display the result.

The tradeoff is deliberate: you define more structure up front, and in return
the model becomes easier to audit, extend, test, and maintain as it grows.

For the longer explanation, see:

https://cloudcell.github.io/om-docs/start/why-not-spreadsheets/

Project status

OM Core is currently alpha software.

Not yet promised before v1.0:

  • stable public API
  • stable plugin API
  • stable scripting API
  • stable file format
  • packaged desktop installer
  • production readiness for critical business use without independent validation

See also:

  • KNOWN_ISSUES.md
  • CHANGELOG.md
  • SECURITY.md

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.