DEAL

A text-first language for systems engineering

Manage your system models as plain text — readable, diffable, and fast.

DEAL is a text-first authoring surface for model-based systems engineering. Write requirements, architecture, interfaces, calculations, and verification as code that lives in Git — with a 100% mapping to KerML and the SysML v2 API.

Get started →View on GitHub ↗

DEAL isn’t a replacement for SysML v2 — it’s the authoring surface for it. It replaces the textual notation with a syntax built for humans, and maps cleanly back to the standard.

text-first · diffs in Gitlightweight · extremely fast100% mapping · KerML / SysML v2 APIinline compute · + external sims

The problem

Digital engineering promises a single source of truth. Today’s tools fight you for it.

Sync is fragile

Requirements in DOORS, architecture in Cameo, interfaces in spreadsheets, verification in test tools. Keeping a model synchronized across all of them is manual, error-prone, and perpetually out of date.

Versioning is an afterthought

Binary model files don’t diff, don’t merge, and don’t fit the version-control workflows software solved decades ago. Branching a system model shouldn’t need a database administrator.

GUIs don’t scale

Clicking through a graphical tool to update every attribute, connection, and trace link is tedious and hostile to automation. What takes a line of text takes a dozen clicks.

See it work

Author compute in the model. Validate the whole thing from the command line.

Bind a part to a simulation, declare its verification criteria, then let the toolchain parse, dimensionally type-check, run the sims, and evaluate the thresholds — in one command.

part def TractionMotor <<specializes>> ThermallyManaged {
    @confidence: 0.90
    @simulation:<<computes>> thermalDerating {
        equation: "Power limit = f(winding_temp, magnet_temp)";
        tool:     "python";
        entry:    "simulations/thermal/motor_thermal.py";
        fidelity: "analytical";
    }
}

/** Verify peak power survives thermal derating. */
requirement def REQ_MOT_001 {
    verification {
        accepts:   [simulation, test];
        threshold: peakPower;
        operator:  ">=";
    }
}

$ deal check --verify --run-sims

deal 0.1 · checking project 'ev-platform'
▸ parse        37 files            ok
▸ resolve      218 symbols          ok
▸ units        dimensional algebra ok
▸ simulate     2 stale bindings
  python  thermal/motor_thermal.py    ✓ 0.8s
  matlab  dynamics/motor_efficiency.m ✓ 3.1s

▸ verify       evaluating 14 criteria
  PASS  REQ_MOT_001  peakPower 142 kW >= 140 kW
  PASS  REQ_SYS_001  range 486 km     >= 483 km
  FAIL  REQ_BAT_004  packTemp 63 °C   > 60 °C limit

✗ 1 requirement failed · 13 passed · 2 sims re-run
exit code 1 — wired straight into CI.

Dimensional checking, simulation bindings, and verification thresholds are all part of the language — not bolted-on tooling.

What DEAL gives you

A lightweight, extremely capable support structure for the language.

Text-first & Git-native

Plain .deal / .dealx files that diff, merge, branch, and review in a pull request. Grep it, script it, CI/CD it.

Inline calculations

First-class calc and constraint definitions — dimensionally checked, with engineer-facing precision contracts (sig 4, ± 1%).

Native sim + external hooks

A built-in compute engine, plus a registry that farms heavy or legacy physics out to Python, MATLAB, and STK.

Requirements & verification

Needs, requirements, use cases, satisfaction and verification — as first-class constructs with explicit traceability.

Standards interop

100% mapping to KerML and the SysML v2 API. Exports SysML v2 JSON and ReqIF (DOORS) via deal build.

Real editor support

Fast LSP, VS Code extension, and tree-sitter grammar for Neovim, Helix, Zed, and GitHub highlighting.

Read the language

Real snippets from the EV platform showcase.

requirement def REQ_SYS_001 {
    public (
        attribute text     : String [1] = "The vehicle shall achieve a minimum
                            range of 300 miles on a single full charge.";
        attribute minRange : Length [1] = km(483);
    )
    verification {
        accepts:   [simulation, test];
        rejects:   [analysis, inspection];
        threshold: minRange;
        operator:  ">=";
    }
}

Requirements carry typed, unit-bearing attributes and a machine-checkable verification contract.

/** Pure function — composable inside any expression. */
calc def MarginOfSafety(allowable : Pressure, actual : Pressure) : Real {
    return allowable / actual - 1;
}

/** Return contract: precision + a named predicate (list form). */
calc def Drag(rho : Density, v : Speed, area : Area, cd : Real) : Force
        => ± percent(1), PositiveForce {
    derived attribute q : Pressure = 0.5 * rho * v * v;
    return q * area * cd;
}

Dimensionally-checked compute in the model itself — compiled, fast, and governed by a precision contract.

/** Parameterized predicate — reusable, callable from any boolean context. */
constraint def PositiveForce(f : Force) {
    require f >= N(0);
}

/** Multiple require lines are an implicit conjunction (all must hold). */
constraint def ThermalWindow(t : Temperature) {
    require t >= degC(-40);
    require t <= degC(85);
}

Named predicates mirror KerML Functions and Predicates — reusable invariants with full dimensional safety.

# Maps @simulation annotations to executable code.
[simulations.battery_thermal]
tool     = "python"
entry    = "thermal/battery_thermal.py"
binds_to = "packages/vehicle/battery.deal::BatteryPack"
inputs   = [
  { model_path = "EnergyStorage.battery.packResistance", unit = "ohm" },
  { model_path = "Thermal.coolantSupply.flowRate",       unit = "L/min" },
]
outputs  = [
  { param = "coolantOutTemp", model_path = "...coolantOut.coolantTemp", unit = "degC" },
]

A typed, unit-aware contract between the model and external tools — bindings are validated before anything runs.

Two complementary paths to compute

Light and fast in-language. Heavy and external when you need it.

In-language compute native

Dimensionally-checked expressions and calc/constraint definitions, compiled for speed and governed by an engineer-facing precision contract.

Parametric and analysis logic lives in the single source of truth
Unit algebra catches dimensional errors at check time
Precision vocabulary: significant figures, relative tolerance

External simulations farm-out

A registry maps @simulation annotations to executable code — heavy, black-box, or legacy physics — over a typed JSON protocol.

PythonMATLABSTK+ JSON protocol

deal simulate runs one, all, or only stale bindings
Inputs/outputs bound to model paths with units
Results flow back into verification criteria

Standards & interoperability

A clean mapping back to the standards your program already runs on.

DEAL targets the same semantic domain as OMG SysML v2 / KerML. Your text is the source; the standard formats are build outputs — so DEAL slots into existing tools instead of replacing them.

.deal / .dealxyour source, in Git

→

deal buildcompiler toolchain

→

SysML v2 JSONKerML / SysML v2 API

ReqIF XMLDOORS & downstream

For the people who verify before they trust

Specifications, security, and references.

Specification ↗Formal EBNF grammar, locked design decisions, and the validated showcase model.Security ↗Disclosure policy and supply-chain posture for sensitive engineering workflows.Standards & references ↗The OMG SysML v2 and KerML normative grammars DEAL maps to.Documentation →Install, first project, language reference, CLI, and editor setup.

Get started

Author your first system model in minutes.

Install

Build from source with cargo build —release (Zig 0.16 + Rust).

Create

deal init my-system scaffolds a project with a manifest and packages.

Build

deal build —target sysml-v2 compiles to the standard. deal check validates.

Read the docs →Star on GitHub ↗