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
cloudcell
Own this? Claim it
88
Spark score
out of 100
Updated last month
Source checked Oct 4, 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 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

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

All-time tracked traffic

Daily traffic

Daily repository traffic

Repository history

Stars

Forks

Commits

Referral sources

Top referral sources

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.

OM Core GUI and TUI running together

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.

Target architecture overview

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.