Under the hood

All of the engineering, before you buy.

6 compilation phases, 250+ quality gates, technology targets and a closed taxonomy of 23 concerns.

The Compilation Pipeline

A multi-phase compilation pipeline — like LLVM for enterprise systems. Seven deterministic stages transform a DMX specification into verified, deployable infrastructure.

01

Specification

Define system architecture in DMX — entities, APIs, data flows, security policies, infrastructure topology.

02

Validate

Syntax and correctness verification. Every reference, type, and constraint checked.

03

Compile

100+ cognitive passes across 6 phases. Pure IR transforms — no side effects, fully deterministic.

04

Emission

200+ emitters targeting Python/FastAPI, SQL, Docker, infrastructure, with Java/Spring Boot in testing. Next.js/React frontend is on the 2027 roadmap.

05

Quality Gates

250+ quality gates: BLOCK (fatal), WARN (advisory), INFO (telemetry). OWASP-aligned security checks, performance checks, compliance mapping.

06

Unified Test System

1,000+ generated tests per microservice across four tiers — contracts, behavior, security, enterprise. Nothing reaches the evidence pack unproven.

07

Evidence Pack

Test evidence, CycloneDX 1.5 SBOM, Source Map IR↔code, Build Fingerprint + Merkle root, Ed25519-signed Replay Certificate.

Compilation Stack

Compiles to 130+ production technologies

One DMX specification, full-stack output across languages, frameworks, and infrastructure.

PythonPython
FastAPIFastAPI
JavaJava
Spring BootSpring Boot
PostgreSQLPostgreSQL
RedisRedis
DockerDocker
KubernetesKubernetes
HelmHelm
KongKong
RabbitMQRabbitMQ
NATS
ElasticsearchElasticsearch
ClickHouseClickHouse
MinIOMinIO
PythonPython
FastAPIFastAPI
JavaJava
Spring BootSpring Boot
PostgreSQLPostgreSQL
RedisRedis
DockerDocker
KubernetesKubernetes
HelmHelm
KongKong
RabbitMQRabbitMQ
NATS
ElasticsearchElasticsearch
ClickHouseClickHouse
MinIOMinIO
PythonPython
FastAPIFastAPI
JavaJava
Spring BootSpring Boot
PostgreSQLPostgreSQL
RedisRedis
DockerDocker
KubernetesKubernetes
HelmHelm
KongKong
RabbitMQRabbitMQ
NATS
ElasticsearchElasticsearch
ClickHouseClickHouse
MinIOMinIO
PythonPython
FastAPIFastAPI
JavaJava
Spring BootSpring Boot
PostgreSQLPostgreSQL
RedisRedis
DockerDocker
KubernetesKubernetes
HelmHelm
KongKong
RabbitMQRabbitMQ
NATS
ElasticsearchElasticsearch
ClickHouseClickHouse
MinIOMinIO
SQLAlchemySQLAlchemy
PydanticPydantic
CeleryCelery
VaultVault
PrometheusPrometheus
OpenTelemetryOpenTelemetry
JaegerJaeger
GrafanaGrafana
DatadogDatadog
Alembic
LiquibaseLiquibase
NginxNginx
TraefikTraefik
TerraformTerraform
Argo WorkflowsArgo Workflows
GitHub ActionsGitHub Actions
JUnitJUnit
SQLAlchemySQLAlchemy
PydanticPydantic
CeleryCelery
VaultVault
PrometheusPrometheus
OpenTelemetryOpenTelemetry
JaegerJaeger
GrafanaGrafana
DatadogDatadog
Alembic
LiquibaseLiquibase
NginxNginx
TraefikTraefik
TerraformTerraform
Argo WorkflowsArgo Workflows
GitHub ActionsGitHub Actions
JUnitJUnit
SQLAlchemySQLAlchemy
PydanticPydantic
CeleryCelery
VaultVault
PrometheusPrometheus
OpenTelemetryOpenTelemetry
JaegerJaeger
GrafanaGrafana
DatadogDatadog
Alembic
LiquibaseLiquibase
NginxNginx
TraefikTraefik
TerraformTerraform
Argo WorkflowsArgo Workflows
GitHub ActionsGitHub Actions
JUnitJUnit
SQLAlchemySQLAlchemy
PydanticPydantic
CeleryCelery
VaultVault
PrometheusPrometheus
OpenTelemetryOpenTelemetry
JaegerJaeger
GrafanaGrafana
DatadogDatadog
Alembic
LiquibaseLiquibase
NginxNginx
TraefikTraefik
TerraformTerraform
Argo WorkflowsArgo Workflows
GitHub ActionsGitHub Actions
JUnitJUnit

Compiler Infrastructure

The compilation layer that transforms declarative specifications into verified, production-grade infrastructure. Every component below operates deterministically.

DMX Specification

A declarative specification language for describing complete system architectures — entities, APIs, data flows, security policies, and infrastructure topology.

The Compiler Wall

The architectural boundary between probabilistic input and deterministic output. LLM involvement terminates at spec authoring. Everything beyond the wall — parsing, passes, emission, verification — is zero-randomness infrastructure.

Verification Gates

250+ quality gates across three severity tiers. OWASP-aligned security checks, performance checks, architectural correctness, and security policy enforcement — applied to every compilation artifact.

Test Infrastructure

38,000+ tests generated per compilation across contract, behavior, security, and validation tiers. Full Merkle-tree provenance ensures traceability from specification to every emitted artifact.

System Primitives

Tenant isolation, row-level security, event-driven architecture, saga orchestration, and cross-module communication — compiled as first-class infrastructure primitives, not bolted-on patterns.

Compilation Observability

Real-time compilation telemetry, quality gate reporting, and artifact tracking. Full observability into every stage of the compilation pipeline.

Bring Your Own Stack

Closed Taxonomies, Open Plugins

Each concern declares one technology in the spec; the compiler dispatches to the matching plugin. Default plus registered options below — and your own plugin extends any concern without a compiler fork. No vendor lock-in.

Blob / Object Storage

OBJECT_STORAGE

object_storage.client · presigned URLs · multipart · lifecycle rules

  • S3planned
  • Google Cloud Storage
    Google Cloud Storageplanned
  • Azure Blobplanned
  • MinIO
    MinIOplanned
  • Cloudflare R2
    Cloudflare R2planned

Event Bus Brokers

MESSAGE_BROKER

shared_kernel.event_bus dispatcher

  • Redis Streams
    Redis Streamsplanned
  • Apache Kafka
    Apache Kafkaplanned
  • RabbitMQ
    RabbitMQplanned
  • NATSplanned
  • GCP Pub/Sub
    GCP Pub/Subplanned
  • AWS SNS/SQSplanned

Secrets Management

SECRET_STORE

shared_kernel.secrets · resolver-scheme · 6 backends

  • env-var
    env-var✓
  • HashiCorp Vault
    HashiCorp Vault★
  • AWS KMS★
  • GCP KMS
    GCP KMS★
  • Azure Key Vault★
  • SOPS
    SOPS★

Log Backends

OBSERVABILITY_LOGS

shared_kernel.observability · structured JSON always emitted

  • Loki
    Loki✓
  • CloudWatch Logs★
  • GCP Cloud Logging
    GCP Cloud Logging★
  • Datadog Logs
    Datadog Logs★

Metrics Backends

OBSERVABILITY_METRICS

metrics_emitter · service_observability binding pass

  • Prometheus
    Prometheus✓
  • Datadog Metrics
    Datadog Metrics★
  • CloudWatch Metrics★
  • OpenTelemetry Collector
    OpenTelemetry Collector★

Deployment Descriptors

DEPLOY_TOOL

containers.client umbrella · 6 deploy targets

  • Docker Compose
    Docker Compose✓
  • Helm
    Helm★
  • Terraform
    Terraform★
  • Pulumi
    Pulumi★
  • Nomad
    Nomad★
  • AWS ECS CFN★
Bring your own
Add a tech kind without forking

Register a plugin for any concern. The compiler dispatches automatically.

Safe defaults
Every concern has one

A build refuses to ship if a declared concern has no matching plugin.

Versioned taxonomy
22 concern categories

The supported surface is a closed, versioned taxonomy — not a moving target.

Complementary, not competitive

AI writes. DevMatrix certifies. You need both.

The same data, read as what your current setup is missing rather than as a scoreboard.

Dimension
With DevMatrix
Assistants + deterministic compilation
Code assistants alone
Copilot · Cursor · Claude Code
AI App Builders
Lovable · Replit · v0
Autonomous Agents
Devin · Cognition
Internal AI Factories
Globant Magnifai · Accenture myWizard
Output determinismByte-identical · same spec → same codeProbabilistic per completionNon-deterministic per promptNon-deterministic per runOpaque · vendor-controlled
Signed evidence packSBOM · Replay Cert · Merkle · Source MapNoneNoneNoneVendor reports · not standardized
Audit traceability (IR ↔ code)Every line traced to spec nodeNoneNoneLogs only · not signedInternal · not externally verifiable
Multi-language emissionPython · Java · Next.js · plugin-registeredAny (probabilistic)Locked to vendor stackAny (probabilistic)Vendor-dependent
Closed-taxonomy / BYO plugins23 concerns · Plugin RegistryN/AVendor stack onlyN/AVendor-bound
Multi-spec orchestrationPlatform / Service / App hierarchy + cross-contract closureFile / function scopeSingle-app scopeTicket scopeVendor-specific
Air-gapped deploySupported · signed imageGHE / Cloud onlyVendor cloudVendor cloudPossible · negotiated
IP ownershipSpec + compiler version + emitted source all yoursGenerated text yours · model notCode yours · platform lock-inGenerated code yours · model notCode yours · platform lock-in
Compliance posture (SOC 2 / PCI / DORA / EU CRA)Evidence pack maps directly to controlsVendor SOC 2 onlyLimitedLimitedVendor attestations
Reproducibility for auditorsIndependent replay from spec + versionNot reproducibleNot reproducibleNot reproducibleVendor-mediated

What is DMX?

DMX is a purpose-built specification language for declaring complete software platforms. One .dmx file describes entities, APIs, business flows, sagas, state machines, security policies, and infrastructure — the compiler handles the rest. Write directly (zero LLM) or use LLM-assisted authoring with critic validation. The spec is the auditable source-of-truth: every regenerated artifact is byte-identical and signed.

At a Glance

accounts.dmx
service "accounts" {
version = "1.0.0"
port = 8002
api_prefix = "/v1"
database = "ledger_accounts_db"
compliance ["SOC2", "PCI-DSS", "DORA"]
depends_on {
identity imports [Tenant, Customer]
}
}
entity Account {
@aggregate_root
@tenancy(tenant, tenant_id)
@soft_delete
id UUID @pk @default($computed.uuid)
tenant_id UUID @fk(Tenant.id) @not_null
owner_id UUID @fk(Customer.id) @not_null
iban String(34) @unique @sensitive
currency String(3) @iso4217 @not_null
balance Money @not_null @default(0)
status Enum(ACTIVE, FROZEN, CLOSED) @default("ACTIVE")
opened_at DateTime @default($computed.now)
}
api {
POST "/accounts" {
permissions = ["accounts:open"]
request {
owner_id UUID @required
currency String(3) @required
}
response @entity(Account) @status(201)
}
POST "/accounts/{id}/freeze" {
permissions = ["accounts:freeze"]
triggers = Account.status -> FROZEN
response @entity(Account)
}
}

Cross-Service Interactions

Declare how services in a platform talk to each other — synchronous HTTP, asynchronous events (message brokers are planned, not available today), or orchestrated sagas with transactional outbox. The compiler emits client, server route, broker wiring, and the compensation paths.

platform.dmx
platform "LedgerPlatform" {
modules {
identity { spec = "identity.dmx" }
accounts { spec = "accounts.dmx" }
payments { spec = "payments.dmx" }
audit { spec = "audit.dmx" }
}
// Sync HTTP — accounts resolves customer within its own request
interactions {
"I-10: Accounts resolves customer" {
tier = 1
provider = identity
consumer = accounts
trigger = http(method="GET", path="/customers/{id}")
response_schema = CustomerDTO
timeout_ms = 500
idempotent = true
}
// Saga — atomic money transfer with compensation
"I-11: Transfer saga" {
tier = 1
orchestrator = payments
participants = [accounts, accounts]
trigger = saga("transfer.requested")
steps = [debit_source, credit_target, settle]
compensation = [reverse_credit, reverse_debit]
outbox = true
}
// Async event — audit logs every state transition
"I-12: Transfer audited" {
tier = 2
producer = payments
consumer = audit
trigger = event("payments.transfer.settled")
payload { transfer_id UUID @required }
}
}
}

Loading verified availability…