ModelScript is a Web-native, polyglot compiler & engineering intelligence platform that unifies 90 open standards and industrial simulation formats — spanning systems engineering & optimization (ModelScript, Modelica, AMPL, SysML v2, SSP, ReqIF, NIST OSCAL, OWL 2, CSV), power, RF, telecommunications & electronics (PSCAD, PSS/E, CIM / CGMES, OpenDSS, DIgSILENT PowerFactory, GE PSLF, OCPP, OpenADR, SPICE, Verilog-A, IBIS, Touchstone, Optical Transport, RAN & Microwave, Fiber Outside Plant), fluid/process, subsurface, civil water & nuclear (OLGA, PipelineStudio, Aspen Plus, gPROMS, ECLIPSE, EPANET, SWMM, RELAP5, EnergyPlus, HEC-RAS, TOUGH, MODFLOW, LandGEM), multibody/automotive/robotics/rail & transit (ADAMS, SIMPACK, GENSYS, GT-SUITE, SIMA, URDF, OpenDRIVE, OpenSCENARIO, AUTOSAR, GTFS, PLCopen, AutomationML), aerospace & controls (Simulink, EASY5, JSBSim, ROCETS, CCSDS), 3D CAD/CAE & metrology (STEP, ISO 23952 QIF, OpenSCAD, OpenUSD, CalculiX FEA, SU2 CFD), chemistry & systems/synthetic biology (SBML, Antimony, Cantera, SMILES/SDF, NMTRAN, SBOL3, BioNetGen, SED-ML, PDB/mmCIF, GenBank/FASTA, PHREEQC, Fortran, C99), and radiology, radiation oncology & computer-assisted surgery (OpenSim, DICOM-RT, CellML, FEBio/SOFA, NIfTI/NRRD, TOPAS/GATE, 3MF Medical, OpenIGTLink/PLUS) — into a continuous digital thread for end-to-end design, simulation, formal verification, and compliance auditing.

┌──────────────────────────────────────────────────────────────────────────────────────────┐
│                                 ModelScript Digital Thread                               │
├──────────────────┬─────────────────┬─────────────────┬─────────────────┬─────────────────┤
│ SysML v2 / ReqIF │ Modelica / SSP  │ STEP / QIF / CAD│ Power / Fluids  │ Bio / Medical / │
│  OSCAL / OWL 2   │ Simulink / EASY5│  (OpenSCAD/FEA) │ (PSCAD/OLGA/+)  │ Aero / Robotics │
└────────┬─────────┴────────┬────────┴────────┬────────┴────────┬────────┴────────┬────────┘
         │                  │                 │                 │                 │
         ▼                  ▼                 ▼                 ▼                 ▼
┌──────────────────────────────────────────────────────────────────────────────────────────┐
│                 Native WebAssembly GLR Incremental Parsers & CST Arenas                  │
├──────────────────────────────────────────────────────────────────────────────────────────┤
│                  Polyglot Triple Graph Grammars (TGG) & AOT Rewriting                    │
│           (Bidirectional forward/backward propagation & Critical Pair Analysis)          │
├──────────────────────────────────────────────────────────────────────────────────────────┤
│                      Salsa Query Engine & Workspace Symbol Index                         │
│                    (Incremental memoization, dependency invalidation)                    │
├──────────────────────────────────────────────────────────────────────────────────────────┤
│                       Semantic Theory Coordinator (Nelson-Oppen)                         │
│   Ontology ─── Constraint/Arithmetic ─── Abstract Domains ─── Continuous Safety ─── CAD  │
├──────────────────────────────────────────────────────────────────────────────────────────┤
│                        Data-Oriented DAE Arena & Solvers                                 │
│   DAEBuilder ── BLT ── SUNDIALS CVODE/IDA ── WebGPU Batched ── Direct Collocation Opt    │
└──────────────────────────────────────────────────────────────────────────────────────────┘

ModelScript features a declarative, AOT-compiled Triple Graph Grammar (TGG) and Double-Pushout (DPO) graph rewriting engine (@modelscript/dsl/tgg). Rather than relying on fragile manual point-to-point synchronizers, TGG rules declaratively define correspondences between source, target, and correspondence graphs. The engine compiles these rules into high-performance AssemblyScript dispatch tables in WebAssembly (tgg_forward_dispatch, tgg_backward_dispatch, tgg_propagate_all_stale), verified for confluence and termination via integrated Critical Pair Analysis (CPA).

Cross-domain verification is orchestrated by a generalized Nelson-Oppen Semantic Theory Coordinator (@modelscript/runtime/formal/theory_coordinator), exchanging equality facts, tight numeric intervals, and conflict clauses across 13 domain theory oracles with CDCL(T) case splitting:

• Ontology Domain (OntologyTheoryOracle): Tableau Description Logic (DL) reasoner, OWL2 bundle closure, BFO ISO/IEC 21838-2 upper-level semantic alignment (SemanticProjector), concept subsumption, and scoped disjointness.
• Constraint Domain (ConstraintTheoryOracle): Non-linear interval contraction via HC4 contractor, DPLL(T) arithmetic solver, and variable domain bounding.
• Abstract Domain (AbstractDomainOracle): Octagon Difference Bound Matrices (DBM), 4D spatio-temporal intervals, and relational numerical bounds.
• Continuous Safety & Reliability Domain (ContinuousSafetyOracle / SafetyTheoryOracle): Reachability analysis via zonotopes, constrained zonotopes, star sets, Sum-of-Squares (SOS) barrier certificates, Fault Tree Analysis (FTA), Minimal Cut Sets (MCS), and ISO 26262 / DO-178C safety metrics.
• Dynamic Simulation Domain (DynamicSimulationOracle): DAE numerical trajectory integration, Signal Temporal Logic (STL) quantitative robustness monitoring, and tolerance propagation.
• Spatial Physics Domain (SpatialPhysicsOracle): Watertight B-Rep CAD solid query, collision/clearance checks, geometric mass properties, 3D verification overlays (reachability tubes, SOS barrier shells, clearance vectors), and 3D FEA/CFD field coupling.
• CAE Contract Domain (CaeContractOracle): FEA structural stress/deflection and CFD aerodynamic performance contract verification synchronized with the Digital Thread hypergraph.
• Causalization Domain (CausalizationOracle): Pantelides Index-1 structural non-singularity, algebraic loop solvability, and Nyquist-Shannon sampling stability verification.
• Dimensional Domain (DimensionalOracle): ISO 80000 7-element rational exponent vector ([L, M, T, I, Θ, N, J]) dimensional homogeneity, unit consistency, and cross-domain polyglot drift checking (checkPolyglotPhysicalDrift).
• Entailment Domain (EntailmentOracle): V-Model requirements decomposition completeness proving ($\bigwedge R_{\text{child},i} \models R_{\text{parent}}$) with signed proof manifest generation.
• Flow Algebra Domain (FlowAlgebraOracle): SysML v2 / KerML conjugated port involution (~Port), Kirchhoff conservative flow balancing, and 1D–3D CFD boundary flux coupling.
• Tolerance Stack & UQ Domains (ToleranceStackOracle, UqOracle): STEP AP242 GD&T 1D/3D tolerance chain evaluation (Worst-Case, RSS, Six-Sigma $C_{pk}$) and stochastic Uncertainty Quantification via analytical CDFs and Monte Carlo sampling.
• Radiology & Surgical CAS Domain (RadiologyCasTheoryOracle): QUANTEC organ-at-risk (OAR) radiotherapy DVH/BED/EQD2 dose constraints, Hadrontherapy Bragg peak range verification, $SE(3)$ surgical navigation transform orthogonality, Fitzpatrick Target Registration Error ($\text{TRE}$), and 2-manifold patient-specific cutting guide safety checks.

The simulation runtime employs a zero-allocation Struct-of-Arrays (SoA) layout (DAEBuilder) in linear WebAssembly memory. Equations, variables, and expressions are lowered directly from linear parser CST nodes into integer arena handles, enabling microsecond Pantelides index reduction, Tarjan BLT partition sorting, alias elimination, Implicitly Restarted Arnoldi sparse eigenvalue extraction, and SIMD/WebGPU batched numerical solving without garbage collection overhead.

Inspired by Rust's Salsa, compilation, name resolution, and specialized class instances are fully memoized on a demand-driven dependency graph. When an engineer modifies a single equation or parameter, only transitively affected queries and DAE blocks are re-flattened.

ModelScript provides first-class support for 91 engineering languages and simulation formats under languages/, organized across 8 domain clusters and powered by native WebAssembly parsers, linear-memory CST arenas, static pre-flight linters, and direct DAEBuilder lowering.

Maturity Tiers (enforced in package.json#modelscript.tier via npm run lint:manifests and audited via npm run audit:languages):

• Stable (24 languages) — Production-ready with complete WASM GLR parser, static linter, DAE/solver lowering, and $\ge 8$ test suites verified against standard industry benchmarks or standard library snapshots (e.g., OpenModelica & MSL 4.1.0, OMG KerML standard library, IEEE/WECC power grids, US EPA EPANET/SWMM, Manchester Benchmark / EN 14363, NASA ROCETS / CCSDS).
• Beta (67 languages) — Domain-complete with native WASM parser, static domain linter, DAEBuilder/solver lowering, and $\ge 5$ unit/integration and benchmark test suites.
• Preview (0 languages) — All 91 language packages meet or exceed Beta and Stable 6-pillar verification thresholds.

1. Continuous Multi-Domain Requirements Verification: Automatically evaluate system requirements across disparate engineering domains. For example, verify that an electric vehicle battery pack's thermal dissipation (computed in 1D Modelica), structural stress limits (derived from 3D FEA), and spatial enclosure envelope (enforced by STEP CAD) simultaneously satisfy high-level SysML v2 safety requirements under uncertainty.
2. Bidirectional Architecture ↔ Simulation Co-Evolution (TGG): Keep architecture and physics in permanent sync. Modifications to component hierarchies, ports, or ratings in SysML v2 are translated via forward TGG rewriting directly into Modelica physics models; reciprocally, parameter sizing optimizations discovered during simulation propagate backwards into architectural specifications.
3. Surrogate Reduced Order Modeling (ROM): Extract high-fidelity 3D CFD or FEA simulation snapshots and construct ultra-fast, real-time surrogate models (polynomial chaos, Gaussian processes, neural ODEs). Embed these ROMs directly into real-time Modelica plant loops or web dashboards for sub-millisecond execution.
4. Coordinated Multi-Theory Safety Certification: Use the Nelson-Oppen Semantic Theory Coordinator to prove complex invariants that single solvers cannot resolve—combining symbolic ontology axioms (e.g. subsystem redundancy rules) with non-linear arithmetic constraints and dynamical reachability flowpipes (e.g. collision-free trajectories).
5. Cross-Enterprise Interoperability & Audit Trails: Ingest industry-standard requirements (ReqIF), architectural definitions (SysML v2), and CAD geometry (STEP), trace them via an immutable digital thread hypergraph, and export production-ready verification manifests and compliance artifacts.

ModelScript is managed with Nx and npm workspaces:

ModelScript bridges modern engineering workflows with extensive export and auditing formats:

• FMI 2.0 & 3.0 FMU Export/Import: Export standalone Modelica models as Functional Mock-up Units (Model Exchange and Co-Simulation in C99, WASM, or JS) or import external FMUs into composite systems.
• C99 HIL & CIGRE B4.82 DLL Real-Time Firmware: Compile controllers and plant models to zero-malloc MISRA-C / C99 source and IEEE/CIGRE B4 DLLs for dSPACE, OPAL-RT, RTDS, Speedgoat, PSCAD, and PSS®E.
• SSP 1.0, IDTA AASX & PSI 21 DDP Packaging: Package multi-model simulation architectures into .ssp containers, Industry 4.0 Asset Administration Shells (.aasx), ISO/PAS 81346 Digital Data Packages (.ddp), and DIN SPEC 3105 Open Know-How (okh.json) manifests.
• Standard Interop Gateways: OSLC 3.0 (Open Services for Lifecycle Collaboration) REST endpoints, OMG SysML v2 REST API, and ReqIF 1.2 synchronization.
• Auditing & Compliance Reports:
  • CTRF: Common Test Report Format output for CI/CD test tracking.
  • SARIF: Static Analysis Results Interchange Format for deep linter and static verification diagnostics in GitHub Code Scanning.
  • NERC RSAW, NIST OSCAL & ISO Interconnection Gatekeeper Dossiers: Automated Reliability Standard Audit Worksheets (TPL-001-5, MOD-026/027, PRC-019/024/025), 5-stage ISO interconnection queue readiness certificates, US EPA LCRR/NetDMR reports, and FCC OET-65 / FAA Part 77 siting dossiers.
  • FDA / ISO Design History Files (DHF) & EN 14363 / IEEE 2800 Dossiers: Regulatory compliance dossiers with SHA-256 cryptographic proof manifests.
  • LaTeX & Interactive HTML: High-precision formal verification certificates and self-contained graphical HTML reports with embedded simulation trajectories and SVG diagrams.

• Node.js ≥ 24 (see .nvmrc)
• Git

git clone https://github.com/modelscript/modelscript.git
cd modelscript
npm install

Build all packages in dependency order via Nx:

npm run build

# Build the complete standalone IDE extension into apps/ide/dist/extension/
npm run build:ide:extension

# Package the complete IDE extension into a deployable .vsix bundle (~121 MB)
npm run package:ide:extension

# Or generate a lightweight multi-language syntax extension into dist/extension/
npm run build:extension

# Package the native Tauri v2 Desktop Studio
npm run package:desktop

Start development services concurrently:

npm run dev

This launches the primary development stack:

The IDE includes a browser-local AI assistant powered by WebLLM (Qwen3-0.6B). To enable it, download the model weights (~350 MB, one-time):

npm run download-model --workspace=@modelscript/ide

After building (npm run build), the unified CLI is available as modelscript (alias msx). You can run these commands immediately against the bundled reference workspaces in packages/examples/:

# 1. Verify cross-domain requirements & zonotope reachability on the polyglot drone workspace
npx msx verify packages/examples/drone-reachability/modelica/DroneSimulation.mo \
  --sysml packages/examples/drone-reachability/sysml/drone_specs.sysml

# 2. Flatten & simulate the Modelica flight dynamics (CSV or JSON output)
npx msx compile DroneSimulation packages/examples/drone-reachability/modelica/DroneSimulation.mo
npx msx simulate DroneSimulation packages/examples/drone-reachability/modelica/DroneSimulation.mo \
  --stop-time 10 --solver dopri5 --format json

# 3. Simulate the multi-disciplinary drone chassis trade study
npx msx simulate TradeStudy packages/examples/drone-chassis/TradeStudy.mo --stop-time 5.0

# 4. Lint, simulate, and verify IEEE 2800-2022 grid compliance on the PSCAD 230 kV microgrid
npx msx pscad lint packages/examples/pscad-microgrid/Microgrid_IBR.pscx
npx msx pscad sim packages/examples/pscad-microgrid/Microgrid_IBR.pscx --step=20us --tstop=0.25
npx msx pscad verify-ieee2800 packages/examples/pscad-microgrid/Microgrid_IBR.pscx

# 5. Render a schematic diagram to SVG or project OpenSCAD to ISO 10303-21 STEP
npx msx render DroneSimulation packages/examples/drone-reachability/modelica/DroneSimulation.mo > diagram.svg
npx msx polyglot project packages/examples/drone-reachability/cad/drone.scad --target step --out drone.step

# 6. Export an FMI 3.0 FMU or FDA/ISO Design History File (DHF) compliance dossier
npx msx fmu DroneSimulation packages/examples/drone-reachability/modelica/DroneSimulation.mo \
  --fmi-version 3 --output DroneSimulation.fmu
npx msx dhf export packages/examples/drone-reachability --format markdown -o Drone_DHF.md

# Run tests for git-affected packages
npm test

# Run the complete test suite across all monorepo packages
npm run test:all

# Run OpenModelica testsuite runner
npm run test:modelica -- OpenModelica/flattening/modelica/types
npm run test:single -- OpenModelica/flattening/modelica/types/IntegerToEnumeration.mo

# Run Modelica Standard Library (MSL) verification & benchmark suite
npm run test:msl

# Code quality & manifest integrity checks
npm run lint
npm run lint:manifests
npm run format

Pre-built multi-arch images are published to the GitHub Container Registry on pushes to main.

Run the complete multi-service stack with a single command:

docker compose pull    # Pull latest images from ghcr.io/modelscript/*
docker compose up -d   # Start all services
docker compose down    # Stop containers
docker compose logs -f # Tail logs

To build and run locally from source:

npm run docker:build
npm run docker:up

ModelScript follows an Open-Core and Dual-License model:

• Community Edition (Open Core): All packages under packages/, languages/, and apps/ are licensed under the GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later). See COPYING for the full license text.
• Enterprise Edition (ee/): All files inside ee/ (@modelscript/ee) and the pre-hardened Enterprise Intranet Appliance (ee/deploy/) are proprietary and licensed under the ModelScript Enterprise License (LicenseRef-ModelScript-Enterprise). See ee/LICENSE for terms.
• Commercial OEM Dual-License: Organizations embedding ModelScript compilers, solvers, or UI components into proprietary closed-source products or SaaS platforms without AGPL-3.0 Section 13 copyleft obligations may purchase a Commercial SDK License. Contact [email protected] for details. (Note: Embedding the optional 3D CAD engine @modelscript/cad utilizes Open CASCADE WebAssembly components under LGPL-2.1 Section 6 dynamic linking terms).