Business rules should not live in folklore, stale PDFs, and three different implementations. DomainForge turns domain meaning into readable, executable structure that can move across languages, runtimes, and governance surfaces.

Every organization has domain truth: the rules, entities, flows, policies, metrics, and relationships that define how the business actually works.

The problem is that this meaning usually gets scattered.

• Analysts describe it in documents.
• Developers reimplement it in services.
• Frontends rebuild parts of it again.
• Architects model it somewhere else.
• Auditors ask where it is enforced.
• Agents receive fragments and improvise.

That is not governance. That is a scavenger hunt.

DomainForge gives teams a semantic source of truth for domain structure: human-readable, machine-executable, versionable, and projectable into the systems that need to use it.

Analysts can read it. Developers can bind to it. Agents can reason over it. Governance systems can inspect it. Architecture tools can project it.

Not documentation hoping to be obeyed. Executable meaning with receipts.

import domainforge

graph = domainforge.Graph()

# Define WHO does the work
warehouse = domainforge.Entity("Warehouse", "logistics")
assembly_line = domainforge.Entity("Assembly Line A", "manufacturing")
graph.add_entity(warehouse)
graph.add_entity(assembly_line)

# Define WHAT moves between them
cameras = domainforge.Resource("Camera", "units")
graph.add_resource(cameras)

# Define HOW much moves
flow = domainforge.Flow(
    cameras.id(),
    assembly_line.id(),
    warehouse.id(),
    1000.0
)
graph.add_flow(flow)

# Validate everything
print(f"Entities: {graph.entity_count()}")
print(f"Flows: {graph.flow_count()}")

That's it. You just created an executable domain model that:

• Defines entities, resources, and flows as a typed graph
• Uses the same Rust-backed core semantics across Python, TypeScript, Rust, and browser/WASM surfaces
• Exports to FINOS CALM for architecture governance
• Becomes a source of truth teams can inspect, test, version, and govern

# Python
pip install domainforge

# TypeScript / Node.js
npm install domainforge

# Rust
cargo add domainforge-core

# Verify it works
python -c "import domainforge; print('✅ Ready:', domainforge.__version__)"

💡 Pre-built packages for PyPI, npm, and Crates.io. Build from source if pre-built wheels/binaries are not yet available for your platform.

DomainForge is stack-agnostic.

It does not require the GodSpeed AI ecosystem. It does not require SEA-Forge, SWE_SEED, GodSpeed-Agent, a specific agent runtime, a specific cloud, or a specific governance platform.

You can use DomainForge as a standalone Apache 2.0 semantic/domain layer in:

• internal tools
• backend services
• frontend validation
• architecture repositories
• agent runtimes
• policy engines
• knowledge graphs
• compliance workflows
• browser/WASM applications
• Python, TypeScript, and Rust systems

DomainForge's value is self-contained: it makes domain meaning readable, executable, portable, and testable.

Within the broader GodSpeed AI stack, DomainForge can also serve as the semantic layer:

DomainForge defines the domain.
SEA-Forge governs the work.
SWE_SEED proves the change.
GodSpeed-Agent compounds the capability.

That stack is optional. DomainForge stands on its own.

DomainForge starts with six core concepts:

That is the starting vocabulary. More advanced declarations — roles, relations, dimensions, units, metrics, mappings, projections, and concept changes — extend the model when the domain needs more structure.

No magic syntax. No framework lock-in. Just executable domain meaning.

Write models directly in .sea files — human-readable, version-controllable, and parseable by all bindings.

// Define entities (who/where)
Entity "Warehouse" in logistics
Entity "Factory" in manufacturing

// Define resources (what moves)
Resource "Camera" units in inventory

// Define flows (how things move)
Flow "Camera" from "Warehouse" to "Factory" quantity 100

// Define validation patterns
Pattern "SKU" matches "^[A-Z]{3}-[0-9]{4}$"

// Define business rules
Policy min_shipment as: quantity >= 10

// Versioned entities with evolution tracking
Entity "Vendor" v2.0.0
  @replaces "Supplier" v1.0.0
  @changes ["renamed", "added_fields"]

// Roles and relations
Role "Approver" in governance

Relation "Payment"
  subject: "Buyer"
  predicate: "pays"
  object: "Seller"
  via: flow "Money"

// Typed instances
Instance acme_corp of "Vendor" {
  name: "Acme Corporation",
  credit_limit: 50000 "USD"
}

// Quantified policy expressions
Policy all_shipments_inspected as:
  forall s in flows: (s.inspected = true)

import domainforge

graph = domainforge.Graph()

# Define the supply chain
supplier = domainforge.Entity("Component Supplier", "supply")
assembly = domainforge.Entity("Assembly Line A", "manufacturing")
quality_control = domainforge.Entity("QC Department", "quality")
finished_goods = domainforge.Entity("Finished Goods Warehouse", "logistics")
graph.add_entity(supplier)
graph.add_entity(assembly)
graph.add_entity(quality_control)
graph.add_entity(finished_goods)

# Define what's being built
pcb_board = domainforge.Resource("PCB Board", "pieces")
camera_module = domainforge.Resource("Camera Module", "units")
graph.add_resource(pcb_board)
graph.add_resource(camera_module)

# Define the flow of components
component_delivery = domainforge.Flow(
    pcb_board.id(),
    supplier.id(),
    assembly.id(),
    500.0
)
graph.add_flow(component_delivery)

import { Graph, Entity, Resource, Flow } from "domainforge";

const graph = new Graph();

const customer = new Entity("Customer Account");
const merchant = new Entity("Merchant Account");
const gateway = new Entity("Payment Gateway");
graph.addEntity(customer);
graph.addEntity(merchant);
graph.addEntity(gateway);

const money = new Resource("USD", "dollars");
graph.addResource(money);

// Track payment flows
const payment = new Flow(money.id, customer.id, merchant.id, 100);
graph.addFlow(payment);

import domainforge

graph = domainforge.Graph()

# Multi-location warehouses
warehouse_us = domainforge.Entity("US Distribution Center", "logistics")
warehouse_us.set_attribute("location", "USA")

warehouse_eu = domainforge.Entity("EU Distribution Center", "logistics")
warehouse_eu.set_attribute("location", "Germany")

retail_store = domainforge.Entity("Retail Store", "logistics")
retail_store.set_attribute("location", "France")

graph.add_entity(warehouse_us)
graph.add_entity(warehouse_eu)
graph.add_entity(retail_store)

product = domainforge.Resource("Widget", "boxes")
graph.add_resource(product)

# Create cross-border flow
shipment = domainforge.Flow(
    product.id(),
    warehouse_eu.id(),
    retail_store.id(),
    250.0
)
graph.add_flow(shipment)

import domainforge

d = domainforge.Dimension.parse("currency")
u = domainforge.Unit("USD", "US Dollar", "Currency", 1.0, "USD")

import { Dimension, Unit } from "domainforge";

const d = Dimension.parse("currency");
const u = new Unit("USD", "US Dollar", "Currency", 1.0, "USD");

import init, { Dimension, Unit } from "./domainforge_core.js";
await init();

const d = new Dimension("currency");
const u = new Unit("USD", "US Dollar", "Currency", 1.0, "USD");

// Programmatic Expression Building & Normalization
const expr = Expression.binary(
  BinaryOp.And,
  Expression.variable("b"),
  Expression.variable("a")
);
console.log(expr.normalize().toStringRepr()); // "(a AND b)"

┌───────────────────────────────────────────────────────┐
│ Your Application                                      │
├───────────────────────────────────────────────────────┤
│ Python API        │ TypeScript        │ WASM           │
│ (PyO3)            │ (napi-rs)         │ (wasm-bindgen) │
├───────────────────────────────────────────────────────┤
│ Rust Core Engine (domainforge-core)                           │
│ ┌─────────────┬──────────────┬─────────────────┐      │
│ │ Primitives  │ Graph Store  │ Policy Engine   │      │
│ │ Parser      │ Validator    │ CALM Export     │      │
│ │ Authority   │ Fact Store   │ Provenance      │      │
│ └─────────────┴──────────────┴─────────────────┘      │
└───────────────────────────────────────────────────────┘

# Install the CLI
cargo install --path domainforge-core --features cli

# Validate a model
domainforge validate model.sea

# Export to FINOS CALM
domainforge project --format calm model.sea architecture.json

# Import from Knowledge Graph
domainforge import --format kg model.ttl

# Normalize Expressions
domainforge normalize "b AND a"  # -> "(a AND b)"

# Evaluate authority decisions
domainforge authority config.json request.json --facts facts.json --json

from domainforge import AuthorityEnvironment

# Create environment from config
env = AuthorityEnvironment(config_json)
env.validate()

# Evaluate an authority request
trace_json, decision_json = env.evaluate(request_json, facts_json)

import { evaluateAuthority } from 'domainforge';

const result = evaluateAuthority(configJson, requestJson, factsJson);
console.log(result.decisionJson);

Error[E001]: Undefined Entity: 'Warehous' at line 1
  --> 1:23
  |
1 | Flow "Materials" from "Warehous" to "Factory"
  |                       ^^^^^^^^^^
  |
  hint: Did you mean 'Warehouse'?

# Clone and set up
git clone https://github.com/GodSpeedAI/DomainForge.git
cd DomainForge
pip install maturin
maturin develop

# Run your first model
python examples/camera_factory.py

# Per-language tests
just rust-test      # Rust core
just python-test    # Python bindings
just ts-test        # TypeScript bindings

# All tests at once
just all-tests

# Python bindings
pip install maturin && maturin build --release

# TypeScript bindings
npm install && npm run build

# WebAssembly
./scripts/build-wasm.sh

We welcome contributions. Please see Contributing Guide for developer notes on building the CLI, TypeScript bindings, and WASM.

DomainForge is open source under the Apache-2.0 License.

Built on foundational work from:

• ERP5 Unified Business Model — Foundational primitive design
• SBVR Standard (OMG) — Semantic business vocabulary
• FINOS CALM — Architecture-as-Code integration
• Rust Community — High-performance core runtime